bitfab 0.52.3 → 0.52.5

package/dist/node.cjs

@@ -97,7 +97,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.52.3";
+    __version__ = "0.52.5";
     __packageName__ = "bitfab";
   }
 });
@@ -1137,7 +1137,7 @@ var init_otel = __esm({
         if (this.onDelivered === void 0) {
           return;
         }
-        const refs = spans.map((span) => span.ref).filter((ref) => ref !== void 0);
+        const refs = spans.map((span) => span.ref).filter((ref2) => ref2 !== void 0);
         if (refs.length === 0) {
           return;
         }
@@ -1394,9 +1394,9 @@ function parseRetryAfterMs(header) {
   }
   return Math.max(0, at - Date.now());
 }
-function carrierMeta(operation, payload, ref) {
+function carrierMeta(operation, payload, ref2) {
   return {
-    ref,
+    ref: ref2,
     name: carrierName(operation, payload),
     startTime: payloadTimestamp(payload, "started_at"),
     endTime: payloadTimestamp(payload, "ended_at"),
@@ -1641,22 +1641,22 @@ var init_http = __esm({
         return reports;
       }
       /** Build a carrier's meta and record what it adds to its trace's expected set. */
-      recordedMeta(operation, payload, ref) {
-        this.recordSubmittedCarrier(ref);
-        return carrierMeta(operation, payload, ref);
+      recordedMeta(operation, payload, ref2) {
+        this.recordSubmittedCarrier(ref2);
+        return carrierMeta(operation, payload, ref2);
       }
-      recordSubmittedCarrier(ref) {
-        if (ref === void 0) {
+      recordSubmittedCarrier(ref2) {
+        if (ref2 === void 0) {
           return;
         }
-        const delivery = this.traceDeliveries.get(ref.traceId);
+        const delivery = this.traceDeliveries.get(ref2.traceId);
         if (delivery === void 0) {
           return;
         }
-        if (ref.spanId === void 0) {
+        if (ref2.spanId === void 0) {
           delivery.closed = true;
         } else {
-          delivery.submittedSpanIds.add(ref.spanId);
+          delivery.submittedSpanIds.add(ref2.spanId);
         }
       }
       /**
@@ -1682,15 +1682,15 @@ var init_http = __esm({
         }
       }
       recordDeliveredCarriers(refs) {
-        for (const ref of refs) {
-          const delivery = this.traceDeliveries.get(ref.traceId);
+        for (const ref2 of refs) {
+          const delivery = this.traceDeliveries.get(ref2.traceId);
           if (delivery === void 0) {
             continue;
           }
-          if (ref.spanId === void 0) {
+          if (ref2.spanId === void 0) {
             delivery.closingAcked = true;
           } else {
-            delivery.ackedSpanIds.add(ref.spanId);
+            delivery.ackedSpanIds.add(ref2.spanId);
           }
         }
       }
@@ -1720,9 +1720,9 @@ var init_http = __esm({
        */
       async waitForPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
         const deadline = Date.now() + Math.max(timeoutMs, 0);
-        const settled = await this.settleDeferredWork(timeoutMs);
+        const settled2 = await this.settleDeferredWork(timeoutMs);
         const flushed = await this.traceTransport?.flush(Math.max(0, deadline - Date.now())) ?? true;
-        return settled && flushed;
+        return settled2 && flushed;
       }
       /**
        * Flush and permanently close this client's tracing transport. Idempotent:
@@ -1735,14 +1735,14 @@ var init_http = __esm({
         }
         const deadline = Date.now() + Math.max(timeoutMs, 0);
         this.closing = (async () => {
-          const settled = await this.settleDeferredWork(
+          const settled2 = await this.settleDeferredWork(
             Math.max(0, deadline - Date.now())
           );
           this.closed = true;
           const transport = this.traceTransport;
           this.traceTransport = void 0;
           const shutdownOk = await transport?.shutdown(Math.max(0, deadline - Date.now())) ?? true;
-          return settled && shutdownOk;
+          return settled2 && shutdownOk;
         })();
         return this.closing;
       }
@@ -2131,6 +2131,18 @@ var init_http = __esm({
           { timeout: REPLAY_COMPLETE_REQUEST_TIMEOUT_MS }
         );
       }
+      async getReseedSource(traceId) {
+        return this.get(
+          `/api/sdk/traces/${encodeURIComponent(traceId)}/reseedSource`
+        );
+      }
+      async reseedTrace(traceId, runTraceId) {
+        return this.request(
+          `/api/sdk/traces/${encodeURIComponent(traceId)}/reseed`,
+          { runTraceId },
+          { timeout: 3e4 }
+        );
+      }
       /**
        * Ask the server to materialize a per-trace DB branch lease from a
        * captured `dbSnapshotRef`. Blocking - the resolver creates a Neon
@@ -2341,6 +2353,112 @@ var init_randomUuid = __esm({
   }
 });
 
+// src/gitCommand.ts
+function isUnrefable(value) {
+  return typeof value === "object" && value !== null && "unref" in value && typeof value.unref === "function";
+}
+function unrefStream(stream) {
+  if (isUnrefable(stream)) {
+    stream.unref();
+  }
+}
+function terminate(child) {
+  if (child.pid && process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+      return;
+    } catch {
+      child.kill("SIGTERM");
+      return;
+    }
+  }
+  child.kill("SIGTERM");
+}
+async function gitRunner(options) {
+  let spawn;
+  try {
+    ;
+    ({ spawn } = await import("child_process"));
+  } catch {
+    return null;
+  }
+  return (dir, args) => new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn("git", args, {
+        cwd: dir,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+    const chunks = [];
+    let size = 0;
+    let overflow = false;
+    let exitCode = null;
+    let done = false;
+    const timers = [];
+    const schedule = (callback, ms) => {
+      const timer = setTimeout(callback, ms);
+      if (!options.keepProcessAlive) {
+        timer.unref();
+      }
+      timers.push(timer);
+    };
+    const finish = () => {
+      if (done) {
+        return;
+      }
+      done = true;
+      for (const timer of timers) {
+        clearTimeout(timer);
+      }
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve(
+        exitCode === 0 && !overflow ? Buffer.concat(chunks).toString("utf8") : null
+      );
+    };
+    child.stdout?.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > options.maxBuffer) {
+        overflow = true;
+        terminate(child);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    child.stderr?.resume();
+    child.on("error", () => {
+      exitCode = null;
+      finish();
+    });
+    child.on("exit", (code) => {
+      exitCode = code;
+      schedule(finish, EXIT_GRACE_MS);
+    });
+    child.on("close", (code) => {
+      exitCode = code ?? exitCode;
+      finish();
+    });
+    schedule(() => terminate(child), options.timeoutMs);
+    if (!options.keepProcessAlive) {
+      child.unref();
+      unrefStream(child.stdout);
+      unrefStream(child.stderr);
+    }
+  });
+}
+var EXIT_GRACE_MS;
+var init_gitCommand = __esm({
+  "src/gitCommand.ts"() {
+    "use strict";
+    EXIT_GRACE_MS = 500;
+  }
+});
+
 // src/mockOverride.ts
 function resolveMockValue(value, ctx) {
   return typeof value === "function" ? value(ctx) : value;
@@ -2397,37 +2515,33 @@ async function readCodeChangeFile() {
   }
 }
 async function captureCodeChangeFromGit(cwd, label) {
-  let execFile;
   let readFile;
   try {
     ;
-    ({ execFile } = await import("child_process"));
     ({ readFile } = await import("fs/promises"));
   } catch {
     return null;
   }
-  const git = (dir, args) => new Promise((resolve) => {
-    execFile(
-      "git",
-      args,
-      // 30s timeout so a hung git (e.g. a network-touching ref op) can't
-      // block the whole replay indefinitely.
-      { cwd: dir, maxBuffer: 64 * 1024 * 1024, timeout: 3e4 },
-      (err, stdout) => resolve(err ? null : stdout)
-    );
+  const git = await gitRunner({
+    timeoutMs: 3e4,
+    maxBuffer: 64 * 1024 * 1024,
+    keepProcessAlive: true
   });
+  if (!git) {
+    return null;
+  }
   try {
     const root = (await git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
     if (!root) {
       return null;
     }
-    const resolved = await resolveBase(git, root);
-    if (!resolved) {
+    const resolved2 = await resolveBase(git, root);
+    if (!resolved2) {
       return null;
     }
-    const { base, fromTrunk } = resolved;
-    const blobBytes = async (ref, path) => {
-      const out = await git(root, ["cat-file", "-s", `${ref}:${path}`]);
+    const { base, fromTrunk } = resolved2;
+    const blobBytes = async (ref2, path) => {
+      const out = await git(root, ["cat-file", "-s", `${ref2}:${path}`]);
       const n = out ? Number.parseInt(out.trim(), 10) : Number.NaN;
       return Number.isFinite(n) ? n : 0;
     };
@@ -2519,8 +2633,8 @@ async function resolveBase(git, root) {
   }
   return await refExists(git, root, "HEAD") ? { base: "HEAD", fromTrunk: false } : null;
 }
-async function refExists(git, root, ref) {
-  return await git(root, ["rev-parse", "--verify", `${ref}^{object}`]) !== null;
+async function refExists(git, root, ref2) {
+  return await git(root, ["rev-parse", "--verify", `${ref2}^{object}`]) !== null;
 }
 async function readWorkingFile(readFile, root, path) {
   try {
@@ -2555,6 +2669,7 @@ var MAX_FILES, MAX_FILE_BYTES, MAX_TOTAL_BYTES, TRUNK_CANDIDATES, NUL;
 var init_codeChange = __esm({
   "src/codeChange.ts"() {
     "use strict";
+    init_gitCommand();
     MAX_FILES = 60;
     MAX_FILE_BYTES = 5e5;
     MAX_TOTAL_BYTES = 2e6;
@@ -2575,6 +2690,7 @@ __export(replay_exports, {
   BITFAB_PROGRESS_PREFIX: () => BITFAB_PROGRESS_PREFIX,
   DbBranchReplayError: () => DbBranchReplayError,
   ReplayError: () => ReplayError,
+  deserializeInputs: () => deserializeInputs,
   replay: () => replay,
   reportReplayProgress: () => reportReplayProgress,
   serializeReplayResult: () => serializeReplayResult,
@@ -2758,9 +2874,9 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
   const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
   try {
     if (includeDbBranchLease && !lease && !leaseError) {
-      let resolved;
+      let resolved2;
       try {
-        resolved = await httpClient.resolveDbBranchLease(
+        resolved2 = await httpClient.resolveDbBranchLease(
           testRunId,
           originalTraceId,
           dbBranchSettings,
@@ -2774,10 +2890,10 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
           cause
         );
       }
-      lease = resolved.lease ?? void 0;
-      leaseError = resolved.leaseError ?? void 0;
-      dbSnapshotRef = resolved.dbSnapshotRef ?? dbSnapshotRef;
-      dbBranchTimings = resolved.timings ?? dbBranchTimings;
+      lease = resolved2.lease ?? void 0;
+      leaseError = resolved2.leaseError ?? void 0;
+      dbSnapshotRef = resolved2.dbSnapshotRef ?? dbSnapshotRef;
+      dbBranchTimings = resolved2.timings ?? dbBranchTimings;
     }
     if (leaseError) {
       throw new DbBranchReplayError(
@@ -3425,6 +3541,7 @@ __export(node_exports, {
   getCurrentSpan: () => getCurrentSpan,
   getCurrentTrace: () => getCurrentTrace,
   reportReplayProgress: () => reportReplayProgress,
+  reseedFromRegistry: () => reseedFromRegistry,
   seedFromRegistry: () => seedFromRegistry,
   serializeReplayResult: () => serializeReplayResult
 });
@@ -4559,24 +4676,239 @@ function mixedTracingError(enteredApi, entered, enclosing, traceFunctionKey) {
     `opt-in and opt-out tracing can't be mixed in one call stack: ${enteredApi} (${entered})${subject} was entered inside a ${SURFACE_API[enclosing]} call (${enclosing}). ${MIXED_SURFACE_REMEDY[entered]}`
   );
 }
-function assertSurfacesCompatible(requested, resolved, parentSurface, traceFunctionKey) {
+function assertSurfacesCompatible(requested, resolved2, parentSurface, traceFunctionKey) {
   if (requested === "inherit" || requested === "neutral") {
     return;
   }
-  if (resolved === void 0 || parentSurface === void 0) {
+  if (resolved2 === void 0 || parentSurface === void 0) {
     return;
   }
-  if (parentSurface === resolved) {
+  if (parentSurface === resolved2) {
     return;
   }
   throw mixedTracingError(
-    SURFACE_API[resolved],
-    resolved,
+    SURFACE_API[resolved2],
+    resolved2,
     parentSurface,
     traceFunctionKey
   );
 }
 
+// src/commitRef.ts
+init_gitCommand();
+init_readEnv();
+var EXPLICIT_SHA_ENV = "BITFAB_COMMIT_SHA";
+var DISABLE_ENV = "BITFAB_DISABLE_COMMIT_REF";
+var GIT_TIMEOUT_MS = 2e3;
+var GIT_MAX_BUFFER = 1024 * 1024;
+var VERCEL_PROVIDER_HOSTS = {
+  github: "github.com",
+  gitlab: "gitlab.com",
+  bitbucket: "bitbucket.org"
+};
+function read(env, name) {
+  if (name === null) {
+    return null;
+  }
+  const value = env(name)?.trim();
+  return value ? value : null;
+}
+function remoteFrom(...names) {
+  return (env) => {
+    const parts = names.map((name) => read(env, name));
+    if (parts.some((part) => part === null)) {
+      return null;
+    }
+    return normalizeRemote(parts.join("/"));
+  };
+}
+function vercelRemote(env) {
+  const provider = read(env, "VERCEL_GIT_PROVIDER")?.toLowerCase() ?? "";
+  const host = VERCEL_PROVIDER_HOSTS[provider];
+  const owner = read(env, "VERCEL_GIT_REPO_OWNER");
+  const slug = read(env, "VERCEL_GIT_REPO_SLUG");
+  if (!host || !owner || !slug) {
+    return null;
+  }
+  return `${host}/${owner}/${slug}`;
+}
+function noRemote() {
+  return null;
+}
+var PLATFORM_ENVS = [
+  ["VERCEL_GIT_COMMIT_SHA", "VERCEL_GIT_COMMIT_REF", vercelRemote],
+  [
+    "GITHUB_SHA",
+    "GITHUB_REF_NAME",
+    remoteFrom("GITHUB_SERVER_URL", "GITHUB_REPOSITORY")
+  ],
+  ["RAILWAY_GIT_COMMIT_SHA", "RAILWAY_GIT_BRANCH", noRemote],
+  ["RENDER_GIT_COMMIT", "RENDER_GIT_BRANCH", noRemote],
+  ["SOURCE_VERSION", null, noRemote],
+  ["CF_PAGES_COMMIT_SHA", "CF_PAGES_BRANCH", noRemote],
+  ["CI_COMMIT_SHA", "CI_COMMIT_REF_NAME", remoteFrom("CI_REPOSITORY_URL")],
+  [
+    "BUILD_SOURCEVERSION",
+    "BUILD_SOURCEBRANCHNAME",
+    remoteFrom("BUILD_REPOSITORY_URI")
+  ],
+  ["CIRCLE_SHA1", "CIRCLE_BRANCH", remoteFrom("CIRCLE_REPOSITORY_URL")]
+];
+var COMMIT_REF_ENV_NAMES = [
+  EXPLICIT_SHA_ENV,
+  DISABLE_ENV,
+  ...PLATFORM_ENVS.flatMap(
+    ([sha, branch]) => branch === null ? [sha] : [sha, branch]
+  ),
+  "GITHUB_SERVER_URL",
+  "GITHUB_REPOSITORY",
+  "CI_REPOSITORY_URL",
+  "BUILD_REPOSITORY_URI",
+  "CIRCLE_REPOSITORY_URL",
+  "VERCEL_GIT_PROVIDER",
+  "VERCEL_GIT_REPO_OWNER",
+  "VERCEL_GIT_REPO_SLUG"
+];
+function normalizeRemote(raw) {
+  const value = raw?.trim();
+  if (!value) {
+    return null;
+  }
+  let host = "";
+  let path = value;
+  if (value.includes("://")) {
+    try {
+      const parsed = new URL(value);
+      host = parsed.hostname;
+      path = parsed.pathname;
+    } catch {
+      return null;
+    }
+  } else {
+    const separator = value.indexOf(":");
+    if (separator !== -1) {
+      const head = value.slice(0, separator);
+      host = head.slice(head.lastIndexOf("@") + 1);
+      path = value.slice(separator + 1);
+    }
+  }
+  path = path.replace(/^\/+|\/+$/g, "");
+  if (path.endsWith(".git")) {
+    path = path.slice(0, -".git".length).replace(/\/+$/, "");
+  }
+  if (!host) {
+    return path || null;
+  }
+  return path ? `${host}/${path}` : host;
+}
+function resolveCommitRefFromEnv(env) {
+  const explicit = read(env, EXPLICIT_SHA_ENV);
+  const platform = PLATFORM_ENVS.find(([sha]) => read(env, sha) !== null);
+  if (!platform) {
+    if (explicit === null) {
+      return null;
+    }
+    return {
+      sha: explicit,
+      branch: null,
+      dirty: null,
+      remote: null,
+      rootSha: null
+    };
+  }
+  const [shaEnv, branchEnv, readRemote] = platform;
+  return {
+    sha: explicit ?? read(env, shaEnv),
+    branch: read(env, branchEnv),
+    dirty: null,
+    remote: readRemote(env),
+    rootSha: null
+  };
+}
+async function resolveCommitRefFromGit(cwd) {
+  const git = await gitRunner({
+    timeoutMs: GIT_TIMEOUT_MS,
+    maxBuffer: GIT_MAX_BUFFER,
+    keepProcessAlive: false
+  });
+  if (!git) {
+    return null;
+  }
+  const run = async (args) => (await git(cwd, args))?.trim() ?? null;
+  const sha = await run(["rev-parse", "HEAD"]);
+  if (!sha) {
+    return null;
+  }
+  const [branch, status, remote, roots] = await Promise.all([
+    run(["symbolic-ref", "--short", "-q", "HEAD"]),
+    run(["status", "--porcelain"]),
+    run(["remote", "get-url", "origin"]),
+    run(["rev-list", "--max-parents=0", "HEAD"])
+  ]);
+  return {
+    sha,
+    branch: branch || null,
+    dirty: status === null ? null : status.length > 0,
+    remote: normalizeRemote(remote),
+    rootSha: roots ? roots.split(/\s+/).sort()[0] ?? null : null
+  };
+}
+function commitRefWire(ref2) {
+  return {
+    sha: ref2.sha,
+    branch: ref2.branch,
+    dirty: ref2.dirty,
+    remote: ref2.remote,
+    root_sha: ref2.rootSha
+  };
+}
+var resolved = false;
+var ref = null;
+var gitStarted = false;
+var settled = Promise.resolve();
+function startCommitRefResolution() {
+  if (resolved || gitStarted) {
+    return;
+  }
+  if (read(readEnv, DISABLE_ENV) !== null) {
+    resolved = true;
+    return;
+  }
+  const fromEnv = resolveCommitRefFromEnv(readEnv);
+  if (fromEnv) {
+    ref = fromEnv;
+    resolved = true;
+    return;
+  }
+  gitStarted = true;
+  if (typeof process === "undefined") {
+    resolved = true;
+    return;
+  }
+  let cwd;
+  try {
+    cwd = process.cwd?.() ?? ".";
+  } catch {
+    resolved = true;
+    return;
+  }
+  settled = resolveCommitRefFromGit(cwd).then(
+    (fromGit) => {
+      if (!resolved) {
+        ref = fromGit;
+        resolved = true;
+      }
+    },
+    () => {
+      resolved = true;
+    }
+  );
+}
+function currentCommitRef() {
+  startCommitRefResolution();
+  return ref;
+}
+
 // src/client.ts
 init_constants();
 
@@ -5069,11 +5401,11 @@ var BitfabLangGraphCallbackHandler = class {
         this.invocations.set(invocation.rootRunId, invocation);
       }
       if (!willHide) {
-        let resolved = parentSpan;
-        while (resolved?.hidden === true) {
-          resolved = resolved.parentId ? this.runToSpan.get(resolved.parentId) : void 0;
+        let resolved2 = parentSpan;
+        while (resolved2?.hidden === true) {
+          resolved2 = resolved2.parentId ? this.runToSpan.get(resolved2.parentId) : void 0;
         }
-        effectiveParentId = resolved ? resolved.spanId : invocation.activeContext?.spanId ?? null;
+        effectiveParentId = resolved2 ? resolved2.spanId : invocation.activeContext?.spanId ?? null;
       } else {
         effectiveParentId = parentRunId ?? null;
       }
@@ -5741,6 +6073,7 @@ var BitfabOpenAIAgentHandler = class {
 
 // src/client.ts
 init_randomUuid();
+init_replay();
 
 // src/replayBranch.ts
 var _url, _context;
@@ -6572,6 +6905,7 @@ var Bitfab = class {
       validateDbSnapshotConfig(config.dbSnapshot);
     }
     this.dbSnapshot = config.dbSnapshot;
+    startCommitRefResolution();
     this.httpClient = new HttpClient({
       apiKey: () => this.resolveApiKey(),
       serviceUrl: this.serviceUrl,
@@ -7665,15 +7999,15 @@ var Bitfab = class {
                 );
               }
               return runWithSpanStack(newStack, async () => {
-                const resolved = await resolution;
-                if (resolved.matched) {
+                const resolved2 = await resolution;
+                if (resolved2.matched) {
                   void sendSpan({
-                    result: resolved.output,
+                    result: resolved2.output,
                     mocked: true,
                     mockTarget: "output",
                     mockSource: "override"
                   });
-                  return resolved.output;
+                  return resolved2.output;
                 }
                 if (shouldMockWithBaseStrategy && !mockSpan) {
                   throw new BitfabError(
@@ -7909,6 +8243,10 @@ var Bitfab = class {
     if (params.dbSnapshotRef) {
       rawTrace.db_snapshot_ref = params.dbSnapshotRef;
     }
+    const commitRef = currentCommitRef();
+    if (commitRef) {
+      rawTrace.commit_ref = commitRefWire(commitRef);
+    }
     if (params.ingestionType) {
       rawTrace.ingestion_type = params.ingestionType;
     }
@@ -8168,6 +8506,36 @@ var Bitfab = class {
     }
     return traceId;
   }
+  async reseedTrace(traceFunctionKey, fn, options) {
+    const source = await this.httpClient.getReseedSource(options.traceId);
+    if (source.traceFunctionKey !== traceFunctionKey) {
+      throw new BitfabError(
+        `Trace ${options.traceId} belongs to '${source.traceFunctionKey}', not '${traceFunctionKey}'.`
+      );
+    }
+    const args = deserializeInputs({
+      input: source.input,
+      input_meta: source.inputMeta
+    });
+    const runTraceId = await this.seedTraceByRunning(
+      traceFunctionKey,
+      fn,
+      {
+        args,
+        metadata: source.metadata,
+        ...source.sessionId === null ? {} : { sessionId: source.sessionId },
+        ...source.name === null ? {} : { name: source.name }
+      }
+    );
+    const adopted = await this.httpClient.reseedTrace(
+      options.traceId,
+      runTraceId
+    );
+    return {
+      traceId: adopted.traceId,
+      previousRunTraceId: adopted.previousRunTraceId
+    };
+  }
   async replay(traceFunctionKey, fn, options) {
     const wrappedKey = fn._bitfabTraceFunctionKey;
     let replayFn = fn;
@@ -8429,6 +8797,24 @@ init_replay();
 function defineReplayRegistry(registry) {
   return registry;
 }
+async function reseedFromRegistry(registry, pipeline, traceIds) {
+  const registration = registry[pipeline];
+  if (registration === void 0) {
+    throw new BitfabError(
+      `Unknown pipeline '${pipeline}'. Registered: ${Object.keys(registry).join(", ")}`
+    );
+  }
+  const traceFunctionKey = resolveTraceFunctionKey(registration);
+  const reseeded = [];
+  for (const traceId of traceIds) {
+    reseeded.push(
+      await registration.client.reseedTrace(traceFunctionKey, registration.fn, {
+        traceId
+      })
+    );
+  }
+  return { pipeline, traceFunctionKey, reseeded };
+}
 async function seedFromRegistry(registry, pipeline, cases, options = {}) {
   const registration = registry[pipeline];
   if (registration === void 0) {
@@ -8509,6 +8895,7 @@ assertAsyncStorageRegistered();
   getCurrentSpan,
   getCurrentTrace,
   reportReplayProgress,
+  reseedFromRegistry,
   seedFromRegistry,
   serializeReplayResult
 });