@bitfab/sdk 0.61.2 → 0.61.4

package/dist/node.cjs

@@ -88,7 +88,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.61.2";
+    __version__ = "0.61.4";
     __packageName__ = "@bitfab/sdk";
   }
 });
@@ -1075,6 +1075,7 @@ var init_simulationPlan = __esm({
       "input_meta",
       "output",
       "output_meta",
+      "replay_recording",
       "prompt"
     ];
     SimulationPlan = class {
@@ -2283,7 +2284,7 @@ function warnDroppedExternalTrace(error) {
 function experimentIdWireFields(experimentId) {
   return { experimentId, testRunId: experimentId };
 }
-var REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS, REPLAY_COMPLETE_REQUEST_TIMEOUT_MS, OTLP_TRACES_ENDPOINT, RETRYABLE_STATUSES, EXIT_FLUSH_TIMEOUT_MS, DEFAULT_LIFECYCLE_TIMEOUT_MS2, pendingTracePromises, liveHttpClients, carrierSeq, HttpClient;
+var REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS, REPLAY_COMPLETE_REQUEST_TIMEOUT_MS, REPLAY_INTERRUPT_REQUEST_TIMEOUT_MS, REPLAY_HEARTBEAT_REQUEST_TIMEOUT_MS, OTLP_TRACES_ENDPOINT, RETRYABLE_STATUSES, EXIT_FLUSH_TIMEOUT_MS, DEFAULT_LIFECYCLE_TIMEOUT_MS2, pendingTracePromises, liveHttpClients, carrierSeq, HttpClient;
 var init_http = __esm({
   "src/http.ts"() {
     "use strict";
@@ -2302,6 +2303,8 @@ var init_http = __esm({
     init_warnOnce();
     REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS = 3e5;
     REPLAY_COMPLETE_REQUEST_TIMEOUT_MS = 12e4;
+    REPLAY_INTERRUPT_REQUEST_TIMEOUT_MS = 5e3;
+    REPLAY_HEARTBEAT_REQUEST_TIMEOUT_MS = 5e3;
     OTLP_TRACES_ENDPOINT = "/api/sdk/otel/v1/traces";
     RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
     EXIT_FLUSH_TIMEOUT_MS = 5e3;
@@ -2889,8 +2892,11 @@ var init_http = __esm({
        * Start a replay session by fetching historical traces.
        * Blocking call - creates an experiment and returns lightweight item references.
        */
-      async startReplay(traceFunctionKey, limit, traceIds, name, codeChangeDescription, codeChangeFiles, includeDbBranchLease, experimentGroupId, datasetIds, graderIds, dbBranchSettings, attempts, includeOriginalMetadata, onlyWithAssertions, judgeAssertions) {
+      async startReplay(traceFunctionKey, limit, traceIds, name, codeChangeDescription, codeChangeFiles, includeDbBranchLease, experimentGroupId, datasetIds, graderIds, dbBranchSettings, attempts, includeOriginalMetadata, onlyWithAssertions, judgeAssertions, experimentalSelectiveReplay) {
         const payload = { traceFunctionKey };
+        if (experimentalSelectiveReplay !== void 0) {
+          payload.experimentalSelectiveReplay = experimentalSelectiveReplay;
+        }
         if (limit !== void 0) {
           payload.limit = limit;
         }
@@ -3111,6 +3117,28 @@ var init_http = __esm({
           { timeout: REPLAY_COMPLETE_REQUEST_TIMEOUT_MS }
         );
       }
+      async interruptReplay(experimentId) {
+        try {
+          await this.request(
+            "/api/sdk/replay/interrupt",
+            experimentIdWireFields(experimentId),
+            { timeout: REPLAY_INTERRUPT_REQUEST_TIMEOUT_MS }
+          );
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async heartbeatReplay(experimentId) {
+        try {
+          await this.request(
+            "/api/sdk/replay/heartbeat",
+            experimentIdWireFields(experimentId),
+            { timeout: REPLAY_HEARTBEAT_REQUEST_TIMEOUT_MS }
+          );
+        } catch {
+        }
+      }
       async getReseedSource(traceId) {
         return this.get(
           `/api/sdk/traces/${encodeURIComponent(traceId)}/reseedSource`
@@ -3614,6 +3642,399 @@ var init_integrationFixture = __esm({
   }
 });
 
+// src/replayHeartbeat.ts
+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;
+    }
+  };
+}
+var REPLAY_HEARTBEAT_INTERVAL_MS;
+var init_replayHeartbeat = __esm({
+  "src/replayHeartbeat.ts"() {
+    "use strict";
+    init_unrefTimer();
+    REPLAY_HEARTBEAT_INTERVAL_MS = 6e4;
+  }
+});
+
+// src/replayInterrupt.ts
+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 };
+}
+var REPLAY_INTERRUPT_SIGNALS;
+var init_replayInterrupt = __esm({
+  "src/replayInterrupt.ts"() {
+    "use strict";
+    REPLAY_INTERRUPT_SIGNALS = [
+      "SIGINT",
+      "SIGTERM"
+    ];
+  }
+});
+
+// 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;
+  }
+}
+var init_selectiveReplay = __esm({
+  "src/selectiveReplay.ts"() {
+    "use strict";
+  }
+});
+
+// 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;
+var init_selectiveReplayRuntime = __esm({
+  "src/selectiveReplayRuntime.ts"() {
+    "use strict";
+    init_errors();
+    init_selectiveReplay();
+    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_exports = {};
 __export(replay_exports, {
@@ -3869,7 +4290,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;
@@ -3882,6 +4303,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 {
@@ -3914,6 +4336,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"
     });
@@ -3933,7 +4366,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) {
@@ -4008,6 +4441,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,
@@ -4019,6 +4453,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) {
@@ -4070,6 +4505,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,
@@ -4174,6 +4610,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.");
@@ -4215,7 +4659,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.
@@ -4235,9 +4679,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.`
@@ -4246,10 +4691,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)
@@ -4264,9 +4709,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,
@@ -4297,7 +4801,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;
@@ -4370,6 +4875,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,
@@ -4414,7 +4920,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,
@@ -4439,12 +4953,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) {
@@ -4548,6 +5065,9 @@ var init_replay = __esm({
     init_mockOverride();
     init_randomUuid();
     init_replayContext();
+    init_replayHeartbeat();
+    init_replayInterrupt();
+    init_selectiveReplayRuntime();
     init_serialize();
     REPLAY_PERSISTENCE_TIMEOUT_MS = 3e4;
     MAX_REPLAY_ATTEMPTS = 100;
@@ -4559,7 +5079,8 @@ var init_replay = __esm({
       "attempts",
       "graderIds",
       "onlyWithAssertions",
-      "dryRun"
+      "dryRun",
+      "experimentalSelectiveReplay"
     ];
     CARRIED_OVER_ERROR = "This item errored in an earlier run of this experiment, before it was resumed.";
     BITFAB_PROGRESS_PREFIX = "@@bitfab:progress ";
@@ -9260,6 +9781,9 @@ var Bitfab = class {
       ...options.mockOnReplay !== void 0 && {
         mockOnReplay: options.mockOnReplay
       },
+      ...options.replayReusable !== void 0 && {
+        replayReusable: options.replayReusable
+      },
       ...options.finalize !== void 0 && { finalize: options.finalize }
     };
   }
@@ -9408,6 +9932,9 @@ var Bitfab = class {
               ...mockOnReplay !== void 0 && {
                 mockOnReplay
               },
+              ...nodeConfiguration?.replayReusable !== void 0 && {
+                replayReusable: nodeConfiguration.replayReusable
+              },
               ...nodeConfiguration?.finalize !== void 0 && {
                 finalize: nodeConfiguration.finalize
               }
@@ -10205,6 +10732,7 @@ var Bitfab = class {
           instrumentation: options.instrumentation ?? "span",
           functionId: options.functionId,
           captureContent: options.captureContent ?? true,
+          replayReusable: options.replayReusable,
           autoTraceDefinition: options.autoTraceDefinition,
           declaredNode: options.declaredNode === true,
           nestedTrace: options.nestedTrace,
@@ -10324,6 +10852,27 @@ var Bitfab = class {
           return result;
         };
         const replayCtxForMock = getReplayContext();
+        if (replayCtxForMock?.selectiveReplay) {
+          const decision = replayCtxForMock.selectiveReplay.enter({
+            traceFunctionKey,
+            spanName: baseSpanParams.spanName ?? traceFunctionKey,
+            spanId,
+            parentSpanId,
+            inputs: args,
+            safetyMock: !isRootSpan && options.mockOnReplay === true,
+            reuseAllowed: options.replayReusable === true,
+            canReuseOutput: options.finalize === void 0 && options.replayOutput === void 0 && !fn.constructor.name.includes("Generator")
+          });
+          if (decision.mock) {
+            void sendSpan({
+              result: decision.output,
+              mocked: true,
+              mockTarget: "output",
+              mockSource: "recorded"
+            });
+            return fnReturnsPromise ? Promise.resolve(decision.output) : decision.output;
+          }
+        }
         if (replayCtxForMock?.mockTree && !isRootSpan) {
           const counters = replayCtxForMock.callCounters;
           const counterKey = `${traceFunctionKey}:${baseSpanParams.spanName}`;
@@ -10747,6 +11296,9 @@ var Bitfab = class {
       span_origin: makeSpanOrigin(params.instrumentation),
       span_data: {
         name: params.spanName,
+        ...params.replayReusable !== void 0 && {
+          replay_reusable: params.replayReusable
+        },
         type: params.spanType,
         ...params.functionId !== void 0 && {
           function_id: params.functionId,
@@ -11298,6 +11850,7 @@ init_replay();
 // src/replayRegistry.ts
 init_errors();
 init_replay();
+init_replayInterrupt();
 function defineReplayRegistry(registry) {
   return registry;
 }