@bitfab/sdk 0.33.7 → 0.34.0

package/dist/chunk-DPV6PBWE.js

@@ -1,916 +0,0 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-
-// 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",
-      "--no-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", path }))
-    ];
-    if (entries.length === 0) {
-      return null;
-    }
-    const files = [];
-    let totalBytes = 0;
-    for (const { status, path } of entries) {
-      if (files.length >= MAX_FILES) {
-        break;
-      }
-      const beforeBytes = status === "A" ? 0 : await blobBytes(base, path);
-      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}:${path}`]) ?? "").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 = [];
-  for (let i = 0; i + 1 < parts.length; i += 2) {
-    out.push({ status: parts[i].charAt(0), path: parts[i + 1] });
-  }
-  return out;
-}
-function looksBinary(s) {
-  return s.slice(0, 8e3).includes(NUL);
-}
-
-// src/errors.ts
-var BitfabError = class extends Error {
-  constructor(message, url) {
-    super(message);
-    this.url = url;
-    this.name = "BitfabError";
-  }
-};
-
-// src/mockOverride.ts
-function resolveMockValue(value, ctx) {
-  return typeof value === "function" ? value(ctx) : value;
-}
-function normalizeMockOverrides(mockOverride) {
-  if (mockOverride === void 0) {
-    return [];
-  }
-  return Array.isArray(mockOverride) ? mockOverride : [mockOverride];
-}
-
-// src/warnOnce.ts
-var warned = /* @__PURE__ */ new Set();
-function warnOnce(key, message) {
-  if (warned.has(key)) {
-    return;
-  }
-  warned.add(key);
-  try {
-    console.warn(`[bitfab] ${message}`);
-  } catch {
-  }
-}
-
-// 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/asyncStorage.ts
-var AsyncLocalStorageClass = null;
-var initDone = false;
-function registerAsyncLocalStorageClass(cls) {
-  if (!AsyncLocalStorageClass) {
-    AsyncLocalStorageClass = cls;
-  }
-  initDone = true;
-}
-function assertAsyncStorageRegistered() {
-  if (!AsyncLocalStorageClass) {
-    console.warn(
-      "Bitfab: AsyncLocalStorage not available - nested span context will not propagate."
-    );
-  }
-}
-var asyncStorageReady = (typeof process !== "undefined" && process.versions?.node ? (
-  // The join trick hides "node:async_hooks" from static analysis so
-  // bundlers that ban Node.js built-ins don't fail at build time.
-  // webpackIgnore tells webpack/turbopack to emit a native import()
-  // so Node.js can resolve the module at runtime.
-  import(
-    /* webpackIgnore: true */
-    ["node", "async_hooks"].join(":")
-  ).then(
-    (mod) => {
-      registerAsyncLocalStorageClass(mod.AsyncLocalStorage);
-    }
-  ).catch(() => {
-  })
-) : Promise.resolve()).then(() => {
-  initDone = true;
-});
-function isAsyncStorageInitDone() {
-  return initDone;
-}
-function createAsyncLocalStorage() {
-  return AsyncLocalStorageClass ? new AsyncLocalStorageClass() : null;
-}
-
-// src/replayContext.ts
-var replayContextStorage = null;
-var REPLAY_CONTEXT_STORAGE_SYMBOL = /* @__PURE__ */ Symbol.for("bitfab.replayContextStorage");
-var replayContextReady = asyncStorageReady.then(() => {
-  const shared = globalThis;
-  const existing = shared[REPLAY_CONTEXT_STORAGE_SYMBOL];
-  if (existing) {
-    replayContextStorage = existing;
-    return;
-  }
-  const created = createAsyncLocalStorage();
-  if (created) {
-    shared[REPLAY_CONTEXT_STORAGE_SYMBOL] = created;
-    replayContextStorage = created;
-  }
-});
-function getReplayContext() {
-  return replayContextStorage?.getStore() ?? null;
-}
-function runWithReplayContext(ctx, fn) {
-  if (replayContextStorage) {
-    return replayContextStorage.run(ctx, fn);
-  }
-  return fn();
-}
-
-// src/serialize.ts
-import superjson from "superjson";
-var MAX_SERIALIZED_BYTES = 512e3;
-var MAX_FRAMEWORK_SERIALIZED_BYTES = 2e6;
-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
-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)}
-`);
-  } catch {
-  }
-}
-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 inputs = [];
-  let originalOutput;
-  let result;
-  let error = null;
-  const pendingPersistence = [];
-  const originalTraceId = serverItem.originalTraceId ?? serverItem.sourceTraceId;
-  const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
-  try {
-    if (includeDbBranchLease && !lease && !leaseError) {
-      const resolved = await httpClient.resolveDbBranchLease(
-        testRunId,
-        originalTraceId,
-        dbBranchSettings
-      );
-      lease = resolved.lease ?? void 0;
-      leaseError = resolved.leaseError ?? void 0;
-      dbSnapshotRef = resolved.dbSnapshotRef ?? dbSnapshotRef;
-    }
-    if (leaseError) {
-      throw new BitfabError(
-        `Replay requested a database branch for trace ${originalTraceId} but it could not be resolved (${leaseError.code}): ${leaseError.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.`
-      );
-    }
-    const span = await httpClient.getExternalSpan(originalSpanId);
-    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
-        });
-        if (treeResponse.root) {
-          mockTree = buildMockTree(treeResponse.root);
-        } else if (mockStrategy === "all" || hasOverrides) {
-          throw new BitfabError(
-            `Replay mock strategy "${mockStrategy}"${hasOverrides ? " with overrides" : ""} requires a span tree root for original span ${originalSpanId}.`
-          );
-        } else {
-          mockTree = void 0;
-        }
-      } catch (e) {
-        if (mockStrategy === "all" || hasOverrides) {
-          throw e;
-        }
-        mockTree = void 0;
-      }
-    }
-    const outputCache = /* @__PURE__ */ new Map();
-    const fetchSpanOutput = mockTree && !includeOutputs ? (externalSpanId) => {
-      let pending = outputCache.get(externalSpanId);
-      if (!pending) {
-        pending = httpClient.getExternalSpan(externalSpanId).then(
-          (s) => deserializeOutput(
-            s.rawData?.span_data ?? {}
-          )
-        );
-        outputCache.set(externalSpanId, pending);
-      }
-      return pending;
-    } : void 0;
-    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,
-        pendingPersistence
-      },
-      () => fn(...inputs)
-    );
-    result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
-  } catch (e) {
-    error = e instanceof Error ? e.message : String(e);
-  } finally {
-    await Promise.allSettled(pendingPersistence);
-    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 {
-        }
-      }
-    }
-  }
-  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,
-    durationMs: serverItem.durationMs ?? null,
-    // 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: serverItem.model ?? null,
-    dbSnapshotRef: dbSnapshotRef ?? null
-  };
-}
-async function mapWithConcurrency(tasks, maxConcurrency, onSettled) {
-  const results = new Array(tasks.length);
-  let nextIndex = 0;
-  async function worker() {
-    while (nextIndex < tasks.length) {
-      const index = nextIndex++;
-      const result = await tasks[index]();
-      results[index] = result;
-      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?.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 resolvedOverrides = [
-    ...normalizeMockOverrides(options?.mockOverride),
-    ...registeredOverrides
-  ];
-  const replayedTraceIds = serverItems.map(() => randomUuid());
-  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;
-  let completed = 0;
-  let succeeded = 0;
-  let errored = 0;
-  const resultItems = await mapWithConcurrency(
-    tasks,
-    maxConcurrency,
-    options?.onProgress ? (item) => {
-      completed += 1;
-      if (item.error === null) {
-        succeeded += 1;
-      } else {
-        errored += 1;
-      }
-      try {
-        options?.onProgress?.({
-          testRunId,
-          completed,
-          total,
-          succeeded,
-          errored,
-          item: {
-            // The server replay trace id isn't known until completeReplay
-            // runs (below), so it can't be reported mid-run and we never
-            // emit the client-side placeholder. originalTraceId (the
-            // historical trace) is known now and is what a UI keys on to
-            // identify what just settled.
-            traceId: null,
-            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,
-            durationMs: item.durationMs,
-            tokens: item.tokens,
-            model: item.model,
-            dbSnapshotRef: item.dbSnapshotRef
-          }
-        });
-      } catch {
-      }
-    } : void 0
-  );
-  const completeResult = await httpClient.completeReplay(testRunId);
-  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 = 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.` : "";
-      throw 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.`
-      );
-    }
-    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: `${serviceUrl}${testRunUrl}`
-  };
-  await writeReplayResultFile(result);
-  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, `${JSON.stringify(result, null, 2)}
-`);
-  } 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 {
-  __privateGet,
-  __privateAdd,
-  __privateSet,
-  BitfabError,
-  warnOnce,
-  serializeValue,
-  deserializeValue,
-  toJsonSafe,
-  toJsonSafeReport,
-  randomUuid,
-  registerAsyncLocalStorageClass,
-  assertAsyncStorageRegistered,
-  asyncStorageReady,
-  isAsyncStorageInitDone,
-  createAsyncLocalStorage,
-  resolveMockValue,
-  getReplayContext,
-  BITFAB_PROGRESS_PREFIX,
-  reportReplayProgress,
-  replay
-};
-//# sourceMappingURL=chunk-DPV6PBWE.js.map