bitfab 0.61.2 → 0.61.4

package/dist/{chunk-A4UVO6BQ.js → chunk-PSAEQ4OW.js}

@@ -4,8 +4,9 @@ import {
   flushTraces,
   gitRunner,
   replayContextReady,
-  runWithReplayContext
-} from "./chunk-INA6W7OB.js";
+  runWithReplayContext,
+  unrefTimer
+} from "./chunk-54EGXUZ3.js";
 import {
   runWithCaptureSuppressed,
   warnOnce
@@ -437,6 +438,373 @@ function fallbackUuidV4() {
   });
 }
 
+// src/replayHeartbeat.ts
+var REPLAY_HEARTBEAT_INTERVAL_MS = 6e4;
+function startReplayHeartbeat(send) {
+  let stopped = false;
+  let inFlight;
+  const timer = setInterval(() => {
+    if (stopped || inFlight !== void 0) {
+      return;
+    }
+    inFlight = send().catch(() => void 0).finally(() => {
+      inFlight = void 0;
+    });
+  }, REPLAY_HEARTBEAT_INTERVAL_MS);
+  unrefTimer(timer);
+  return {
+    stop: async () => {
+      stopped = true;
+      clearInterval(timer);
+      await inFlight;
+    }
+  };
+}
+
+// src/replayInterrupt.ts
+var REPLAY_INTERRUPT_SIGNALS = [
+  "SIGINT",
+  "SIGTERM"
+];
+function signalCapableProcess() {
+  if (typeof process === "undefined" || typeof process.on !== "function") {
+    return void 0;
+  }
+  return process;
+}
+function describeReplayInterrupt(experimentId, markedInterrupted) {
+  if (markedInterrupted) {
+    return `[replay] Experiment ${experimentId} interrupted.`;
+  }
+  return `[replay] Experiment ${experimentId} stopped, but Bitfab could not mark it interrupted. It will be marked interrupted within 15 minutes. A resume in the next two minutes may be refused as still running.`;
+}
+function reportInterrupted(experimentId, markedInterrupted) {
+  try {
+    console.error(describeReplayInterrupt(experimentId, markedInterrupted));
+  } catch {
+  }
+}
+function installReplayInterruptHandlers(target) {
+  const host = signalCapableProcess();
+  if (host === void 0) {
+    return { remove: () => {
+    }, interrupted: () => false };
+  }
+  const handlers = /* @__PURE__ */ new Map();
+  const removeHandlers = () => {
+    for (const [signal, handler] of handlers) {
+      host.removeListener(signal, handler);
+    }
+    handlers.clear();
+  };
+  let interrupting = false;
+  const handleSignal = async (signal) => {
+    const hostHandlesSignal = host.listenerCount(signal) > 1;
+    const markedInterrupted = await target.interrupt();
+    removeHandlers();
+    if (target.onInterrupt !== void 0) {
+      try {
+        target.onInterrupt({
+          experimentId: target.experimentId,
+          experimentUrl: target.experimentUrl,
+          signal,
+          markedInterrupted
+        });
+      } catch {
+      }
+      return;
+    }
+    reportInterrupted(target.experimentId, markedInterrupted);
+    if (!hostHandlesSignal) {
+      host.kill(host.pid, signal);
+    }
+  };
+  for (const signal of REPLAY_INTERRUPT_SIGNALS) {
+    const handler = () => {
+      if (interrupting) {
+        return;
+      }
+      interrupting = true;
+      void handleSignal(signal);
+    };
+    handlers.set(signal, handler);
+    host.on(signal, handler);
+  }
+  return { remove: removeHandlers, interrupted: () => interrupting };
+}
+
+// src/selectiveReplay.ts
+function replayNodeKey(node) {
+  return JSON.stringify([node.traceFunctionKey, node.spanName]);
+}
+function jsonFingerprint(value) {
+  const seen = /* @__PURE__ */ new Set();
+  function encode(input) {
+    if (input === null || typeof input === "boolean") {
+      return JSON.stringify(input);
+    }
+    if (typeof input === "string" && !input.startsWith("<unserializable")) {
+      return JSON.stringify(input);
+    }
+    if (typeof input === "number" && Number.isFinite(input) && !Object.is(input, -0)) {
+      return JSON.stringify(input);
+    }
+    if (typeof input !== "object" || input === null || seen.has(input)) {
+      throw new Error("Not a lossless JSON value");
+    }
+    seen.add(input);
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== (Array.isArray(input) ? Array.prototype : Object.prototype)) {
+      throw new Error("Not a plain JSON object");
+    }
+    if (Object.getOwnPropertySymbols(input).length > 0) {
+      throw new Error("Symbol properties are not recorded");
+    }
+    const keys = Object.keys(input);
+    if (Object.getOwnPropertyNames(input).length !== keys.length + (Array.isArray(input) ? 1 : 0)) {
+      throw new Error("Non-enumerable properties are not recorded");
+    }
+    if (Array.isArray(input) && (keys.length !== input.length || keys.some((key, index) => key !== String(index)))) {
+      throw new Error("Not a dense JSON array");
+    }
+    const properties = keys.map((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(input, key);
+      if (!descriptor || !("value" in descriptor)) {
+        throw new Error("Accessor properties are not replay inputs");
+      }
+      return `${Array.isArray(input) ? "" : `${JSON.stringify(key)}:`}${encode(descriptor.value)}`;
+    });
+    return Array.isArray(input) ? `[${properties.join(",")}]` : `{${properties.join(",")}}`;
+  }
+  try {
+    return encode(value);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/selectiveReplayRuntime.ts
+function validateSelectiveReplayOptions(options) {
+  const validNodes = (nodes) => Array.isArray(nodes) && nodes.length <= 100 && nodes.every(
+    (node) => typeof node?.traceFunctionKey === "string" && node.traceFunctionKey.length > 0 && node.traceFunctionKey.length <= 500 && typeof node.spanName === "string" && node.spanName.length > 0 && node.spanName.length <= 500
+  );
+  if (!options || !validNodes(options.mustRun) || options.mustRun.length === 0 || Object.keys(options).some((key) => key !== "mustRun")) {
+    throw new BitfabError(
+      "experimentalSelectiveReplay accepts only 1\u2013100 mustRun with traceFunctionKey and spanName. Declare replayReusable on eligible spans, not reusableNodes in the replay request."
+    );
+  }
+}
+function policyKey(options) {
+  return JSON.stringify(options.mustRun.map(replayNodeKey).sort());
+}
+var SelectiveReplayRuntime = class {
+  constructor(plan, options) {
+    this.plan = plan;
+    this.options = options;
+    this.nodes = /* @__PURE__ */ new Map();
+    this.children = /* @__PURE__ */ new Map();
+    this.runtimeParents = /* @__PURE__ */ new Map();
+    this.consumed = /* @__PURE__ */ new Map();
+    this.requiredScopes = /* @__PURE__ */ new Set();
+    this.recordings = /* @__PURE__ */ new Map();
+    this.reached = /* @__PURE__ */ new Set();
+    this.decisions = [];
+    this.assertionNames = /* @__PURE__ */ new Set();
+    this.assertionScopes = /* @__PURE__ */ new Set();
+    this.observedNames = /* @__PURE__ */ new Map();
+    this.unresolvedAssertions = [];
+    validateSelectiveReplayOptions(options);
+    if (plan?.version !== 4 || !Array.isArray(plan.nodes) || plan.nodes.length === 0 || plan.nodes.length > 500 || !Array.isArray(plan.unresolvedMustRun) || !Array.isArray(plan.assertions) || !plan.options) {
+      throw new BitfabError(
+        "Server did not return a compatible selective replay plan. Update the server or disable experimentalSelectiveReplay."
+      );
+    }
+    validateSelectiveReplayOptions(plan.options);
+    if (policyKey(plan.options) !== policyKey(options)) {
+      throw new BitfabError(
+        "Selective replay plan does not match the requested mustRun nodes."
+      );
+    }
+    this.required = new Set(options.mustRun.map(replayNodeKey));
+    for (const node of plan.nodes) {
+      if (typeof node.id !== "string" || this.nodes.has(node.id) || typeof node.traceFunctionKey !== "string" || typeof node.spanName !== "string" || typeof node.mustRun !== "boolean" || typeof node.reusable !== "boolean") {
+        throw new BitfabError("Invalid selective replay node.");
+      }
+      this.nodes.set(node.id, node);
+      if (node.recording !== void 0) {
+        this.recordings.set(node.id, {
+          input: node.recording.kwargs === void 0 ? jsonFingerprint(node.recording.input) : void 0,
+          output: jsonFingerprint(node.recording.output)
+        });
+      }
+      if (node.parentId !== null) {
+        const siblings = this.children.get(node.parentId) ?? [];
+        siblings.push(node);
+        this.children.set(node.parentId, siblings);
+      }
+    }
+    const root = this.nodes.get(plan.rootId);
+    if (!root || root.parentId !== null || !root.mustRun) {
+      throw new BitfabError("Selective replay requires a live recorded root.");
+    }
+    const assertionIds = /* @__PURE__ */ new Set();
+    let wholeTrace = false;
+    for (const assertion of plan.assertions) {
+      const target = assertion?.target;
+      if (typeof assertion?.id !== "string" || assertion.id.length === 0 || assertionIds.has(assertion.id) || target !== null && (typeof target !== "object" || target.kind !== "output" && target.kind !== "span")) {
+        throw new BitfabError(
+          "Invalid selective replay assertion requirements."
+        );
+      }
+      assertionIds.add(assertion.id);
+      if (target === null) {
+        wholeTrace = true;
+      } else if (target.kind === "span") {
+        if (typeof target.name !== "string" || target.name.length === 0 || target.occurrence !== void 0 && target.occurrence !== "first" && target.occurrence !== "last" && !(Number.isInteger(target.occurrence) && typeof target.occurrence === "number" && target.occurrence >= 0)) {
+          throw new BitfabError("Invalid selective replay assertion target.");
+        }
+        this.assertionNames.add(target.name);
+        const count = plan.nodes.filter(
+          (node) => node.spanName === target.name
+        ).length;
+        if (count <= (typeof target.occurrence === "number" ? target.occurrence : 0)) {
+          this.unresolvedAssertions.push(assertion.id);
+        }
+      }
+    }
+    this.fullTraceForAssertions = wholeTrace || this.unresolvedAssertions.length > 0;
+    const recordedKeys = new Set(plan.nodes.map(replayNodeKey));
+    const unresolved = options.mustRun.filter(
+      (node) => !recordedKeys.has(replayNodeKey(node))
+    );
+    if (JSON.stringify(unresolved.map(replayNodeKey).sort()) !== JSON.stringify(plan.unresolvedMustRun.map(replayNodeKey).sort())) {
+      throw new BitfabError(
+        "Selective replay plan has incomplete mustRun coverage."
+      );
+    }
+    for (const node of plan.nodes) {
+      const ancestors = /* @__PURE__ */ new Set([node.id]);
+      let requiredByManifest = this.required.has(replayNodeKey(node));
+      let requiredForAssertion = this.fullTraceForAssertions || this.assertionNames.has(node.spanName);
+      let parentId = node.parentId;
+      while (parentId !== null) {
+        const parent = this.nodes.get(parentId);
+        if (!parent || ancestors.has(parentId) || node.mustRun && !parent.mustRun) {
+          throw new BitfabError("Invalid selective replay ancestry.");
+        }
+        ancestors.add(parentId);
+        requiredByManifest || (requiredByManifest = this.required.has(replayNodeKey(parent)));
+        requiredForAssertion || (requiredForAssertion = this.assertionNames.has(parent.spanName));
+        parentId = parent.parentId;
+      }
+      if (!ancestors.has(plan.rootId) || (requiredByManifest || unresolved.length > 0) && !node.mustRun) {
+        throw new BitfabError("Selective replay plan could hide required code.");
+      }
+      if (requiredForAssertion && !node.mustRun) {
+        throw new BitfabError(
+          "Selective replay plan could hide assertion evidence."
+        );
+      }
+    }
+  }
+  enter(params) {
+    const identity = {
+      traceFunctionKey: params.traceFunctionKey,
+      spanName: params.spanName
+    };
+    const key = replayNodeKey(identity);
+    const fingerprint = jsonFingerprint(params.inputs);
+    let node;
+    let matchReason = "unmatched-call";
+    if (params.parentSpanId === null) {
+      node = this.nodes.get(this.plan.rootId);
+    } else {
+      const recordedParent = this.runtimeParents.get(params.parentSpanId);
+      const consumed = this.consumed.get(params.parentSpanId) ?? /* @__PURE__ */ new Set();
+      this.consumed.set(params.parentSpanId, consumed);
+      const candidates = recordedParent ? (this.children.get(recordedParent) ?? []).filter(
+        (candidate) => replayNodeKey(candidate) === key && !consumed.has(candidate.id)
+      ) : [];
+      const exact = fingerprint === void 0 ? [] : candidates.filter(
+        (candidate) => this.recordings.get(candidate.id)?.input === fingerprint
+      );
+      node = exact.length === 1 ? exact[0] : exact.length === 0 && candidates.length === 1 ? candidates[0] : void 0;
+      if (node) {
+        consumed.add(node.id);
+      } else if (candidates.length > 0) {
+        matchReason = "ambiguous-call";
+        for (const candidate of candidates) {
+          consumed.add(candidate.id);
+        }
+      }
+    }
+    this.runtimeParents.set(params.spanId, node?.id ?? null);
+    const requiredByManifest = this.required.has(key) || params.parentSpanId !== null && this.requiredScopes.has(params.parentSpanId);
+    if (requiredByManifest) {
+      this.requiredScopes.add(params.spanId);
+    }
+    const requiredForAssertion = this.fullTraceForAssertions || this.assertionNames.has(params.spanName) || params.parentSpanId !== null && this.assertionScopes.has(params.parentSpanId);
+    if (requiredForAssertion) {
+      this.assertionScopes.add(params.spanId);
+    }
+    const mustRun = params.parentSpanId === null || requiredByManifest || node?.mustRun === true || requiredForAssertion || this.plan.unresolvedMustRun.length > 0;
+    const recording = node === void 0 ? void 0 : this.recordings.get(node.id);
+    const equalInputs = fingerprint !== void 0 && recording?.input === fingerprint;
+    const reusable = recording?.output !== void 0 && equalInputs && params.canReuseOutput;
+    const reason = mustRun ? requiredByManifest ? "must-run" : requiredForAssertion ? "assertion" : node?.reason ?? "unresolved-must-run" : !node ? matchReason : !equalInputs ? "input-drift-or-missing-recording" : !params.canReuseOutput ? "unsupported-output-boundary" : !params.safetyMock && !params.reuseAllowed ? "reuse-not-declared" : node.reason;
+    const decision = (action, why) => {
+      this.decisions.push({
+        ...identity,
+        originalSpanId: node?.id ?? null,
+        action,
+        reason: why
+      });
+    };
+    if (params.safetyMock && (mustRun || !reusable)) {
+      decision("blocked", `safety-conflict:${reason}`);
+      this.failure = new BitfabError(
+        `Selective replay cannot execute or safely reuse safety-mocked node ${params.spanName} (${reason}).`
+      );
+      throw this.failure;
+    }
+    if (!mustRun && reusable && (params.safetyMock || node?.reusable === true && params.reuseAllowed)) {
+      decision("mock", params.safetyMock ? "safety-mock" : "unchanged-inputs");
+      return {
+        mock: true,
+        output: JSON.parse(recording.output)
+      };
+    }
+    decision("run", reason);
+    this.observedNames.set(
+      params.spanName,
+      (this.observedNames.get(params.spanName) ?? 0) + 1
+    );
+    if (this.required.has(key)) {
+      this.reached.add(key);
+    }
+    return { mock: false };
+  }
+  assertNoSafetyConflict() {
+    if (this.failure) {
+      throw this.failure;
+    }
+  }
+  report() {
+    return {
+      decisions: this.decisions,
+      mustRunNotReached: this.options.mustRun.filter(
+        (node) => !this.reached.has(replayNodeKey(node))
+      ),
+      unresolvedMustRun: this.plan.unresolvedMustRun,
+      assertionIds: this.plan.assertions.map((assertion) => assertion.id),
+      unresolvedAssertions: this.unresolvedAssertions,
+      assertionTargetsNotReached: this.plan.assertions.flatMap(
+        ({ id, target }) => target?.kind === "span" && (this.observedNames.get(target.name) ?? 0) <= (typeof target.occurrence === "number" ? target.occurrence : 0) ? [id] : []
+      )
+    };
+  }
+};
+
 // src/replay.ts
 var REPLAY_PERSISTENCE_TIMEOUT_MS = 3e4;
 var MAX_REPLAY_ATTEMPTS = 100;
@@ -454,7 +822,8 @@ var RESUME_CONFLICTING_OPTIONS = [
   "attempts",
   "graderIds",
   "onlyWithAssertions",
-  "dryRun"
+  "dryRun",
+  "experimentalSelectiveReplay"
 ];
 var CARRIED_OVER_ERROR = "This item errored in an earlier run of this experiment, before it was resumed.";
 function validateResume(resume, options) {
@@ -715,7 +1084,7 @@ function buildMockTree(rootNode) {
   }
   return { spans };
 }
-async function processItem(httpClient, serverItem, fn, experimentId, mockStrategy, resolvedOverrides, replayedTraceId, attempt, includeDbBranchLease, dbBranchSettings, adaptInputs, dryRun) {
+async function processItem(httpClient, serverItem, fn, experimentId, mockStrategy, resolvedOverrides, replayedTraceId, attempt, includeDbBranchLease, dbBranchSettings, adaptInputs, dryRun, selectiveOptions) {
   let lease = includeDbBranchLease ? serverItem.dbBranchLease : void 0;
   let leaseError = includeDbBranchLease ? serverItem.dbBranchLeaseError : void 0;
   let dbSnapshotRef = serverItem.dbSnapshotRef;
@@ -728,6 +1097,7 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
   let replayError = null;
   let replayDurationMs = null;
   let replayStarted = null;
+  let selectiveReplay;
   const originalTraceId = serverItem.originalTraceId ?? serverItem.sourceTraceId;
   const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
   try {
@@ -760,6 +1130,17 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
         originalTraceId
       );
     }
+    if (selectiveOptions !== void 0) {
+      if (serverItem.selectiveReplayPlan === void 0) {
+        throw new BitfabError(
+          "Server did not return a selective replay plan. Update the server or disable experimentalSelectiveReplay."
+        );
+      }
+      selectiveReplay = new SelectiveReplayRuntime(
+        serverItem.selectiveReplayPlan,
+        selectiveOptions
+      );
+    }
     const span = await httpClient.getExternalSpan(originalSpanId, {
       view: "replay"
     });
@@ -779,7 +1160,7 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
       });
     }
     const hasOverrides = resolvedOverrides.length > 0;
-    const needTree = mockStrategy === "all" || mockStrategy === "marked" || hasOverrides;
+    const needTree = selectiveReplay === void 0 && (mockStrategy === "all" || mockStrategy === "marked" || hasOverrides);
     const includeOutputs = mockStrategy === "all";
     let mockTree;
     if (needTree) {
@@ -854,6 +1235,7 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
           sourceBitfabTraceId: originalTraceId,
           replayAttempt: attempt,
           mockTree,
+          selectiveReplay,
           callCounters: mockTree ? /* @__PURE__ */ new Map() : void 0,
           mockStrategy,
           mockOverrides: hasOverrides ? resolvedOverrides : void 0,
@@ -865,6 +1247,7 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
         () => fn(...inputs)
       );
       result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
+      selectiveReplay?.assertNoSafetyConflict();
       replayDurationMs = Math.round(performance.now() - replayStarted);
     } catch (e) {
       if (replayStarted !== null) {
@@ -916,6 +1299,7 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
     traceError,
     replayError,
     durationMs: replayDurationMs,
+    ...selectiveReplay === void 0 ? {} : { selectiveReplay: selectiveReplay.report() },
     originalDurationMs,
     originalTokens: serverItem.originalTokens ?? serverItem.tokens ?? null,
     originalModel,
@@ -1020,6 +1404,14 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       "force only applies when resuming an experiment. Pass it together with resume."
     );
   }
+  if (options?.experimentalSelectiveReplay !== void 0) {
+    validateSelectiveReplayOptions(options.experimentalSelectiveReplay);
+    if ((options.mock ?? "marked") !== "marked" || normalizeMockOverrides(options.mockOverride).length > 0 || registeredOverrides.length > 0) {
+      throw new BitfabError(
+        "experimentalSelectiveReplay requires mock: 'marked' and cannot be combined with mock overrides."
+      );
+    }
+  }
   if (options?.traceIds !== void 0) {
     if (options.traceIds.length === 0) {
       throw new BitfabError("traceIds must contain at least one trace ID.");
@@ -1061,7 +1453,7 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
   const includeDbBranchLease = dbBranchEnabled(options?.dbBranch) && options?.dryRun !== true;
   let session;
   if (options?.resume === void 0) {
-    const started2 = await httpClient.startReplay(
+    const started = await httpClient.startReplay(
       traceFunctionKey,
       // limit is meaningless with explicit traceIds (the ID list determines
       // the count), so it's omitted from the request entirely.
@@ -1081,9 +1473,10 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       requestedAttempts,
       options?.adaptInputs !== void 0,
       options?.onlyWithAssertions,
-      options?.judgeAssertions
+      options?.judgeAssertions,
+      options?.experimentalSelectiveReplay
     );
-    if (started2.items.length === 0) {
+    if (started.items.length === 0) {
       try {
         console.warn(
           `Bitfab: no traces matched "${traceFunctionKey}", so this replay ran nothing. Capture a trace, or seed one with seedTrace, before replaying.`
@@ -1092,10 +1485,10 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       }
     }
     session = {
-      experimentId: started2.experimentId,
-      experimentUrl: started2.experimentUrl,
+      experimentId: started.experimentId,
+      experimentUrl: started.experimentUrl,
       attempts: requestedAttempts,
-      work: expandReplayWork(started2.items, requestedAttempts),
+      work: expandReplayWork(started.items, requestedAttempts),
       finished: [],
       includeDbBranchLease,
       dbBranchSettings: resolveDbBranchSettings(options?.dbBranch)
@@ -1110,9 +1503,68 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       options.dbBranch
     );
   }
-  const { experimentId, experimentUrl, attempts } = session;
+  const { experimentId } = session;
+  const fullExperimentUrl = `${serviceUrl}${session.experimentUrl}`;
+  const heartbeat = startReplayHeartbeat(
+    () => httpClient.heartbeatReplay(experimentId)
+  );
+  const interruptReplay = async () => {
+    await heartbeat.stop();
+    return httpClient.interruptReplay(experimentId);
+  };
+  const interruptHandlers = installReplayInterruptHandlers({
+    experimentId,
+    experimentUrl: fullExperimentUrl,
+    interrupt: interruptReplay,
+    onInterrupt: options?.onInterrupt
+  });
+  let completeReturned = false;
+  const markCompleteReturned = () => {
+    completeReturned = true;
+    void heartbeat.stop();
+  };
+  try {
+    return await runReplaySession(
+      httpClient,
+      fn,
+      session,
+      fullExperimentUrl,
+      maxConcurrency,
+      interruptHandlers.remove,
+      markCompleteReturned,
+      interruptHandlers.interrupted,
+      options,
+      registeredOverrides
+    );
+  } catch (error) {
+    if (!completeReturned && !interruptHandlers.interrupted()) {
+      await interruptReplay();
+    }
+    throw error;
+  } finally {
+    interruptHandlers.remove();
+    await heartbeat.stop();
+  }
+}
+function throwIfInterrupted(interrupted, items, experimentId, experimentUrl) {
+  if (!interrupted()) {
+    return;
+  }
+  const cause = new BitfabError(
+    `Experiment ${experimentId} was interrupted, so it was not completed or graded. Resume it by passing { resume: "${experimentId}" } to replay, or with bitfab-replay --resume ${experimentId}.`,
+    experimentUrl
+  );
+  throw new ReplayError(
+    cause.message,
+    items,
+    experimentId,
+    experimentUrl,
+    cause
+  );
+}
+async function runReplaySession(httpClient, fn, session, fullExperimentUrl, maxConcurrency, stopInterruptingOnSignal, markCompleteReturned, interrupted, options, registeredOverrides) {
+  const { experimentId, attempts } = session;
   const mockStrategy = options?.mock ?? "marked";
-  const fullExperimentUrl = `${serviceUrl}${experimentUrl}`;
   try {
     options?.onExperimentStart?.({
       experimentId,
@@ -1143,7 +1595,8 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       session.includeDbBranchLease,
       session.dbBranchSettings,
       options?.adaptInputs,
-      options?.dryRun === true
+      options?.dryRun === true,
+      options?.experimentalSelectiveReplay
     )
   );
   const total = tasks.length + carriedOverItems.length;
@@ -1216,6 +1669,7 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
             traceError: item.traceError,
             replayError: item.replayError,
             durationMs: item.durationMs,
+            ...item.selectiveReplay === void 0 ? {} : { selectiveReplay: item.selectiveReplay },
             originalDurationMs: item.originalDurationMs,
             originalTokens: item.originalTokens,
             originalModel: item.originalModel,
@@ -1260,7 +1714,15 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
   );
   const resultItems = [...carriedOverItems, ...ranItems];
   if (options?.dryRun === true) {
+    throwIfInterrupted(
+      interrupted,
+      resultItems,
+      experimentId,
+      fullExperimentUrl
+    );
+    stopInterruptingOnSignal();
     await httpClient.completeReplay(experimentId).catch(() => void 0);
+    markCompleteReturned();
     const dryResult = {
       items: resultItems,
       experimentId,
@@ -1285,12 +1747,15 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       ranItems[index].traceId = readBack;
     }
   }
+  throwIfInterrupted(interrupted, resultItems, experimentId, fullExperimentUrl);
+  stopInterruptingOnSignal();
   const completeResult = await preserveReplayFailure(
     () => httpClient.completeReplay(experimentId),
     resultItems,
     experimentId,
     fullExperimentUrl
   );
+  markCompleteReturned();
   const serverTraceIds = completeResult.traceIds;
   const replayTokens = completeResult.tokens;
   if (serverTraceIds !== void 0) {
@@ -1403,4 +1868,4 @@ export {
   sleepForReplayPersistence,
   replay
 };
-//# sourceMappingURL=chunk-A4UVO6BQ.js.map
+//# sourceMappingURL=chunk-PSAEQ4OW.js.map