@bitfab/sdk 0.38.10 → 0.40.0

package/dist/{chunk-BNOVHUQB.js → chunk-A22EYRSY.js}

@@ -3,218 +3,6 @@ import {
   createAsyncLocalStorage
 } from "./chunk-H6LZRFMN.js";
 
-// src/codeChange.ts
-var MAX_FILES = 60;
-var MAX_FILE_BYTES = 5e5;
-var MAX_TOTAL_BYTES = 2e6;
-var TRUNK_CANDIDATES = [
-  "origin/HEAD",
-  "origin/main",
-  "origin/master",
-  "main",
-  "master"
-];
-var NUL = String.fromCharCode(0);
-async function resolveAutoCodeChange(label) {
-  if (typeof process === "undefined") {
-    return null;
-  }
-  if (process.env?.BITFAB_DISABLE_CODE_CHANGE_CAPTURE) {
-    return null;
-  }
-  const fromEnv = await readCodeChangeFile();
-  if (fromEnv) {
-    return fromEnv;
-  }
-  return captureCodeChangeFromGit(process.cwd?.() ?? ".", label);
-}
-async function readCodeChangeFile() {
-  const path = process.env?.BITFAB_CODE_CHANGE_PATH;
-  if (!path) {
-    return null;
-  }
-  try {
-    const { readFile } = await import("fs/promises");
-    const parsed = JSON.parse(await readFile(path, "utf8"));
-    const files = Array.isArray(parsed?.files) && parsed.files.every(
-      (f) => typeof f === "object" && f !== null && !Array.isArray(f)
-    ) ? parsed.files : void 0;
-    const description = typeof parsed?.description === "string" ? parsed.description : void 0;
-    if (!files && description === void 0) {
-      return null;
-    }
-    return { description, files };
-  } catch {
-    return null;
-  }
-}
-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)
-    );
-  });
-  try {
-    const root = (await git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
-    if (!root) {
-      return null;
-    }
-    const resolved = await resolveBase(git, root);
-    if (!resolved) {
-      return null;
-    }
-    const { base, fromTrunk } = resolved;
-    const blobBytes = async (ref, path) => {
-      const out = await git(root, ["cat-file", "-s", `${ref}:${path}`]);
-      const n = out ? Number.parseInt(out.trim(), 10) : Number.NaN;
-      return Number.isFinite(n) ? n : 0;
-    };
-    const workingBytes = async (path) => {
-      try {
-        const { stat } = await import("fs/promises");
-        const { join } = await import("path");
-        return (await stat(join(root, path))).size;
-      } catch {
-        return 0;
-      }
-    };
-    const tracked = await git(root, [
-      "diff",
-      "--name-status",
-      "--find-renames",
-      "-z",
-      base,
-      "--",
-      ":!.bitfab"
-    ]);
-    const untracked = await git(root, [
-      "ls-files",
-      "--others",
-      "--exclude-standard",
-      "-z",
-      "--",
-      ":!.bitfab"
-    ]);
-    const entries = [
-      ...parseNameStatusZ(tracked ?? ""),
-      ...(untracked ?? "").split(NUL).filter((p) => p.length > 0).map((path) => ({ status: "A", beforePath: path, path }))
-    ];
-    if (entries.length === 0) {
-      return null;
-    }
-    const files = [];
-    let totalBytes = 0;
-    for (const { status, beforePath, path } of entries) {
-      if (files.length >= MAX_FILES) {
-        break;
-      }
-      const beforeBytes = status === "A" ? 0 : await blobBytes(base, beforePath);
-      const afterBytes = status === "D" ? 0 : await workingBytes(path);
-      if (beforeBytes > MAX_FILE_BYTES || afterBytes > MAX_FILE_BYTES) {
-        continue;
-      }
-      const before = (status === "A" ? "" : await git(root, ["show", `${base}:${beforePath}`]) ?? "").replace(/\r\n/g, "\n");
-      const after = (status === "D" ? "" : await readWorkingFile(readFile, root, path)).replace(/\r\n/g, "\n");
-      if (before === after) {
-        continue;
-      }
-      const size = Buffer.byteLength(before, "utf8") + Buffer.byteLength(after, "utf8");
-      if (totalBytes + size > MAX_TOTAL_BYTES || looksBinary(before) || looksBinary(after)) {
-        continue;
-      }
-      totalBytes += size;
-      files.push({ path, before, after });
-    }
-    if (files.length === 0) {
-      return null;
-    }
-    const subject = (await git(root, ["log", "-1", "--format=%s", "HEAD"]))?.trim();
-    const fileWord = files.length === 1 ? "file" : "files";
-    const head = label?.trim() || subject || "Working-tree change";
-    const against = fromTrunk ? "vs trunk" : "uncommitted (vs HEAD)";
-    return {
-      description: `${head} (${files.length} ${fileWord} changed ${against})`,
-      files
-    };
-  } catch {
-    return null;
-  }
-}
-async function resolveBase(git, root) {
-  const forced = process.env?.BITFAB_CODE_CHANGE_BASE;
-  if (forced && await refExists(git, root, forced)) {
-    const base = (await git(root, ["merge-base", "HEAD", forced]))?.trim() || (await git(root, ["rev-parse", "--verify", forced]))?.trim() || null;
-    return base ? { base, fromTrunk: true } : null;
-  }
-  for (const candidate of TRUNK_CANDIDATES) {
-    if (!await refExists(git, root, candidate)) {
-      continue;
-    }
-    const mb = (await git(root, ["merge-base", "HEAD", candidate]))?.trim();
-    if (mb) {
-      return { base: mb, fromTrunk: true };
-    }
-  }
-  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 readWorkingFile(readFile, root, path) {
-  try {
-    const { join } = await import("path");
-    return await readFile(join(root, path), "utf8");
-  } catch {
-    return "";
-  }
-}
-function parseNameStatusZ(raw) {
-  const parts = raw.split(NUL).filter((p) => p.length > 0);
-  const out = [];
-  let i = 0;
-  while (i + 1 < parts.length) {
-    const status = parts[i].charAt(0);
-    i += 1;
-    const beforePath = parts[i];
-    i += 1;
-    if ((status === "R" || status === "C") && i < parts.length) {
-      out.push({ status, beforePath, path: parts[i] });
-      i += 1;
-    } else {
-      out.push({ status, beforePath, path: beforePath });
-    }
-  }
-  return out;
-}
-function looksBinary(s) {
-  return s.slice(0, 8e3).includes(NUL);
-}
-
-// src/errors.ts
-var BitfabError = class extends Error {
-  constructor(message, url, status, retryAfterMs) {
-    super(message);
-    this.url = url;
-    this.status = status;
-    this.retryAfterMs = retryAfterMs;
-    this.name = "BitfabError";
-  }
-};
-
 // src/readEnv.ts
 function readEnv(name) {
   if (typeof process !== "undefined" && process.env) {
@@ -311,12 +99,23 @@ function encodeRequestBody(body) {
 }
 
 // src/version.generated.ts
-var __version__ = "0.38.10";
+var __version__ = "0.40.0";
 var __packageName__ = "@bitfab/sdk";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
 
+// src/errors.ts
+var BitfabError = class extends Error {
+  constructor(message, url, status, retryAfterMs) {
+    super(message);
+    this.url = url;
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "BitfabError";
+  }
+};
+
 // src/replayContext.ts
 var replayContextStorage = null;
 var REPLAY_CONTEXT_STORAGE_SYMBOL = /* @__PURE__ */ Symbol.for("bitfab.replayContextStorage");
@@ -1757,6 +1556,10 @@ var HttpClient = class {
     const response = await this.get(endpoint);
     return response.span;
   }
+  /**
+   * GET a JSON endpoint on the service with the client's API key. Throws a
+   * `BitfabError` carrying the status text for any non-2xx response.
+   */
   async get(endpoint) {
     const url = `${this.serviceUrl}${endpoint}`;
     const controller = new AbortController();
@@ -1770,7 +1573,10 @@ var HttpClient = class {
       if (!response.ok) {
         const errorText = await response.text();
         throw new BitfabError(
-          `HTTP ${response.status}: ${errorText.slice(0, 500)}`
+          `HTTP ${response.status}: ${errorText.slice(0, 500)}`,
+          void 0,
+          response.status,
+          parseRetryAfterMs(readHeader(response, "retry-after"))
         );
       }
       return await response.json();
@@ -2032,900 +1838,20 @@ var HttpClient = class {
   }
 };
 
-// src/mockOverride.ts
-var NO_MOCK_OVERRIDE = /* @__PURE__ */ Symbol("bitfab.noMockOverride");
-function resolveMockValue(value, ctx) {
-  return typeof value === "function" ? value(ctx) : value;
-}
-function normalizeMockOverrides(mockOverride) {
-  if (mockOverride === void 0) {
-    return [];
-  }
-  const overrides = Array.isArray(mockOverride) ? mockOverride : [mockOverride];
-  return overrides.map(
-    (override) => typeof override === "function" ? { match: () => true, value: override } : override
-  );
-}
-
-// src/randomUuid.ts
-function randomUuid() {
-  const globalCrypto = globalThis.crypto;
-  if (typeof globalCrypto?.randomUUID === "function") {
-    try {
-      return globalCrypto.randomUUID();
-    } catch {
-    }
-  }
-  warnOnce(
-    "crypto-unavailable",
-    "global crypto.randomUUID is unavailable; using a non-cryptographic fallback for trace/span ids. Tracing works normally (ids are correlation-only, not security-sensitive)."
-  );
-  return fallbackUuidV4();
-}
-function fallbackUuidV4() {
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
-    const rand = Math.random() * 16 | 0;
-    const value = char === "x" ? rand : rand & 3 | 8;
-    return value.toString(16);
-  });
-}
-
-// src/serialize.ts
-import superjson from "superjson";
-var MAX_SERIALIZED_BYTES = MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
-var MAX_FRAMEWORK_SERIALIZED_BYTES = MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
-function describeValue(value) {
-  try {
-    const ctorName = value?.constructor?.name;
-    if (ctorName && ctorName !== "Object") {
-      return ctorName;
-    }
-  } catch {
-  }
-  return typeof value;
-}
-function unserializableStub(value, reason) {
-  warnOnce(
-    `serialize:${reason.replace(/\d+/g, "N")}`,
-    `a value could not be fully serialized for a span (${reason}); it was replaced with a placeholder. The span still ships, but its captured input/output is incomplete.`
-  );
-  let summary;
-  try {
-    summary = `<unserializable: ${describeValue(value)} (${reason})>`;
-  } catch {
-    summary = `<unserializable (${reason})>`;
-  }
-  return { json: summary };
-}
-function serializeValue(value) {
-  try {
-    const { json, meta } = superjson.serialize(value);
-    let size;
-    try {
-      size = JSON.stringify(json).length;
-    } catch {
-      return unserializableStub(value, "stringify_failed_after_superjson");
-    }
-    if (size > MAX_SERIALIZED_BYTES) {
-      return unserializableStub(value, `too_large_${size}_bytes`);
-    }
-    return meta ? { json, meta } : { json };
-  } catch {
-    try {
-      return { json: JSON.parse(JSON.stringify(value)) };
-    } catch {
-      return unserializableStub(value, "json_stringify_failed");
-    }
-  }
-}
-function deserializeValue(serialized) {
-  if (serialized.meta === void 0) {
-    return serialized.json;
-  }
-  return superjson.deserialize({
-    json: serialized.json,
-    meta: serialized.meta
-  });
-}
-var MAX_SAFE_DEPTH = 6;
-function toJsonSafe(value) {
-  return toJsonSafeReport(value).safe;
-}
-function toJsonSafeReport(value) {
-  const dropped = [];
-  const safe = toJsonSafeInner(value, 0, /* @__PURE__ */ new WeakSet(), dropped);
-  try {
-    const size = JSON.stringify(safe)?.length ?? 0;
-    if (size > MAX_FRAMEWORK_SERIALIZED_BYTES) {
-      warnOnce(
-        "toJsonSafe:too_large",
-        `a framework payload exceeded ${MAX_FRAMEWORK_SERIALIZED_BYTES} bytes and was replaced with a placeholder so the span still ships. The captured state for this span is incomplete.`
-      );
-      return {
-        safe: `<unserializable: too_large_${size}_bytes>`,
-        dropped: [...dropped, `too_large_${size}_bytes`]
-      };
-    }
-  } catch {
-  }
-  return { safe, dropped };
-}
-function toJsonSafeInner(value, depth, seen, dropped) {
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  const className = value?.constructor?.name ?? typeof value;
-  if (depth > MAX_SAFE_DEPTH) {
-    dropped.push(className);
-    return `<${className}>`;
-  }
-  if (typeof value !== "object") {
-    if (typeof value === "function" || typeof value === "symbol") {
-      dropped.push(className);
-    }
-    try {
-      return String(value);
-    } catch {
-      dropped.push(className);
-      return `<${className}>`;
-    }
-  }
-  if (seen.has(value)) {
-    dropped.push(className);
-    return `<cycle ${className}>`;
-  }
-  seen.add(value);
-  let result;
-  if (Array.isArray(value)) {
-    result = value.map(
-      (item) => toJsonSafeInner(item, depth + 1, seen, dropped)
-    );
-  } else if (typeof value.toJSON === "function") {
-    try {
-      result = toJsonSafeInner(
-        value.toJSON(),
-        depth + 1,
-        seen,
-        dropped
-      );
-    } catch {
-      dropped.push(className);
-      result = `<${className}>`;
-    }
-  } else {
-    try {
-      const obj = {};
-      for (const [k, v] of Object.entries(value)) {
-        if (!k.startsWith("_")) {
-          obj[k] = toJsonSafeInner(v, depth + 1, seen, dropped);
-        }
-      }
-      result = obj;
-    } catch {
-      dropped.push(className);
-      result = `<${className}>`;
-    }
-  }
-  seen.delete(value);
-  return result;
-}
-
-// src/replay.ts
-var REPLAY_PERSISTENCE_TIMEOUT_MS = 3e4;
-function dbBranchEnabled(dbBranch) {
-  return dbBranch !== void 0 && dbBranch !== false;
-}
-function resolveDbBranchSettings(dbBranch) {
-  if (!dbBranch || dbBranch === true) {
-    return void 0;
-  }
-  const { minCu, maxCu, warmupSql } = dbBranch;
-  const settings = {
-    ...minCu === void 0 ? {} : { minCu },
-    ...maxCu === void 0 ? {} : { maxCu },
-    ...warmupSql === void 0 ? {} : { warmupSql }
-  };
-  return Object.keys(settings).length === 0 ? void 0 : settings;
-}
-var BITFAB_PROGRESS_PREFIX = "@@bitfab:progress ";
-function reportReplayProgress(progress) {
-  const stderr = typeof process !== "undefined" ? process.stderr : void 0;
-  if (!stderr) {
-    return;
-  }
-  try {
-    stderr.write(
-      `${BITFAB_PROGRESS_PREFIX}${JSON.stringify(progress, replayJsonReplacer)}
-`
-    );
-  } catch {
-  }
-}
-var ReplayError = class extends BitfabError {
-  constructor(message, items, testRunId, testRunUrl, cause) {
-    super(message, testRunUrl);
-    this.items = items;
-    this.testRunId = testRunId;
-    this.testRunUrl = testRunUrl;
-    this.cause = cause;
-    this.name = "ReplayError";
-  }
-};
-var DbBranchReplayError = class extends BitfabError {
-  constructor(code, message, originalTraceId, cause) {
-    super(message);
-    this.code = code;
-    this.originalTraceId = originalTraceId;
-    this.cause = cause;
-    this.name = "DbBranchReplayError";
-  }
-};
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function replayItemErrorMessage(error) {
-  if (error instanceof DbBranchReplayError) {
-    return `Replay requested a database branch for trace ${error.originalTraceId} but it could not be resolved (${error.code}): ${error.message}. The function was not run, because replaying it against the live database would produce a result that looks valid but did not use the historical data you asked for.`;
-  }
-  return errorMessage(error);
-}
-function replayJsonReplacer(_key, value) {
-  if (value instanceof Error) {
-    const serialized = {
-      name: value.name,
-      message: value.message,
-      stack: value.stack
-    };
-    if (value instanceof DbBranchReplayError) {
-      serialized.code = value.code;
-      serialized.originalTraceId = value.originalTraceId;
-      if (value.cause !== void 0) {
-        serialized.cause = value.cause;
-      }
-    }
-    return serialized;
-  }
-  return value;
-}
-function serializeReplayResult(result) {
-  return JSON.stringify(result, replayJsonReplacer, 2);
-}
-async function preserveReplayFailure(operation, items, testRunId, testRunUrl) {
-  try {
-    return await operation();
-  } catch (cause) {
-    if (cause instanceof ReplayError) {
-      throw cause;
-    }
-    throw new ReplayError(
-      errorMessage(cause),
-      items,
-      testRunId,
-      testRunUrl,
-      cause
-    );
-  }
-}
-function deserializeInputs(spanData) {
-  const inputMeta = spanData.input_meta;
-  const rawInput = spanData.input;
-  if (inputMeta !== void 0 && inputMeta !== null) {
-    const deserialized = deserializeValue({ json: rawInput, meta: inputMeta });
-    if (Array.isArray(deserialized)) {
-      return deserialized;
-    }
-    return deserialized !== void 0 && deserialized !== null ? [deserialized] : [];
-  }
-  if (Array.isArray(rawInput)) {
-    return rawInput;
-  }
-  return rawInput !== void 0 && rawInput !== null ? [rawInput] : [];
-}
-function deserializeOutput(spanData) {
-  const outputMeta = spanData.output_meta;
-  const rawOutput = spanData.output;
-  if (outputMeta !== void 0 && outputMeta !== null) {
-    return deserializeValue({ json: rawOutput, meta: outputMeta });
-  }
-  return rawOutput;
-}
-function buildMockTree(rootNode) {
-  const spans = /* @__PURE__ */ new Map();
-  const counters = /* @__PURE__ */ new Map();
-  function walk(node) {
-    const key = node.traceFunctionKey;
-    if (key) {
-      const name = node.spanName || key;
-      const counterKey = `${key}:${name}`;
-      const index = counters.get(counterKey) ?? 0;
-      counters.set(counterKey, index + 1);
-      spans.set(`${counterKey}:${index}`, {
-        sourceSpanId: node.sourceSpanId,
-        externalSpanId: node.externalSpanId,
-        output: node.output,
-        outputMeta: node.outputMeta
-      });
-    }
-    for (const child of node.children) {
-      walk(child);
-    }
-  }
-  for (const child of rootNode.children) {
-    walk(child);
-  }
-  return { spans };
-}
-async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy, resolvedOverrides, replayedTraceId, includeDbBranchLease, dbBranchSettings, adaptInputs) {
-  let lease = includeDbBranchLease ? serverItem.dbBranchLease : void 0;
-  let leaseError = includeDbBranchLease ? serverItem.dbBranchLeaseError : void 0;
-  let dbSnapshotRef = serverItem.dbSnapshotRef;
-  let dbBranchTimings = includeDbBranchLease ? serverItem.dbBranchTimings : void 0;
-  let inputs = [];
-  let originalOutput;
-  let result;
-  let error = null;
-  let traceError = null;
-  let replayError = null;
-  let replayDurationMs = null;
-  let replayStarted = null;
-  const originalTraceId = serverItem.originalTraceId ?? serverItem.sourceTraceId;
-  const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
-  try {
-    if (includeDbBranchLease && !lease && !leaseError) {
-      let resolved;
-      try {
-        resolved = await httpClient.resolveDbBranchLease(
-          testRunId,
-          originalTraceId,
-          dbBranchSettings
-        );
-      } catch (cause) {
-        throw new DbBranchReplayError(
-          "lease_request_failed",
-          `Bitfab could not request the database branch: ${errorMessage(cause)}`,
-          originalTraceId,
-          cause
-        );
-      }
-      lease = resolved.lease ?? void 0;
-      leaseError = resolved.leaseError ?? void 0;
-      dbSnapshotRef = resolved.dbSnapshotRef ?? dbSnapshotRef;
-      dbBranchTimings = resolved.timings ?? dbBranchTimings;
-    }
-    if (leaseError) {
-      throw new DbBranchReplayError(
-        leaseError.code,
-        leaseError.message,
-        originalTraceId
-      );
-    }
-    const span = await httpClient.getExternalSpan(originalSpanId, {
-      view: "replay"
-    });
-    const spanData = span.rawData?.span_data ?? {};
-    inputs = deserializeInputs(spanData);
-    originalOutput = deserializeOutput(spanData);
-    if (adaptInputs) {
-      inputs = adaptInputs(inputs, {
-        originalTraceId,
-        originalSpanId,
-        // Deprecated aliases for originalTraceId/originalSpanId.
-        sourceTraceId: originalTraceId,
-        sourceSpanId: originalSpanId
-      });
-    }
-    const hasOverrides = resolvedOverrides.length > 0;
-    const needTree = mockStrategy === "all" || mockStrategy === "marked" || hasOverrides;
-    const includeOutputs = mockStrategy === "all";
-    let mockTree;
-    if (needTree) {
-      try {
-        const treeResponse = await httpClient.getSpanTree(originalSpanId, {
-          includeOutputs,
-          includeRootOutput: false
-        });
-        if (!treeResponse.root) {
-          throw new BitfabError(
-            `Replay mock strategy "${mockStrategy}"${hasOverrides ? " with overrides" : ""} requires a span tree root for original span ${originalSpanId}.`
-          );
-        }
-        mockTree = buildMockTree(treeResponse.root);
-      } catch (error2) {
-        if (mockStrategy !== "marked" || hasOverrides) {
-          throw error2;
-        }
-        mockTree = { spans: /* @__PURE__ */ new Map() };
-      }
-    }
-    const outputCache = /* @__PURE__ */ new Map();
-    const fetchSpanOutput = mockTree && !includeOutputs ? (externalSpanId) => {
-      let pending = outputCache.get(externalSpanId);
-      if (!pending) {
-        pending = httpClient.getExternalSpan(externalSpanId, { view: "replay" }).then(
-          (s) => deserializeOutput(
-            s.rawData?.span_data ?? {}
-          )
-        );
-        outputCache.set(externalSpanId, pending);
-      }
-      return pending;
-    } : void 0;
-    try {
-      replayStarted = performance.now();
-      const maybePromise = runWithReplayContext(
-        {
-          testRunId,
-          traceId: replayedTraceId,
-          inputSourceSpanId: span.id,
-          inputSourceTraceId: span.externalTraceId,
-          sourceBitfabTraceId: originalTraceId,
-          mockTree,
-          callCounters: mockTree ? /* @__PURE__ */ new Map() : void 0,
-          mockStrategy,
-          mockOverrides: hasOverrides ? resolvedOverrides : void 0,
-          fetchSpanOutput,
-          dbBranchLease: lease,
-          dbBranchTimings
-        },
-        () => fn(...inputs)
-      );
-      result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
-      replayDurationMs = Math.round(performance.now() - replayStarted);
-    } catch (e) {
-      if (replayStarted !== null) {
-        replayDurationMs = Math.round(performance.now() - replayStarted);
-      }
-      traceError = e;
-      error = errorMessage(e);
-    }
-  } catch (e) {
-    if (replayStarted !== null) {
-      replayDurationMs = Math.round(performance.now() - replayStarted);
-    }
-    replayError = e;
-    error = replayItemErrorMessage(e);
-  } finally {
-    if (lease) {
-      try {
-        await httpClient.releaseDbBranchLease(lease.neonBranchId);
-      } catch (e) {
-        try {
-          console.warn(
-            `Bitfab: failed to release DB branch ${lease.neonBranchId} (TTL janitor will catch it): ${e instanceof Error ? e.message : String(e)}`
-          );
-        } catch {
-        }
-      }
-    }
-  }
-  const originalDurationMs = serverItem.originalDurationMs ?? serverItem.durationMs ?? null;
-  const originalModel = serverItem.originalModel ?? serverItem.model ?? null;
-  return {
-    // Written in by replay() from the complete-replay response once the server
-    // has minted this replay trace's row. Null until then: the client-side
-    // correlation id (replayedTraceId) is never surfaced as the item's traceId.
-    traceId: null,
-    originalTraceId,
-    originalSpanId,
-    // Deprecated aliases for originalTraceId/originalSpanId.
-    sourceTraceId: originalTraceId,
-    sourceSpanId: originalSpanId,
-    input: inputs,
-    result,
-    originalOutput,
-    error,
-    traceError,
-    replayError,
-    durationMs: replayDurationMs,
-    originalDurationMs,
-    originalTokens: serverItem.originalTokens ?? serverItem.tokens ?? null,
-    originalModel,
-    // Filled in by replay() from the complete-replay response once the
-    // replay traces are persisted and their spans aggregated server-side.
-    // Null here (and on older servers) means "replay tokens not known".
-    tokens: null,
-    model: originalModel,
-    dbSnapshotRef: dbSnapshotRef ?? null,
-    dbBranchTimings: dbBranchTimings ?? null
-  };
-}
-async function waitForReplayPersistence(httpClient, testRunId, replayedTraceIds) {
-  const deferredSettled = await httpClient.settleDeferredWork(
-    REPLAY_PERSISTENCE_TIMEOUT_MS
-  );
-  if (!deferredSettled) {
-    httpClient.takeTraceDeliveries(replayedTraceIds);
-    throw new BitfabError(
-      `Replay could not settle deferred span work before the deadline, so the expected span counts are incomplete (testRunId ${testRunId}).`
-    );
-  }
-  if (!httpClient.hasClosedDeliveries(replayedTraceIds)) {
-    httpClient.takeTraceDeliveries(replayedTraceIds);
-    return {};
-  }
-  const flushed = await flushTraces(REPLAY_PERSISTENCE_TIMEOUT_MS);
-  const deliveries = httpClient.takeTraceDeliveries(replayedTraceIds);
-  const expectedSpanCounts = {};
-  const readBackTraceIds = {};
-  let allDelivered = true;
-  for (const [traceId, delivery] of Object.entries(deliveries)) {
-    if (delivery.serverTraceId !== void 0) {
-      readBackTraceIds[traceId] = delivery.serverTraceId;
-    }
-    if (!delivery.closed) {
-      continue;
-    }
-    expectedSpanCounts[traceId] = delivery.spanCount;
-    allDelivered = allDelivered && delivery.delivered;
-  }
-  if (allDelivered) {
-    return readBackTraceIds;
-  }
-  const deadline = Date.now() + REPLAY_PERSISTENCE_TIMEOUT_MS;
-  let missing = Object.keys(expectedSpanCounts).length;
-  while (true) {
-    const status = await httpClient.getReplayStatus(
-      testRunId,
-      expectedSpanCounts
-    );
-    const ready = status.traceIds ?? {};
-    missing = Object.keys(expectedSpanCounts).filter(
-      (traceId) => ready[traceId] === void 0
-    ).length;
-    if (missing === 0) {
-      return readBackTraceIds;
-    }
-    if (Date.now() >= deadline) {
-      break;
-    }
-    await sleepForReplayPersistence(
-      Math.min(100, Math.max(0, deadline - Date.now()))
-    );
-  }
-  const cause = flushed ? "" : " Delivery was also not confirmed before the flush deadline, so the spans likely never reached the server.";
-  throw new BitfabError(
-    `Replay traces were not fully persisted before the delivery deadline (testRunId ${testRunId}, missing ${missing} of ${Object.keys(expectedSpanCounts).length} trace(s)).${cause}`
-  );
-}
-function sleepForReplayPersistence(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-async function mapWithConcurrency2(tasks, maxConcurrency, onSettled, onStarted) {
-  const results = new Array(tasks.length);
-  let nextIndex = 0;
-  async function worker() {
-    while (nextIndex < tasks.length) {
-      const index = nextIndex++;
-      onStarted?.(index);
-      const result = await tasks[index]();
-      results[index] = result;
-      await onSettled?.(result, index);
-    }
-  }
-  const workers = Array.from(
-    { length: Math.min(maxConcurrency, tasks.length) },
-    () => worker()
-  );
-  await Promise.all(workers);
-  return results;
-}
-async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, registeredOverrides = []) {
-  if (options?.traceIds !== void 0) {
-    if (options.traceIds.length === 0) {
-      throw new BitfabError("traceIds must contain at least one trace ID.");
-    }
-    if (options.traceIds.length > 100) {
-      throw new BitfabError(
-        `traceIds supports at most 100 trace IDs per replay (got ${options.traceIds.length}).`
-      );
-    }
-  }
-  if (options?.traceIds !== void 0 && options?.datasetId !== void 0) {
-    throw new BitfabError(
-      "traceIds and datasetId select different replay sources and cannot be used together."
-    );
-  }
-  if (options?.limit !== void 0 && options?.traceIds !== void 0) {
-    try {
-      console.warn(
-        "Bitfab: limit is ignored when traceIds is passed: the explicit trace ID list already determines how many traces replay."
-      );
-    } catch {
-    }
-  }
-  await replayContextReady;
-  let codeChangeDescription = options?.codeChangeDescription;
-  let codeChangeFiles = options?.codeChangeFiles;
-  if (codeChangeFiles === void 0) {
-    const captured = await resolveAutoCodeChange(options?.name);
-    if (captured) {
-      codeChangeFiles = captured.files;
-      if (codeChangeDescription === void 0) {
-        codeChangeDescription = captured.description;
-      }
-    }
-  }
-  const {
-    testRunId,
-    testRunUrl,
-    items: serverItems
-  } = await httpClient.startReplay(
-    traceFunctionKey,
-    // limit is meaningless with explicit traceIds (the ID list determines
-    // the count), so it's omitted from the request entirely.
-    options?.traceIds ? void 0 : options?.limit ?? 5,
-    options?.traceIds,
-    options?.name,
-    codeChangeDescription,
-    codeChangeFiles,
-    dbBranchEnabled(options?.dbBranch),
-    // includeDbBranchLease
-    options?.experimentGroupId,
-    options?.datasetId,
-    options?.graderIds,
-    resolveDbBranchSettings(options?.dbBranch)
-  );
-  const mockStrategy = options?.mock ?? "marked";
-  const maxConcurrency = options?.maxConcurrency ?? 10;
-  const fullTestRunUrl = `${serviceUrl}${testRunUrl}`;
-  const resolvedOverrides = [
-    ...normalizeMockOverrides(options?.mockOverride),
-    ...registeredOverrides
-  ];
-  const replayedTraceIds = serverItems.map(() => randomUuid());
-  httpClient.trackTraceDeliveries(replayedTraceIds);
-  const tasks = serverItems.map(
-    (serverItem, index) => () => processItem(
-      httpClient,
-      serverItem,
-      fn,
-      testRunId,
-      mockStrategy,
-      resolvedOverrides,
-      replayedTraceIds[index],
-      dbBranchEnabled(options?.dbBranch),
-      resolveDbBranchSettings(options?.dbBranch),
-      options?.adaptInputs
-    )
-  );
-  const total = tasks.length;
-  const onItemFinish = options?.onItemFinish ?? options?.onProgress;
-  let completed = 0;
-  let started = 0;
-  let succeeded = 0;
-  let errored = 0;
-  let flushInFlight = null;
-  let flushPending = false;
-  const flushFinishedItemTrace = () => {
-    flushPending = true;
-    if (!flushInFlight) {
-      flushInFlight = (async () => {
-        try {
-          while (flushPending) {
-            flushPending = false;
-            await httpClient.settleDeferredWork(REPLAY_PERSISTENCE_TIMEOUT_MS);
-            await flushTraces(REPLAY_PERSISTENCE_TIMEOUT_MS);
-          }
-        } finally {
-          flushInFlight = null;
-        }
-      })();
-    }
-    return flushInFlight;
-  };
-  const resultItems = await mapWithConcurrency2(
-    tasks,
-    maxConcurrency,
-    async (item, index) => {
-      let serverTraceId = null;
-      try {
-        await flushFinishedItemTrace();
-        serverTraceId = httpClient.peekServerTraceId(replayedTraceIds[index]) ?? null;
-      } catch {
-      }
-      item.traceId = serverTraceId;
-      completed += 1;
-      if (item.error === null) {
-        succeeded += 1;
-      } else {
-        errored += 1;
-      }
-      try {
-        onItemFinish?.({
-          testRunId,
-          completed,
-          total,
-          succeeded,
-          errored,
-          item: {
-            // The server's assigned traces.id, read back off the ingest
-            // response and surfaced as this item finishes. Null only if the
-            // per-item flush could not confirm delivery in time; the end-of-run
-            // barrier then fills the returned ReplayItem. The client-side
-            // placeholder is never surfaced.
-            traceId: serverTraceId,
-            originalTraceId: item.originalTraceId ?? null,
-            originalSpanId: item.originalSpanId ?? null,
-            // Deprecated aliases for originalTraceId/originalSpanId.
-            sourceTraceId: item.originalTraceId ?? null,
-            sourceSpanId: item.originalSpanId ?? null,
-            input: item.input,
-            result: item.result,
-            originalOutput: item.originalOutput,
-            error: item.error,
-            traceError: item.traceError,
-            replayError: item.replayError,
-            durationMs: item.durationMs,
-            originalDurationMs: item.originalDurationMs,
-            originalTokens: item.originalTokens,
-            originalModel: item.originalModel,
-            tokens: item.tokens,
-            model: item.model,
-            dbSnapshotRef: item.dbSnapshotRef,
-            dbBranchTimings: item.dbBranchTimings
-          }
-        });
-      } catch {
-      }
-    },
-    options?.onItemStart ? (index) => {
-      started += 1;
-      const serverItem = serverItems[index];
-      const originalTraceId = serverItem.originalTraceId ?? serverItem.sourceTraceId;
-      const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
-      try {
-        options.onItemStart?.({
-          type: "started",
-          testRunId,
-          started,
-          completed,
-          total,
-          succeeded,
-          errored,
-          item: {
-            originalTraceId,
-            originalSpanId,
-            sourceTraceId: originalTraceId,
-            sourceSpanId: originalSpanId
-          }
-        });
-      } catch {
-      }
-    } : void 0
-  );
-  const deliveredTraceIds = await preserveReplayFailure(
-    () => waitForReplayPersistence(httpClient, testRunId, replayedTraceIds),
-    resultItems,
-    testRunId,
-    fullTestRunUrl
-  );
-  for (let index = 0; index < resultItems.length; index += 1) {
-    const localId = replayedTraceIds[index];
-    const readBack = localId ? deliveredTraceIds[localId] : void 0;
-    if (readBack !== void 0) {
-      resultItems[index].traceId = readBack;
-    }
-  }
-  const completeResult = await preserveReplayFailure(
-    () => httpClient.completeReplay(testRunId),
-    resultItems,
-    testRunId,
-    fullTestRunUrl
-  );
-  const serverTraceIds = completeResult.traceIds;
-  const replayTokens = completeResult.tokens;
-  if (serverTraceIds !== void 0) {
-    const missing = [];
-    let completedCount = 0;
-    for (let index = 0; index < resultItems.length; index += 1) {
-      const item = resultItems[index];
-      const localId = replayedTraceIds[index];
-      const mapped = localId ? serverTraceIds[localId] : void 0;
-      item.traceId = item.traceId ?? mapped ?? null;
-      if (item.error === null) {
-        completedCount += 1;
-        if (mapped === void 0) {
-          missing.push(localId ?? item.originalTraceId);
-        }
-      }
-      if (mapped !== void 0) {
-        item.tokens = replayTokens?.[mapped] ?? null;
-      }
-    }
-    if (completedCount > 0 && missing.length === completedCount) {
-      const serverCount = completeResult.traceCount !== void 0 ? ` The server persisted ${completeResult.traceCount} trace(s) for this run.` : "";
-      const cause = new BitfabError(
-        `Replay completed but the server has no persisted trace for any of the ${completedCount} completed item(s) (testRunId ${testRunId}).${serverCount} Trace uploads were awaited, so either the uploads failed (check for "Bitfab: Failed to create" errors above) or the replayed function is not wrapped with withSpan.`
-      );
-      throw new ReplayError(
-        cause.message,
-        resultItems,
-        testRunId,
-        fullTestRunUrl,
-        cause
-      );
-    }
-    if (missing.length > 0) {
-      try {
-        console.error(
-          `Bitfab: server has no persisted trace for ${missing.length} of ${completedCount} completed replay item(s) (testRunId ${testRunId}). Their replay token usage is unavailable and they cannot be labeled.`
-        );
-      } catch {
-      }
-    }
-  }
-  const result = {
-    items: resultItems,
-    testRunId,
-    testRunUrl: fullTestRunUrl
-  };
-  await writeReplayResultFile(result);
-  if (!options?.onItemFinish) {
-    try {
-      options?.onProgress?.({
-        type: "complete",
-        testRunId,
-        completed: total,
-        total,
-        succeeded,
-        errored,
-        result
-      });
-    } catch {
-    }
-  }
-  return result;
-}
-async function writeReplayResultFile(result) {
-  const resultPath = typeof process !== "undefined" ? process.env?.BITFAB_REPLAY_RESULT_PATH : void 0;
-  if (!resultPath) {
-    return;
-  }
-  try {
-    const [{ dirname }, { mkdir, writeFile }] = await Promise.all([
-      import("path"),
-      import("fs/promises")
-    ]);
-    await mkdir(dirname(resultPath), { recursive: true });
-    await writeFile(resultPath, `${serializeReplayResult(result)}
-`);
-  } catch (err) {
-    try {
-      console.warn(
-        `Bitfab: failed to write replay result to BITFAB_REPLAY_RESULT_PATH (${resultPath}): ${err instanceof Error ? err.message : String(err)}`
-      );
-    } catch {
-    }
-  }
-}
-
 export {
   __version__,
   DEFAULT_SERVICE_URL,
   BitfabError,
+  replayContextReady,
   getReplayContext,
+  runWithReplayContext,
+  MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES,
   warnOnce,
+  serializePayloadBody,
+  awaitOnExit,
   flushTraces,
-  HttpClient,
-  serializeValue,
-  deserializeValue,
-  toJsonSafe,
-  toJsonSafeReport,
-  randomUuid,
-  NO_MOCK_OVERRIDE,
-  resolveMockValue,
-  BITFAB_PROGRESS_PREFIX,
-  reportReplayProgress,
-  ReplayError,
-  DbBranchReplayError,
-  serializeReplayResult,
-  waitForReplayPersistence,
-  sleepForReplayPersistence,
-  replay
+  awaitPendingRequests,
+  parseRetryAfterMs,
+  HttpClient
 };
-//# sourceMappingURL=chunk-BNOVHUQB.js.map
+//# sourceMappingURL=chunk-A22EYRSY.js.map