@bitfab/sdk 0.65.4 → 0.65.5

package/dist/chunk-27B3UBSS.js

@@ -1,2547 +0,0 @@
-// src/traceCompletion.ts
-var TraceCompletion = class {
-  constructor() {
-    this.traces = /* @__PURE__ */ new Map();
-    this.closed = /* @__PURE__ */ new Map();
-  }
-  state(traceId) {
-    let state = this.traces.get(traceId);
-    if (state === void 0) {
-      state = { spanIds: /* @__PURE__ */ new Set(), active: /* @__PURE__ */ new Set() };
-      this.traces.set(traceId, state);
-    }
-    return state;
-  }
-  start(traceId, spanId) {
-    if (this.closed.has(traceId)) {
-      return;
-    }
-    const state = this.state(traceId);
-    state.spanIds.add(spanId);
-    state.active.add(spanId);
-  }
-  open(traceId) {
-    if (!this.closed.has(traceId)) {
-      this.state(traceId);
-    }
-  }
-  hold(traceId, key) {
-    this.state(traceId).active.add(key);
-  }
-  record(traceId, spanId) {
-    if (!this.closed.has(traceId)) {
-      this.state(traceId).spanIds.add(spanId);
-    }
-  }
-  end(traceId, spanId) {
-    const state = this.traces.get(traceId);
-    if (state !== void 0) {
-      state.active.delete(spanId);
-      this.drain(traceId, state);
-    }
-  }
-  abort(traceId, spanId) {
-    const state = this.traces.get(traceId);
-    if (state === void 0) {
-      return;
-    }
-    state.active.delete(spanId);
-    state.spanIds.delete(spanId);
-    if (state.active.size === 0 && state.spanIds.size === 0 && state.complete === void 0) {
-      this.traces.delete(traceId);
-      return;
-    }
-    this.drain(traceId, state);
-  }
-  close(traceId, complete, dropped = false) {
-    const count = this.closed.get(traceId);
-    if (count !== void 0) {
-      complete(count);
-      return;
-    }
-    const state = this.traces.get(traceId);
-    if (state === void 0) {
-      return;
-    }
-    state.complete = complete;
-    if (dropped) {
-      state.active.clear();
-    }
-    this.drain(traceId, state);
-  }
-  drain(traceId, state) {
-    if (state.active.size !== 0 || state.complete === void 0) {
-      return;
-    }
-    this.traces.delete(traceId);
-    this.closed.set(traceId, state.spanIds.size);
-    if (this.closed.size > 1024) {
-      const oldest = this.closed.keys().next().value;
-      if (oldest !== void 0) {
-        this.closed.delete(oldest);
-      }
-    }
-    state.complete(state.spanIds.size);
-  }
-};
-
-// src/readEnv.ts
-function readEnv(name) {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[name];
-  }
-  return void 0;
-}
-
-// src/compress.ts
-var DISABLE_COMPRESSION_ENV = "BITFAB_DISABLE_COMPRESSION";
-var MIN_COMPRESSED_BYTES = 8192;
-var gzipNode;
-var _nodeGzipReady = (typeof process !== "undefined" && process.versions?.node ? (
-  // The join trick hides "node:zlib" 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. Same pattern as `asyncStorage.ts`.
-  import(
-    /* webpackIgnore: true */
-    ["node", "zlib"].join(":")
-  ).then(({ gzip }) => {
-    gzipNode = (data) => new Promise((resolve, reject) => {
-      gzip(data, (error, result) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(result);
-        }
-      });
-    });
-  }).catch(() => {
-  })
-) : Promise.resolve()).then(() => {
-});
-function toArrayBuffer(view) {
-  return view.buffer.slice(
-    view.byteOffset,
-    view.byteOffset + view.byteLength
-  );
-}
-function compressedRequest(body, rawBytes, compressed) {
-  if (compressed.byteLength >= rawBytes) {
-    return { body, rawBytes, wireBytes: rawBytes };
-  }
-  return {
-    body: compressed instanceof Uint8Array ? toArrayBuffer(compressed) : compressed,
-    contentEncoding: "gzip",
-    rawBytes,
-    wireBytes: compressed.byteLength
-  };
-}
-async function gzipViaStream(bytes) {
-  const stream = new Blob([bytes]).stream().pipeThrough(new CompressionStream("gzip"));
-  return await new Response(stream).arrayBuffer();
-}
-function encodeRequestBody(body) {
-  if (readEnv(DISABLE_COMPRESSION_ENV)) {
-    const rawBytes = new TextEncoder().encode(body).byteLength;
-    return { body, rawBytes, wireBytes: rawBytes };
-  }
-  const bytes = new TextEncoder().encode(body);
-  if (bytes.byteLength < MIN_COMPRESSED_BYTES) {
-    return {
-      body,
-      rawBytes: bytes.byteLength,
-      wireBytes: bytes.byteLength
-    };
-  }
-  if (gzipNode) {
-    return gzipNode(bytes).then(
-      (compressed) => compressedRequest(body, bytes.byteLength, compressed),
-      () => ({
-        body,
-        rawBytes: bytes.byteLength,
-        wireBytes: bytes.byteLength
-      })
-    );
-  }
-  if (typeof CompressionStream === "undefined") {
-    return {
-      body,
-      rawBytes: bytes.byteLength,
-      wireBytes: bytes.byteLength
-    };
-  }
-  return gzipViaStream(bytes).then(
-    (compressed) => compressedRequest(body, bytes.byteLength, compressed),
-    () => ({
-      body,
-      rawBytes: bytes.byteLength,
-      wireBytes: bytes.byteLength
-    })
-  );
-}
-
-// src/version.generated.ts
-var __version__ = "0.65.4";
-var __packageName__ = "@bitfab/sdk";
-
-// 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/gitCommand.ts
-var EXIT_GRACE_MS = 500;
-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, env) => new Promise((resolve) => {
-    let child;
-    try {
-      child = spawn("git", args, {
-        cwd: dir,
-        detached: process.platform !== "win32",
-        stdio: ["ignore", "pipe", "pipe"],
-        ...env ? { env: { ...process.env, ...env } } : {}
-      });
-    } 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);
-    }
-  });
-}
-
-// src/gitState.ts
-var GIT_TIMEOUT_MS = 3e4;
-var GIT_MAX_BUFFER = 1024 * 1024;
-var DISABLE_ENV = "BITFAB_DISABLE_GIT_STATE";
-var SHA_PATTERN = /^[0-9a-f]{40}$/;
-function sha(value) {
-  const trimmed = value?.trim();
-  return trimmed && SHA_PATTERN.test(trimmed) ? trimmed : null;
-}
-function text(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : null;
-}
-function isEmptyGitState(state) {
-  return Object.values(state).every((value) => value === null);
-}
-async function resolveGitState(cwd) {
-  const git = await gitRunner({
-    timeoutMs: GIT_TIMEOUT_MS,
-    maxBuffer: GIT_MAX_BUFFER,
-    keepProcessAlive: true
-  });
-  if (!git) {
-    return null;
-  }
-  const run = async (args, env) => (await git(cwd, args, env))?.trim() ?? null;
-  const [refs, email, branch] = await Promise.all([
-    run(["rev-parse", "--show-toplevel", "HEAD", "HEAD^{tree}"]),
-    run(["config", "user.email"]),
-    run(["symbolic-ref", "--short", "-q", "HEAD"])
-  ]);
-  const [root, commitSha, baseSha] = (refs ?? "").split("\n");
-  if (!root) {
-    return null;
-  }
-  const state = {
-    githubEmail: text(email),
-    branch: text(branch),
-    commitSha: sha(commitSha),
-    baseSha: sha(baseSha),
-    experimentSha: await resolveWorkingTreeSha(run, root.trim())
-  };
-  return isEmptyGitState(state) ? null : state;
-}
-async function resolveWorkingTreeSha(run, root) {
-  let indexPath;
-  let cleanup;
-  try {
-    const { mkdtemp, rm } = await import("fs/promises");
-    const { join } = await import("path");
-    const { tmpdir } = await import("os");
-    const dir = await mkdtemp(join(tmpdir(), "bitfab-git-"));
-    indexPath = join(dir, "index");
-    cleanup = () => rm(dir, { recursive: true, force: true });
-  } catch {
-    return null;
-  }
-  try {
-    const env = { GIT_INDEX_FILE: indexPath };
-    if (await run(["read-tree", "HEAD"], env) === null) {
-      return null;
-    }
-    if (await run(["add", "-A", "--", root], env) === null) {
-      return null;
-    }
-    return sha(await run(["write-tree"], env));
-  } catch {
-    return null;
-  } finally {
-    await cleanup().catch(() => {
-    });
-  }
-}
-function resolvedGitState() {
-  if (typeof process === "undefined" || process.env?.[DISABLE_ENV]) {
-    return Promise.resolve(null);
-  }
-  let cwd;
-  try {
-    cwd = process.cwd?.() ?? ".";
-  } catch {
-    return Promise.resolve(null);
-  }
-  return resolveGitState(cwd).catch(() => null);
-}
-
-// src/asyncStorage.ts
-var AsyncLocalStorageClass = null;
-var initDone = false;
-function registerAsyncLocalStorageClass(cls) {
-  if (!AsyncLocalStorageClass) {
-    AsyncLocalStorageClass = cls;
-  }
-  initDone = true;
-}
-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 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 runWithReplayContext(ctx, fn) {
-  if (replayContextStorage) {
-    return replayContextStorage.run(ctx, fn);
-  }
-  return fn();
-}
-
-// src/captureSuppression.ts
-var suppressionGlobal = globalThis;
-var suppressionState = suppressionGlobal.__bitfabCaptureSuppressionV1 ?? { depth: 0 };
-suppressionGlobal.__bitfabCaptureSuppressionV1 = suppressionState;
-function runWithCaptureSuppressed(fn) {
-  suppressionState.depth += 1;
-  try {
-    return fn();
-  } finally {
-    suppressionState.depth -= 1;
-  }
-}
-
-// src/payloadBudget.ts
-var MAX_SPAN_CARRIER_BYTES = 28e5;
-var MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES = 78e5;
-var textEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
-function byteLength(value) {
-  return textEncoder ? textEncoder.encode(value).length : value.length;
-}
-function carrierByteLength(body) {
-  return carrierBytesOf(textEncoder ? textEncoder.encode(body) : null, body);
-}
-function carrierBytesOf(encoded, body) {
-  if (!encoded) {
-    return body.length + 2;
-  }
-  let extra = 2;
-  for (let i = 0; i < encoded.length; i++) {
-    const byte = encoded[i];
-    if (byte === 34 || byte === 92) {
-      extra += 1;
-    } else if (byte < 32) {
-      extra += byte === 8 || byte === 9 || byte === 10 || byte === 12 || byte === 13 ? 1 : 5;
-    }
-  }
-  return encoded.length + extra;
-}
-var MAX_BYTES_PER_UNIT = 3;
-function fitsCarrierBudget(body, maxBytes = MAX_SPAN_CARRIER_BYTES) {
-  const units = body.length;
-  if (units * MAX_BYTES_PER_UNIT + 2 <= maxBytes) {
-    return true;
-  }
-  if (units + 2 > maxBytes) {
-    return false;
-  }
-  return carrierByteLength(body) <= maxBytes;
-}
-var STRUCTURAL_SPAN_KEYS = /* @__PURE__ */ new Set([
-  "name",
-  "type",
-  "function_name",
-  "error_source"
-]);
-function asRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function cloneTrimmable(payload) {
-  const copy = { ...payload };
-  const containers = [];
-  const spanData = asRecord(copy.span_data);
-  if (spanData) {
-    const clone = { ...spanData };
-    copy.span_data = clone;
-    containers.push(clone);
-  }
-  const rawSpan = asRecord(copy.rawSpan);
-  const rawSpanData = rawSpan && asRecord(rawSpan.span_data);
-  if (rawSpan && rawSpanData) {
-    const clone = { ...rawSpanData };
-    copy.rawSpan = { ...rawSpan, span_data: clone };
-    containers.push(clone);
-  }
-  if (containers.length === 0) {
-    containers.push(copy);
-  }
-  return { copy, containers };
-}
-function collectCandidates(containers) {
-  const candidates = [];
-  for (const container of containers) {
-    for (const [key, value] of Object.entries(container)) {
-      if (STRUCTURAL_SPAN_KEYS.has(key) || value == null) {
-        continue;
-      }
-      let size;
-      try {
-        size = byteLength(JSON.stringify(value) ?? "");
-      } catch {
-        continue;
-      }
-      candidates.push({ container, key, size });
-    }
-  }
-  return candidates.sort((a, b) => b.size - a.size);
-}
-function trimPayloadToBudget(payload, encode, maxBytes = MAX_SPAN_CARRIER_BYTES) {
-  const { copy, containers } = cloneTrimmable(payload);
-  const candidates = collectCandidates(containers);
-  if (candidates.length === 0) {
-    return void 0;
-  }
-  const trimmed = [];
-  for (const candidate of candidates) {
-    candidate.container[candidate.key] = `<unserializable: too_large_${candidate.size}_bytes>`;
-    trimmed.push(candidate.key);
-    let body;
-    try {
-      body = encode(copy);
-    } catch {
-      return void 0;
-    }
-    if (fitsCarrierBudget(body, maxBytes)) {
-      return { value: copy, trimmed };
-    }
-  }
-  return void 0;
-}
-function markPayloadTrimmed(value, trimmed, maxBytes = MAX_SPAN_CARRIER_BYTES) {
-  const existing = Array.isArray(value.errors) ? value.errors : [];
-  value.errors = [
-    ...existing,
-    {
-      source: "sdk",
-      step: "payload_budget",
-      error: `trimmed oversized field(s) to fit the ${maxBytes}-byte span carrier budget: ${[
-        ...new Set(trimmed)
-      ].join(", ")}`
-    }
-  ];
-}
-
-// src/warnOnce.ts
-var warned = /* @__PURE__ */ new Set();
-function warn(message) {
-  try {
-    console.warn(`[bitfab] ${message}`);
-  } catch {
-  }
-}
-function warnOnce(key, message) {
-  if (warned.has(key)) {
-    return;
-  }
-  warned.add(key);
-  warn(message);
-}
-function writeOnce(key, line, write = console.warn) {
-  if (warned.has(key)) {
-    return;
-  }
-  warned.add(key);
-  try {
-    write(line);
-  } catch {
-  }
-}
-
-// src/serializePayload.ts
-function serializePayloadBody(payload, maxCarrierBytes = MAX_SPAN_CARRIER_BYTES) {
-  return runWithCaptureSuppressed(
-    () => encodeWithinBudget(payload, maxCarrierBytes)
-  );
-}
-function encodeWithinBudget(payload, maxCarrierBytes) {
-  const encoded = encodePayloadBody(payload);
-  if (fitsCarrierBudget(encoded.body, maxCarrierBytes)) {
-    return { body: encoded.body, dropped: encoded.dropped };
-  }
-  return applyPayloadBudget(encoded, maxCarrierBytes);
-}
-function applyPayloadBudget(encoded, maxCarrierBytes) {
-  const result = encoded.value ? trimPayloadToBudget(
-    encoded.value,
-    (value) => encodePayloadBody(value).body,
-    maxCarrierBytes
-  ) : void 0;
-  if (!result) {
-    return { body: encoded.body, dropped: encoded.dropped };
-  }
-  warnOnce(
-    "payload:over-budget",
-    `a span payload exceeded the ${maxCarrierBytes}-byte carrier budget; its largest field(s) (${[
-      ...new Set(result.trimmed)
-    ].join(
-      ", "
-    )}) were replaced with placeholders so the span still ships. The span is incomplete and may not be replayable.`
-  );
-  markPayloadTrimmed(result.value, result.trimmed, maxCarrierBytes);
-  return {
-    body: encodePayloadBody(result.value).body,
-    dropped: encoded.dropped
-  };
-}
-function encodePayloadBody(payload) {
-  try {
-    return { body: JSON.stringify(payload), dropped: [], value: payload };
-  } catch {
-    const dropped = [];
-    const sanitize = (value, seen) => {
-      const t = typeof value;
-      if (value === null || t === "string" || t === "number" || t === "boolean") {
-        return value;
-      }
-      if (t === "bigint") {
-        dropped.push("BigInt");
-        return "<unserializable: BigInt>";
-      }
-      if (t === "function") {
-        const name = value.name || "Function";
-        dropped.push(name);
-        return `<unserializable: ${name}>`;
-      }
-      if (t === "symbol") {
-        dropped.push("Symbol");
-        return "<unserializable: Symbol>";
-      }
-      if (t !== "object") {
-        return void 0;
-      }
-      const obj = value;
-      const className = obj.constructor?.name || "object";
-      if (seen.has(obj)) {
-        dropped.push(className);
-        return `<cycle: ${className}>`;
-      }
-      seen.add(obj);
-      let result;
-      if (Array.isArray(obj)) {
-        result = obj.map((item) => sanitize(item, seen));
-      } else if (typeof obj.toJSON === "function") {
-        try {
-          result = sanitize(obj.toJSON(), seen);
-        } catch {
-          dropped.push(className);
-          result = `<unserializable: ${className}>`;
-        }
-      } else {
-        try {
-          const out = {};
-          for (const [k, v] of Object.entries(obj)) {
-            out[k] = sanitize(v, seen);
-          }
-          result = out;
-        } catch {
-          warnOnce(
-            "payload:field-getter-threw",
-            "a value with a throwing getter/proxy could not be serialized into a span payload; it was replaced with a placeholder. The span still ships with its other fields intact."
-          );
-          dropped.push(className);
-          result = `<unserializable: ${className}>`;
-        }
-      }
-      seen.delete(obj);
-      return result;
-    };
-    let sanitized;
-    try {
-      sanitized = sanitize(payload, /* @__PURE__ */ new WeakSet());
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      const marker = { error: `payload_serialize_failed: ${message}` };
-      return { body: JSON.stringify(marker), dropped, value: marker };
-    }
-    const isRecord = typeof sanitized === "object" && sanitized !== null && !Array.isArray(sanitized);
-    if (dropped.length > 0 && isRecord) {
-      const obj = sanitized;
-      const existing = Array.isArray(obj.errors) ? obj.errors : [];
-      obj.errors = [
-        ...existing,
-        {
-          source: "sdk",
-          step: "json_serialize",
-          error: `stubbed non-serializable value(s): ${[
-            ...new Set(dropped)
-          ].join(", ")}`
-        }
-      ];
-    }
-    return {
-      body: JSON.stringify(sanitized),
-      dropped,
-      value: isRecord ? sanitized : void 0
-    };
-  }
-}
-
-// src/spanOrigin.ts
-var FRAMEWORK_INSTRUMENTATIONS = [
-  "openai-agents",
-  "langgraph",
-  "claude-agent-sdk",
-  "vercel-ai",
-  "rivet"
-];
-var FRAMEWORK_INSTRUMENTATION_SET = new Set(
-  FRAMEWORK_INSTRUMENTATIONS
-);
-
-// src/simulationPlan.ts
-var SIMULATION_PLAN_READ_TIMEOUT_MS = 5e3;
-var NO_API_KEY_FOR_SIMULATION_PLAN = "no API key is set";
-var ROOT_TRACE_FUNCTION_KEY_FIELD = "rootTraceFunctionKey";
-var DECLARED_NODE_FIELD = "declaredNode";
-function planWaitSliceMs(timeoutMs) {
-  return Math.min(SIMULATION_PLAN_READ_TIMEOUT_MS, Math.max(timeoutMs, 0) / 2);
-}
-
-// src/traceMetadata.ts
-var activeRecords = /* @__PURE__ */ new Map();
-var completedRecords = /* @__PURE__ */ new Map();
-function findRecord(traceId) {
-  return activeRecords.get(traceId) ?? completedRecords.get(traceId);
-}
-function warnAboutShadowedKeys(traceId, record) {
-  const shadowed = Object.keys(record.derived).filter(
-    (key) => key in record.caller && record.caller[key] !== record.derived[key] && !record.warnedKeys.has(key)
-  ).sort();
-  if (shadowed.length === 0) {
-    return;
-  }
-  for (const key of shadowed) {
-    record.warnedKeys.add(key);
-  }
-  warn(
-    `trace metadata key(s) ${shadowed.join(", ")} on trace ${traceId} were set both by the caller and by an integration's own trace export; the caller's value is the one kept on the trace.`
-  );
-}
-function mergeCallerMetadataIntoTracePayload(payload) {
-  const externalTrace = payload.externalTrace;
-  if (typeof externalTrace !== "object" || externalTrace === null) {
-    return payload;
-  }
-  const external = externalTrace;
-  const traceId = typeof payload.id === "string" && payload.id !== "" ? payload.id : external.id;
-  if (typeof traceId !== "string" || traceId === "") {
-    return payload;
-  }
-  const record = findRecord(traceId);
-  if (!record || Object.keys(record.caller).length === 0) {
-    return payload;
-  }
-  const exported = external.metadata;
-  if (typeof exported === "object" && exported !== null) {
-    Object.assign(record.derived, exported);
-  }
-  warnAboutShadowedKeys(traceId, record);
-  return {
-    ...payload,
-    externalTrace: {
-      ...external,
-      metadata: { ...record.derived, ...record.caller }
-    }
-  };
-}
-
-// src/otel.ts
-import { SpanStatusCode } from "@opentelemetry/api";
-import {
-  ExportResultCode
-} from "@opentelemetry/core";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import {
-  AlwaysOnSampler,
-  BasicTracerProvider,
-  BatchSpanProcessor
-} from "@opentelemetry/sdk-trace-base";
-
-// src/transportTypes.ts
-var DeliveryError = class extends Error {
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "DeliveryError";
-    this.retryable = options.retryable ?? false;
-    this.oversized = options.oversized ?? false;
-    this.retryAfterMs = options.retryAfterMs;
-  }
-};
-
-// src/unrefTimer.ts
-function unrefTimer(timer) {
-  const handle = timer;
-  if (typeof handle.unref === "function") {
-    handle.unref();
-  }
-}
-
-// src/otel.ts
-var OPERATION_ATTRIBUTE = "bitfab.operation";
-var PAYLOAD_ATTRIBUTE = "bitfab.payload";
-var MAX_EXPORT_REQUEST_BYTES = 3e6;
-var MAX_DECOMPRESSED_REQUEST_BYTES = 8e6;
-var MAX_REQUEST_BYTES_ENV = "BITFAB_OTEL_MAX_REQUEST_BYTES";
-var EXPORT_CONCURRENCY_ENV = "BITFAB_OTEL_EXPORT_CONCURRENCY";
-var MAX_QUEUE_SIZE = 16384;
-var DIRECT_MAX_EXPORT_BATCH_SIZE = 512;
-var DIRECT_MAX_REQUEST_BATCH_SIZE = 256;
-var DEFAULT_EXPORT_CONCURRENCY = 32;
-var MAX_EXPORT_CONCURRENCY = 64;
-var SCHEDULE_DELAY_MILLIS = 5e3;
-var EXPORT_TIMEOUT_MILLIS = 3e4;
-var RETRY_BASE_DELAY_MILLIS = 100;
-var RETRY_BACKOFF_CEILING_MILLIS = 5e3;
-var MAX_SEND_ATTEMPTS = 3;
-var DEFAULT_LIFECYCLE_TIMEOUT_MS = 3e4;
-var liveTransports = /* @__PURE__ */ new Set();
-var carrierRefs = /* @__PURE__ */ new WeakMap();
-function readBoundedIntEnv(name, max, fallback, warnKey) {
-  const raw = readEnv(name);
-  if (raw === void 0) {
-    return fallback;
-  }
-  const value = Number(raw);
-  if (Number.isInteger(value) && value > 0 && value <= max) {
-    return value;
-  }
-  warnOnce(
-    warnKey,
-    `${name} must be a positive integer no greater than ${max}; using ${fallback}`
-  );
-  return fallback;
-}
-function logError(message, error) {
-  try {
-    if (error === void 0) {
-      console.error(`[bitfab] ${message}`);
-    } else {
-      console.error(`[bitfab] ${message}`, error);
-    }
-  } catch {
-  }
-}
-function otlpValue(value) {
-  if (typeof value === "boolean") {
-    return { boolValue: value };
-  }
-  if (typeof value === "number") {
-    return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
-  }
-  if (typeof value === "string") {
-    return { stringValue: value };
-  }
-  if (Array.isArray(value)) {
-    return { arrayValue: { values: value.map(otlpValue) } };
-  }
-  return { stringValue: String(value) };
-}
-function otlpAttributes(attributes) {
-  if (!attributes) {
-    return [];
-  }
-  return Object.entries(attributes).filter(([, value]) => value !== void 0).map(([key, value]) => ({ key, value: otlpValue(value) }));
-}
-function hrTimeToNanoString(time) {
-  if (!time) {
-    return "0";
-  }
-  return `${time[0]}${String(time[1]).padStart(9, "0")}`;
-}
-function spanToOtlp(span) {
-  const spanContext = span.spanContext();
-  const result = {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    name: span.name,
-    kind: span.kind + 1,
-    startTimeUnixNano: hrTimeToNanoString(span.startTime),
-    endTimeUnixNano: hrTimeToNanoString(span.endTime),
-    attributes: otlpAttributes(span.attributes),
-    droppedAttributesCount: span.droppedAttributesCount,
-    droppedEventsCount: span.droppedEventsCount,
-    droppedLinksCount: span.droppedLinksCount,
-    status: {
-      code: span.status.code,
-      ...span.status.message ? { message: span.status.message } : {}
-    },
-    flags: spanContext.traceFlags
-  };
-  const parentSpanId = span.parentSpanContext?.spanId;
-  if (parentSpanId) {
-    result.parentSpanId = parentSpanId;
-  }
-  if (spanContext.traceState) {
-    result.traceState = spanContext.traceState.serialize();
-  }
-  return result;
-}
-var SPAN_SEPARATOR_BYTES = 1;
-function encodeSpan(span) {
-  const json = JSON.stringify(spanToOtlp(span));
-  return {
-    json,
-    size: byteLength(json),
-    ref: carrierRefs.get(span)
-  };
-}
-function trimEncodedSpan(span) {
-  try {
-    const carrier = JSON.parse(span.json);
-    const attribute = carrier.attributes?.find(
-      (entry) => entry.key === PAYLOAD_ATTRIBUTE
-    );
-    const payloadBody = attribute?.value?.stringValue;
-    if (!attribute?.value || payloadBody === void 0) {
-      return void 0;
-    }
-    const payload = JSON.parse(payloadBody);
-    attribute.value.stringValue = serializePayloadBody(
-      payload,
-      MAX_SPAN_CARRIER_BYTES
-    ).body;
-    const json = JSON.stringify(carrier);
-    return { json, size: byteLength(json) };
-  } catch {
-    return void 0;
-  }
-}
-async function prepareRequest(body) {
-  const prepared = encodeRequestBody(body);
-  return prepared instanceof Promise ? await prepared : prepared;
-}
-function requestEnvelope(first) {
-  const scope = first.instrumentationScope;
-  const resource = JSON.stringify({
-    attributes: otlpAttributes(
-      first.resource.attributes
-    )
-  });
-  const scopeJson = JSON.stringify({
-    name: scope.name,
-    version: scope.version ?? ""
-  });
-  const head = `{"resourceSpans":[{"resource":${resource},"scopeSpans":[{"scope":${scopeJson},"spans":[`;
-  const tail = "]}]}]}";
-  return { head, tail, size: byteLength(head) + byteLength(tail) };
-}
-function encodeRequest(envelope, spans) {
-  return envelope.head + spans.map((span) => span.json).join(",") + envelope.tail;
-}
-function delay(ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    unrefTimer(timer);
-  });
-}
-async function withDeadline(work, timeoutMs) {
-  let timer;
-  try {
-    return await Promise.race([
-      work,
-      new Promise((resolve) => {
-        timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
-        unrefTimer(timer);
-      })
-    ]);
-  } finally {
-    if (timer) {
-      clearTimeout(timer);
-    }
-  }
-}
-async function mapWithConcurrency(items, limit, task) {
-  const results = new Array(items.length);
-  let next = 0;
-  const workers = Array.from(
-    { length: Math.min(Math.max(limit, 1), items.length) },
-    async () => {
-      while (next < items.length) {
-        const index = next;
-        next += 1;
-        results[index] = await task(items[index]);
-      }
-    }
-  );
-  await Promise.all(workers);
-  return results;
-}
-function isRetryable(error) {
-  return error instanceof DeliveryError && error.retryable;
-}
-function isOversized(error) {
-  return error instanceof DeliveryError && error.oversized;
-}
-function retryWaitMillis(error, attempt, remainingMillis) {
-  const requested = error instanceof DeliveryError ? error.retryAfterMs : void 0;
-  const affordable = remainingMillis / 2;
-  if (requested !== void 0) {
-    return requested < affordable ? requested : null;
-  }
-  const backoff = Math.min(
-    RETRY_BASE_DELAY_MILLIS * 2 ** attempt,
-    RETRY_BACKOFF_CEILING_MILLIS
-  );
-  const jittered = backoff / 2 + Math.random() * (backoff / 2);
-  return jittered < affordable ? jittered : null;
-}
-var BitfabSpanExporter = class {
-  constructor(directSender, maxRequestBytes, maxRequestBatchSize, exportConcurrency, onDelivered, exportTimeoutMillis = EXPORT_TIMEOUT_MILLIS) {
-    this.directSender = directSender;
-    this.maxRequestBytes = maxRequestBytes;
-    this.maxRequestBatchSize = maxRequestBatchSize;
-    this.exportConcurrency = exportConcurrency;
-    this.onDelivered = onDelivered;
-    this.exportTimeoutMillis = exportTimeoutMillis;
-    /** Epoch ms until which the server has asked this exporter to stay away. */
-    this.throttledUntil = 0;
-  }
-  export(spans, resultCallback) {
-    void this.exportAsync(spans).then(
-      (succeeded) => {
-        resultCallback({
-          code: succeeded ? ExportResultCode.SUCCESS : ExportResultCode.FAILED
-        });
-      },
-      (error) => {
-        resultCallback({ code: ExportResultCode.FAILED, error });
-      }
-    );
-  }
-  async exportAsync(spans) {
-    if (spans.length === 0) {
-      return true;
-    }
-    let encoded;
-    let envelope;
-    try {
-      encoded = spans.map(encodeSpan);
-      envelope = requestEnvelope(spans[0]);
-    } catch (error) {
-      logError("failed to encode an OpenTelemetry span batch", error);
-      return false;
-    }
-    const batches = this.buildRequestBatches(envelope, encoded);
-    const results = await mapWithConcurrency(
-      batches,
-      this.exportConcurrency,
-      (batch) => this.send(envelope, batch)
-    );
-    return results.every(Boolean);
-  }
-  buildRequestBatches(envelope, spans) {
-    const batches = [];
-    let current = [];
-    let size = envelope.size;
-    for (const span of spans) {
-      const addition = span.size + (current.length > 0 ? SPAN_SEPARATOR_BYTES : 0);
-      if (current.length > 0 && (current.length >= this.maxRequestBatchSize || size + addition > this.maxRequestBytes)) {
-        batches.push({ spans: current, size });
-        current = [];
-        size = envelope.size;
-      }
-      current.push(span);
-      size += span.size + (current.length > 1 ? SPAN_SEPARATOR_BYTES : 0);
-    }
-    if (current.length > 0) {
-      batches.push({ spans: current, size });
-    }
-    return batches;
-  }
-  async send(envelope, batch) {
-    try {
-      let requestSpans = batch.spans;
-      let requestRawBytes = batch.size;
-      let alreadyTrimmed = false;
-      while (true) {
-        if (requestRawBytes <= MAX_DECOMPRESSED_REQUEST_BYTES) {
-          const prepared = await prepareRequest(
-            encodeRequest(envelope, requestSpans)
-          );
-          if (prepared.wireBytes <= this.maxRequestBytes) {
-            await this.sendWithRetries(prepared);
-            this.reportDelivered(batch.spans);
-            return true;
-          }
-        }
-        if (batch.spans.length !== 1) {
-          logError(
-            "an OpenTelemetry span batch exceeded the configured request-size target and could not be exported"
-          );
-          return false;
-        }
-        if (alreadyTrimmed) {
-          logError(
-            "a single OpenTelemetry span exceeded the configured request-size target after trimming"
-          );
-          return false;
-        }
-        const trimmed = trimEncodedSpan(batch.spans[0]);
-        if (!trimmed) {
-          logError(
-            "a single OpenTelemetry span exceeded the configured request-size target and could not be trimmed"
-          );
-          return false;
-        }
-        requestSpans = [trimmed];
-        requestRawBytes = envelope.size + trimmed.size;
-        alreadyTrimmed = true;
-      }
-    } catch (error) {
-      if (isOversized(error)) {
-        logError(
-          batch.spans.length === 1 ? "a single OpenTelemetry span exceeded the ingestion request limit and could not be exported" : "an OpenTelemetry span batch exceeded the ingestion request limit and could not be exported"
-        );
-        return false;
-      }
-      logError("failed to export an OpenTelemetry span batch", error);
-      return false;
-    }
-  }
-  /**
-   * Retries transient failures. Span and trace-completion carriers are safe to
-   * retry: the server keys them idempotently on `sourceSpanId`/`sourceTraceId`,
-   * so a duplicate delivery cannot create a duplicate row.
-   *
-   * KNOWN LIMITATION: an `internal_trace` (a `call()` BAML trace) carries no
-   * such key, so retrying a batch that holds one can create a duplicate trace -
-   * including when a request times out client-side but the server goes on to
-   * persist it. Accepted deliberately for now, matching the other SDKs, rather
-   * than skipping retries for a whole batch or inventing an idempotency scheme
-   * the server does not yet understand. The fix is a client-supplied
-   * idempotency key that ingestion dedupes on.
-   */
-  /**
-   * Remember a throttle the server asked for, so the requests fanned out
-   * alongside this one respect it too. Delaying only the request that was
-   * refused leaves the other seven in the window hitting a server that just
-   * asked for room.
-   */
-  recordThrottle(error) {
-    const requested = error instanceof DeliveryError ? error.retryAfterMs : void 0;
-    if (requested !== void 0) {
-      this.throttledUntil = Math.max(
-        this.throttledUntil,
-        Date.now() + requested
-      );
-    }
-  }
-  /**
-   * Waits out an active throttle, or reports the batch undeliverable when the
-   * throttle outlasts what we are willing to hold it for. Either way nothing is
-   * sent while the server has asked us to stay away.
-   */
-  async awaitThrottle(deadline) {
-    const remaining = this.throttledUntil - Date.now();
-    if (remaining <= 0) {
-      return;
-    }
-    if (remaining >= (deadline - Date.now()) / 2) {
-      throw new DeliveryError(
-        `OTLP ingestion is throttled for another ${remaining}ms, longer than the export budget`
-      );
-    }
-    await delay(remaining);
-  }
-  async sendWithRetries(request) {
-    const deadline = Date.now() + this.exportTimeoutMillis;
-    for (let attempt = 0; attempt < MAX_SEND_ATTEMPTS; attempt += 1) {
-      try {
-        await this.awaitThrottle(deadline);
-        await this.directSender(request, Math.max(0, deadline - Date.now()));
-        return;
-      } catch (error) {
-        if (isOversized(error)) {
-          throw error;
-        }
-        this.recordThrottle(error);
-        if (attempt === MAX_SEND_ATTEMPTS - 1 || !isRetryable(error)) {
-          throw error;
-        }
-        const wait = retryWaitMillis(error, attempt, deadline - Date.now());
-        if (wait === null) {
-          throw error;
-        }
-        await delay(wait);
-      }
-    }
-  }
-  /**
-   * Announce the carriers a request delivered. Wrapped because a listener that
-   * throws must never turn a delivered batch into a failed export.
-   */
-  reportDelivered(spans) {
-    if (this.onDelivered === void 0) {
-      return;
-    }
-    const refs = spans.map((span) => span.ref).filter((ref) => ref !== void 0);
-    if (refs.length === 0) {
-      return;
-    }
-    try {
-      this.onDelivered(refs);
-    } catch (error) {
-      logError("a delivery listener threw", error);
-    }
-  }
-  async shutdown() {
-  }
-  async forceFlush() {
-  }
-};
-var DeliveryTrackingExporter = class {
-  constructor(exporter) {
-    this.exporter = exporter;
-    // Deliberately unscoped, matching the Python SDK. An export can outlive
-    // OTel's export timeout and report failure after the flush that was waiting
-    // on it already returned, so that failure surfaces on the NEXT flush instead.
-    // That over-reports: a good flush can inherit an older failure. The
-    // alternative - discarding failures from completed flush windows - under-
-    // reports, and `BatchSpanProcessor` also runs scheduled exports that belong
-    // to no flush at all, so their failures would vanish entirely. For a
-    // telemetry SDK a false "flush failed" is investigable; a false "flush
-    // succeeded" silently loses traces. We take the noisy direction on purpose.
-    this.failedExports = 0;
-  }
-  export(spans, resultCallback) {
-    try {
-      this.exporter.export(spans, (result) => {
-        if (result.code !== ExportResultCode.SUCCESS) {
-          this.failedExports += 1;
-        }
-        resultCallback(result);
-      });
-    } catch (error) {
-      this.failedExports += 1;
-      resultCallback({ code: ExportResultCode.FAILED, error });
-    }
-  }
-  takeFailedExports() {
-    const failed = this.failedExports;
-    this.failedExports = 0;
-    return failed;
-  }
-  shutdown() {
-    return this.exporter.shutdown();
-  }
-  forceFlush() {
-    return this.exporter.forceFlush?.() ?? Promise.resolve();
-  }
-};
-var OtelBatchTransport = class {
-  constructor(options) {
-    this.closed = false;
-    const maxRequestBytes = options.maxRequestBytes ?? MAX_EXPORT_REQUEST_BYTES;
-    const maxRequestBatchSize = options.maxRequestBatchSize ?? DIRECT_MAX_REQUEST_BATCH_SIZE;
-    if (maxRequestBatchSize <= 0) {
-      throw new BitfabError("maxRequestBatchSize must be a positive integer");
-    }
-    this.deliveryTracker = new DeliveryTrackingExporter(
-      new BitfabSpanExporter(
-        options.directSender,
-        maxRequestBytes,
-        maxRequestBatchSize,
-        options.exportConcurrency ?? DEFAULT_EXPORT_CONCURRENCY,
-        options.onDelivered,
-        options.exportTimeoutMillis ?? EXPORT_TIMEOUT_MILLIS
-      )
-    );
-    this.processor = new BatchSpanProcessor(this.deliveryTracker, {
-      maxQueueSize: options.maxQueueSize ?? MAX_QUEUE_SIZE,
-      maxExportBatchSize: options.maxExportBatchSize ?? DIRECT_MAX_EXPORT_BATCH_SIZE,
-      scheduledDelayMillis: SCHEDULE_DELAY_MILLIS,
-      exportTimeoutMillis: options.exportTimeoutMillis ?? EXPORT_TIMEOUT_MILLIS
-    });
-    this.provider = new BasicTracerProvider({
-      sampler: new AlwaysOnSampler(),
-      resource: resourceFromAttributes({
-        "service.name": "bitfab-typescript-sdk",
-        "service.version": __version__
-      }),
-      spanLimits: {
-        attributeCountLimit: 2,
-        attributeValueLengthLimit: Number.POSITIVE_INFINITY
-      },
-      spanProcessors: [this.processor]
-    });
-    this.tracer = this.provider.getTracer("bitfab", __version__);
-    liveTransports.add(this);
-  }
-  submit(operation, payload, meta = {}) {
-    if (this.closed) {
-      warnOnce(
-        "otel-submit-after-shutdown",
-        "OpenTelemetry transport is shut down; dropping spans"
-      );
-      return;
-    }
-    try {
-      const { body, dropped } = serializePayloadBody(
-        payload,
-        MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES
-      );
-      if (dropped.length > 0) {
-        warnOnce(
-          "otel-carrier-payload-stubbed",
-          `a span payload held non-serializable value(s) (${[
-            ...new Set(dropped)
-          ].join(", ")}); they were stubbed so the span still ships, but the trace may be incomplete or not replayable.`
-        );
-      }
-      const span = this.tracer.startSpan(meta.name ?? `bitfab.${operation}`, {
-        attributes: {
-          [OPERATION_ATTRIBUTE]: operation,
-          [PAYLOAD_ATTRIBUTE]: body
-        },
-        startTime: meta.startTime
-      });
-      if (meta.ref !== void 0) {
-        carrierRefs.set(span, meta.ref);
-      }
-      if (meta.errored === true) {
-        span.setStatus({ code: SpanStatusCode.ERROR });
-      }
-      endSpan(span, meta.endTime);
-    } catch (error) {
-      logError("failed to queue an OpenTelemetry span", error);
-    }
-  }
-  async flush(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
-    const pending = (this.pendingFlush ?? Promise.resolve(true)).then(
-      () => this.forceFlushOnce()
-    );
-    this.pendingFlush = pending.catch(() => false);
-    return withDeadline(pending, timeoutMs);
-  }
-  async forceFlushOnce() {
-    try {
-      await this.processor.forceFlush();
-    } catch (error) {
-      logError("failed to flush OpenTelemetry spans", error);
-      this.deliveryTracker.takeFailedExports();
-      return false;
-    }
-    return this.deliveryTracker.takeFailedExports() === 0;
-  }
-  async shutdown(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
-    const deadline = Date.now() + Math.max(timeoutMs, 0);
-    this.closed = true;
-    const flushed = await this.flush(Math.max(0, deadline - Date.now()));
-    liveTransports.delete(this);
-    const shutdownCompleted = await withDeadline(
-      this.provider.shutdown().then(() => true).catch((error) => {
-        logError("failed to shut down the OpenTelemetry transport", error);
-        return false;
-      }),
-      Math.max(0, deadline - Date.now())
-    );
-    return flushed && shutdownCompleted;
-  }
-};
-function endSpan(span, endTime) {
-  span.end(endTime);
-}
-function createOtelTransport(options) {
-  return new OtelBatchTransport({
-    ...options,
-    exportConcurrency: readBoundedIntEnv(
-      EXPORT_CONCURRENCY_ENV,
-      MAX_EXPORT_CONCURRENCY,
-      DEFAULT_EXPORT_CONCURRENCY,
-      "otel-export-concurrency-invalid"
-    ),
-    maxRequestBytes: readBoundedIntEnv(
-      MAX_REQUEST_BYTES_ENV,
-      MAX_EXPORT_REQUEST_BYTES,
-      MAX_EXPORT_REQUEST_BYTES,
-      "otel-max-request-bytes-invalid"
-    )
-  });
-}
-async function forEachLiveTransport(timeoutMs, run) {
-  const deadline = Date.now() + Math.max(timeoutMs, 0);
-  let succeeded = true;
-  for (const transport of [...liveTransports]) {
-    succeeded = await run(transport, Math.max(0, deadline - Date.now())) && succeeded;
-  }
-  return succeeded;
-}
-function flushOtelTransports(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
-  return forEachLiveTransport(
-    timeoutMs,
-    (transport, remaining) => transport.flush(remaining)
-  );
-}
-function shutdownOtelTransports(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
-  return forEachLiveTransport(
-    timeoutMs,
-    (transport, remaining) => transport.shutdown(remaining)
-  );
-}
-
-// src/transport.ts
-function createTraceTransport(options) {
-  return createOtelTransport(options);
-}
-function flushTraceTransports(timeoutMs) {
-  return flushOtelTransports(timeoutMs);
-}
-function shutdownTraceTransports(timeoutMs) {
-  return shutdownOtelTransports(timeoutMs);
-}
-
-// src/http.ts
-var REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS = 3e5;
-var REPLAY_COMPLETE_REQUEST_TIMEOUT_MS = 12e4;
-var REPLAY_INTERRUPT_REQUEST_TIMEOUT_MS = 5e3;
-var REPLAY_HEARTBEAT_REQUEST_TIMEOUT_MS = 5e3;
-var OTLP_TRACES_ENDPOINT = "/api/sdk/otel/v1/traces";
-var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
-var EXIT_FLUSH_TIMEOUT_MS = 5e3;
-var DEFAULT_LIFECYCLE_TIMEOUT_MS2 = 3e4;
-var pendingTracePromises = /* @__PURE__ */ new Set();
-var liveHttpClients = /* @__PURE__ */ new Set();
-async function releaseHeldExternalSpans(timeoutMs) {
-  const deadline = Date.now() + Math.max(timeoutMs, 0);
-  let released = true;
-  for (const client of [...liveHttpClients]) {
-    const result = await client.releaseHeldExternalSpans?.(
-      Math.max(0, deadline - Date.now())
-    );
-    released = result !== false && released;
-  }
-  return released;
-}
-function stopSimulationPlans() {
-  for (const client of [...liveHttpClients]) {
-    client.stopSimulationPlan?.();
-  }
-}
-function awaitOnExit(promise) {
-  pendingTracePromises.add(promise);
-  void promise.finally(() => {
-    pendingTracePromises.delete(promise);
-  }).catch(() => {
-  });
-  return promise;
-}
-async function flushTraces(timeoutMs = 5e3) {
-  const deadline = Date.now() + Math.max(timeoutMs, 0);
-  const released = await releaseHeldExternalSpans(planWaitSliceMs(timeoutMs));
-  const requestsFlushed = await awaitPendingRequests(
-    Math.max(0, deadline - Date.now())
-  );
-  const releasedAfterDeferred = await releaseHeldExternalSpans(0);
-  const transportsFlushed = await flushTraceTransports(
-    Math.max(0, deadline - Date.now())
-  );
-  return released && releasedAfterDeferred && requestsFlushed && transportsFlushed;
-}
-async function awaitPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
-  await replayContextReady.catch(() => {
-  });
-  return waitForPromises(Array.from(pendingTracePromises), timeoutMs);
-}
-async function waitForPromises(promises, timeoutMs) {
-  if (promises.length === 0) {
-    return true;
-  }
-  let timer;
-  try {
-    return await Promise.race([
-      Promise.allSettled(promises).then(() => true),
-      new Promise((resolve) => {
-        timer = setTimeout(() => resolve(false), timeoutMs);
-        unrefTimer(timer);
-      })
-    ]);
-  } finally {
-    if (timer) {
-      clearTimeout(timer);
-    }
-  }
-}
-if (typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
-  let isFlushing = false;
-  process.on("beforeExit", () => {
-    if (isFlushing) {
-      return;
-    }
-    isFlushing = true;
-    const planWaitMs = SIMULATION_PLAN_READ_TIMEOUT_MS;
-    const stopFlushing = () => {
-      isFlushing = false;
-    };
-    const deadline = setTimeout(
-      stopFlushing,
-      EXIT_FLUSH_TIMEOUT_MS + planWaitMs
-    );
-    unrefTimer(deadline);
-    void releaseHeldExternalSpans(planWaitMs).catch(() => {
-    }).then(() => {
-      stopSimulationPlans();
-    }).then(
-      () => Promise.allSettled([
-        ...Array.from(pendingTracePromises).map((p) => p.catch(() => {
-        })),
-        shutdownTraceTransports(EXIT_FLUSH_TIMEOUT_MS).catch(() => false)
-      ])
-    ).then(() => {
-      clearTimeout(deadline);
-      stopFlushing();
-    });
-  });
-}
-var SPAN_TYPES = [
-  "llm",
-  "agent",
-  "function",
-  "guardrail",
-  "handoff",
-  "custom"
-];
-function readHeader(response, name) {
-  try {
-    return response.headers?.get(name) ?? null;
-  } catch {
-    return null;
-  }
-}
-function parseRetryAfterMs(header) {
-  const value = header?.trim();
-  if (!value) {
-    return void 0;
-  }
-  const seconds = Number(value);
-  if (Number.isFinite(seconds)) {
-    return seconds >= 0 ? seconds * 1e3 : void 0;
-  }
-  const at = Date.parse(value);
-  if (Number.isNaN(at)) {
-    return void 0;
-  }
-  return Math.max(0, at - Date.now());
-}
-function carrierMeta(operation, payload, ref) {
-  return {
-    ref,
-    name: carrierName(operation, payload),
-    startTime: payloadTimestamp(payload, "started_at"),
-    endTime: payloadTimestamp(payload, "ended_at"),
-    errored: payloadHasError(payload)
-  };
-}
-function carrierName(operation, payload) {
-  if (operation === "external_span") {
-    const spanData = asPayloadRecord(
-      asPayloadRecord(payload.rawSpan)?.span_data
-    );
-    if (typeof spanData?.name === "string") {
-      return spanData.name;
-    }
-  }
-  if (typeof payload.traceFunctionKey === "string") {
-    return payload.traceFunctionKey;
-  }
-  return `bitfab.${operation}`;
-}
-function payloadTimestamp(payload, field) {
-  const rawSpan = asPayloadRecord(payload.rawSpan);
-  const rawTrace = asPayloadRecord(payload.externalTrace) ?? asPayloadRecord(payload.rawTrace);
-  const raw = rawSpan?.[field] ?? rawTrace?.[field];
-  if (typeof raw !== "string") {
-    return void 0;
-  }
-  const parsed = Date.parse(raw);
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-function payloadHasError(payload) {
-  const spanData = asPayloadRecord(asPayloadRecord(payload.rawSpan)?.span_data);
-  if (spanData?.error != null) {
-    return true;
-  }
-  const errors = payload.errors;
-  return Array.isArray(errors) ? errors.length > 0 : Boolean(errors);
-}
-function asPayloadRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function carrierRef(payload) {
-  const traceId = sourceTraceIdOf(payload);
-  if (traceId === void 0) {
-    return void 0;
-  }
-  const rawSpan = payload.rawSpan;
-  if (rawSpan === void 0) {
-    return { traceId };
-  }
-  const spanId = rawSpan?.id;
-  return {
-    traceId,
-    spanId: typeof spanId === "string" ? spanId : `submission-${++carrierSeq}`
-  };
-}
-function sourceTraceIdOf(payload) {
-  if (typeof payload.sourceTraceId === "string") {
-    return payload.sourceTraceId;
-  }
-  const rawTrace = payload.externalTrace ?? payload.rawTrace;
-  const id = rawTrace?.id;
-  return typeof id === "string" ? id : void 0;
-}
-var carrierSeq = 0;
-function describeError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function warnDroppedExternalSpan(error) {
-  warnOnce(
-    "external-span-dropped",
-    `a span was dropped because the send step failed: ${describeError(error)}`
-  );
-}
-function warnDroppedExternalTrace(error) {
-  warnOnce(
-    "external-trace-dropped",
-    `a trace was dropped because the send step failed: ${describeError(error)}`
-  );
-}
-var HttpClient = class {
-  constructor(config) {
-    // Only traces a caller asked about are tracked, so ordinary tracing stores
-    // nothing here.
-    this.traceDeliveries = /* @__PURE__ */ new Map();
-    // Deferred span work owned by THIS client. The module-global set backs the
-    // process-wide `flushTraces()` and the exit hook, but per-client lifecycle
-    // must not wait on another client's slow finalize: a false `close()` failure
-    // caused by unrelated work is worse than no signal at all.
-    this.deferredWork = /* @__PURE__ */ new Set();
-    this.traceCompletion = new TraceCompletion();
-    this.closed = false;
-    this.apiKey = config.apiKey;
-    this.serviceUrl = config.serviceUrl;
-    this.timeout = config.timeout ?? 12e4;
-    liveHttpClients.add(this);
-  }
-  /**
-   * Resolve the API key at the moment it is needed (request time), invoking
-   * the function form if one was supplied. Never read at construction.
-   */
-  resolveApiKey() {
-    return typeof this.apiKey === "function" ? this.apiKey() : this.apiKey;
-  }
-  /** @internal Whether this client currently has credentials for trace delivery. */
-  hasApiKey() {
-    try {
-      const apiKey = this.resolveApiKey();
-      return apiKey !== void 0 && apiKey.trim() !== "";
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * This client's span transport, built on first use.
-   *
-   * Lazy on purpose: a client that never sends a span must never start a batch
-   * worker. Every framework integration created from a `Bitfab` client shares
-   * the owning client's `HttpClient`, so handlers reuse this one worker instead
-   * of each spinning up their own.
-   */
-  getTraceTransport() {
-    if (this.closed) {
-      warnOnce(
-        "http-client-closed",
-        "the Bitfab client is closed; dropping spans"
-      );
-      return void 0;
-    }
-    if (!this.traceTransport) {
-      this.traceTransport = createTraceTransport({
-        directSender: (request, timeoutMs) => this.deliverCarriers(request, timeoutMs),
-        onDelivered: (refs) => this.recordDeliveredCarriers(refs)
-      });
-    }
-    return this.traceTransport;
-  }
-  /**
-   * Post one encoded batch and decide what the server's answer means, so the
-   * transport never reads a response. Rejections and permanent statuses come
-   * back as a non-retryable {@link DeliveryError}; anything the server might
-   * still accept on a second try comes back retryable.
-   */
-  async deliverCarriers(request, timeoutMs) {
-    let response;
-    try {
-      response = await this.sendPrepared(
-        OTLP_TRACES_ENDPOINT,
-        request,
-        { timeout: timeoutMs }
-      );
-    } catch (error) {
-      const status = error instanceof BitfabError ? error.status : void 0;
-      if (status === void 0) {
-        throw new DeliveryError(`OTLP ingestion failed: ${String(error)}`, {
-          retryable: true
-        });
-      }
-      throw new DeliveryError(`OTLP ingestion failed with HTTP ${status}`, {
-        retryable: RETRYABLE_STATUSES.has(status),
-        oversized: status === 413,
-        ...error instanceof BitfabError && error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {}
-      });
-    }
-    const serverTraceIds = asPayloadRecord(response?.traceIds);
-    if (serverTraceIds !== void 0) {
-      this.recordServerTraceIds(serverTraceIds);
-    }
-    const partialSuccess = asPayloadRecord(response?.partialSuccess);
-    const rejected = partialSuccess?.rejectedSpans;
-    if (rejected !== void 0 && rejected !== "0" && rejected !== 0) {
-      throw new DeliveryError(
-        `OTLP ingestion rejected ${rejected} span(s): ${partialSuccess?.errorMessage ?? "no reason provided"}`
-      );
-    }
-  }
-  /**
-   * Start tracking delivery for `traceIds`. Nothing is recorded for a trace
-   * that was never tracked, so ordinary tracing costs no bookkeeping at all.
-   */
-  trackTraceDeliveries(traceIds) {
-    for (const traceId of traceIds) {
-      if (!this.traceDeliveries.has(traceId)) {
-        this.traceDeliveries.set(traceId, {
-          submittedSpanIds: /* @__PURE__ */ new Set(),
-          ackedSpanIds: /* @__PURE__ */ new Set(),
-          closed: false,
-          closingAcked: false
-        });
-      }
-    }
-  }
-  /**
-   * The server's assigned `traces.id` for a tracked trace if it has already
-   * been read back off an ingest response, without stopping tracking. Lets a
-   * replay surface the id mid-run for items whose spans already landed.
-   */
-  peekServerTraceId(traceId) {
-    return this.traceDeliveries.get(traceId)?.serverTraceId;
-  }
-  /** Whether any tracked trace has had its closing carrier submitted. */
-  hasClosedDeliveries(traceIds) {
-    return traceIds.some((traceId) => this.traceDeliveries.get(traceId)?.closed);
-  }
-  /**
-   * Report what each tracked trace submitted and whether the server confirmed
-   * it, and stop tracking them. Every id passed is freed, so a caller cannot
-   * leak a record for a trace that never closed.
-   *
-   * `delivered` is only meaningful once a flush has settled: acks land before
-   * an export resolves, so a flush that reported success has already collected
-   * every ack it is going to collect.
-   */
-  takeTraceDeliveries(traceIds) {
-    const reports = {};
-    for (const traceId of traceIds) {
-      const delivery = this.traceDeliveries.get(traceId);
-      if (delivery === void 0) {
-        continue;
-      }
-      this.traceDeliveries.delete(traceId);
-      reports[traceId] = {
-        spanCount: delivery.submittedSpanIds.size,
-        closed: delivery.closed,
-        delivered: delivery.closingAcked && [...delivery.submittedSpanIds].every(
-          (spanId) => delivery.ackedSpanIds.has(spanId)
-        ),
-        serverTraceId: delivery.serverTraceId
-      };
-    }
-    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);
-  }
-  recordSubmittedCarrier(ref) {
-    if (ref === void 0) {
-      return;
-    }
-    const delivery = this.traceDeliveries.get(ref.traceId);
-    if (delivery === void 0) {
-      return;
-    }
-    if (ref.spanId === void 0) {
-      delivery.closed = true;
-    } else {
-      delivery.submittedSpanIds.add(ref.spanId);
-    }
-  }
-  /**
-   * Ingestion commits every carrier in a request before it answers, so a
-   * delivered ref is proof its row exists: the same fact the replay status
-   * endpoint would report, already in hand.
-   */
-  /**
-   * Record the server's assigned `traces.id` for each tracked source trace,
-   * read back from the OTLP ingest response. Keyed by source trace id, the same
-   * key the delivery ledger uses. Untracked ids are ignored.
-   */
-  recordServerTraceIds(map) {
-    for (const [sourceTraceId, serverTraceId] of Object.entries(map)) {
-      if (typeof serverTraceId !== "string") {
-        continue;
-      }
-      const delivery = this.traceDeliveries.get(sourceTraceId);
-      if (delivery === void 0) {
-        continue;
-      }
-      delivery.serverTraceId = serverTraceId;
-    }
-  }
-  recordDeliveredCarriers(refs) {
-    for (const ref of refs) {
-      const delivery = this.traceDeliveries.get(ref.traceId);
-      if (delivery === void 0) {
-        continue;
-      }
-      if (ref.spanId === void 0) {
-        delivery.closingAcked = true;
-      } else {
-        delivery.ackedSpanIds.add(ref.spanId);
-      }
-    }
-  }
-  /**
-   * Track deferred span work so this client's own lifecycle waits for it, and
-   * so the process-wide flush and exit hook do too.
-   */
-  trackDeferred(promise) {
-    this.deferredWork.add(promise);
-    void promise.finally(() => this.deferredWork.delete(promise)).catch(() => {
-    });
-    return awaitOnExit(promise);
-  }
-  /**
-   * Settle only THIS client's deferred span work. Scoped deliberately: the
-   * global set can contain another client's long-running finalize, and
-   * attributing its timeout here would fail a client whose own work succeeded.
-   */
-  async settleDeferredWork(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
-    const deadline = Date.now() + Math.max(timeoutMs, 0);
-    const released = await this.releaseHeldExternalSpans?.(
-      planWaitSliceMs(timeoutMs)
-    );
-    await replayContextReady.catch(() => {
-    });
-    const settled = await waitForPromises(
-      Array.from(this.deferredWork),
-      Math.max(0, deadline - Date.now())
-    );
-    const releasedAfterDeferred = await this.releaseHeldExternalSpans?.(0);
-    return released !== false && releasedAfterDeferred !== false && settled;
-  }
-  /**
-   * Wait for spans queued by this client to be delivered, within one deadline.
-   * Returns false on delivery failure or timeout.
-   */
-  async waitForPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
-    const deadline = Date.now() + Math.max(timeoutMs, 0);
-    const settled = await this.settleDeferredWork(
-      Math.max(0, deadline - Date.now())
-    );
-    const flushed = await this.traceTransport?.flush(Math.max(0, deadline - Date.now())) ?? true;
-    return settled && flushed;
-  }
-  /**
-   * Flush and permanently close this client's tracing transport. Idempotent:
-   * a second call joins the first rather than tearing down a pipeline the
-   * first call already owns.
-   */
-  close(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
-    if (this.closing) {
-      return this.closing;
-    }
-    const deadline = Date.now() + Math.max(timeoutMs, 0);
-    this.closing = (async () => {
-      liveHttpClients.delete(this);
-      const settled = await this.settleDeferredWork(
-        Math.max(0, deadline - Date.now())
-      );
-      this.stopSimulationPlan?.();
-      this.closed = true;
-      this.externalSpanTransform = void 0;
-      this.externalTraceTransform = void 0;
-      this.releaseHeldExternalSpans = void 0;
-      this.stopSimulationPlan = void 0;
-      const transport = this.traceTransport;
-      this.traceTransport = void 0;
-      const shutdownOk = await transport?.shutdown(Math.max(0, deadline - Date.now())) ?? true;
-      return settled && shutdownOk;
-    })();
-    return this.closing;
-  }
-  /**
-   * Make an HTTP request to the Bitfab API. Defaults to POST; pass
-   * `options.method` to use a different verb (e.g. "PATCH").
-   *
-   * @param endpoint - The API endpoint (without base URL)
-   * @param payload - The request body
-   * @param options - Optional request options
-   * @returns The parsed JSON response
-   * @throws {BitfabError} If the request fails
-   */
-  async request(endpoint, payload, options) {
-    const { body, dropped } = serializePayloadBody(payload);
-    if (dropped.length > 0) {
-      try {
-        console.warn(
-          `Bitfab: request body to ${endpoint} held ${dropped.length} non-serializable value(s) (${[...new Set(dropped)].join(", ")}); they were stubbed so the span still sends, but the trace may be incomplete or not replayable. Capture a JSON-safe projection of this input to make it replayable.`
-        );
-      } catch {
-      }
-    }
-    return this.sendEncoded(endpoint, body, options);
-  }
-  /**
-   * POST an already-encoded body. The span transport encodes its own batches,
-   * so routing them back through {@link HttpClient.request} would encode the
-   * same data twice.
-   */
-  async sendEncoded(endpoint, body, options) {
-    const prepared = encodeRequestBody(body);
-    const encoded = prepared instanceof Promise ? await prepared : prepared;
-    return this.sendPrepared(endpoint, encoded, options);
-  }
-  async sendPrepared(endpoint, encoded, options) {
-    const url = `${this.serviceUrl}${endpoint}`;
-    const timeout = options?.timeout ?? this.timeout;
-    const method = options?.method ?? "POST";
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.resolveApiKey() ?? ""}`
-    };
-    if (encoded.contentEncoding) {
-      headers["Content-Encoding"] = encoded.contentEncoding;
-    }
-    try {
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: encoded.body,
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new BitfabError(
-          `HTTP ${response.status}: ${errorText.slice(0, 500)}`,
-          void 0,
-          response.status,
-          parseRetryAfterMs(readHeader(response, "retry-after"))
-        );
-      }
-      const result = await response.json();
-      if (result.error) {
-        if (result.url) {
-          throw new BitfabError(
-            `${result.error} Configure it at: ${this.serviceUrl}${result.url}`,
-            result.url
-          );
-        }
-        throw new BitfabError(result.error);
-      }
-      return result;
-    } catch (error) {
-      if (error instanceof BitfabError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new BitfabError(`Request timed out after ${timeout}ms`);
-        }
-        throw new BitfabError(error.message);
-      }
-      throw new BitfabError("Unknown error occurred");
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Look up a function by name.
-   * Blocks until complete - needed for function execution.
-   */
-  async lookupFunction(name) {
-    return this.request("/api/sdk/functions/lookup", { name });
-  }
-  async getSimulationPlan() {
-    if (!this.hasApiKey()) {
-      throw new BitfabError(NO_API_KEY_FOR_SIMULATION_PLAN);
-    }
-    return this.get(
-      "/api/sdk/sim-plan",
-      SIMULATION_PLAN_READ_TIMEOUT_MS
-    );
-  }
-  async getTraceSpan(traceId, lookup) {
-    const searchParams = new URLSearchParams();
-    if (lookup.id !== void 0) {
-      searchParams.set("id", lookup.id);
-    } else {
-      if (lookup.name !== void 0) {
-        searchParams.set("name", lookup.name);
-      }
-      if (lookup.type !== void 0) {
-        searchParams.set("type", lookup.type);
-      }
-      searchParams.set("occurrence", String(lookup.occurrence ?? "last"));
-    }
-    const endpoint = `/api/sdk/traces/${encodeURIComponent(traceId)}/span?${searchParams.toString()}`;
-    const response = await this.get(endpoint);
-    return response.span;
-  }
-  async getSpan(spanId) {
-    const response = await this.get(
-      `/api/sdk/spans/${encodeURIComponent(spanId)}`
-    );
-    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, timeoutMs, extraHeaders) {
-    const url = `${this.serviceUrl}${endpoint}`;
-    const timeout = timeoutMs ?? this.timeout;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${this.resolveApiKey() ?? ""}`,
-          ...extraHeaders
-        },
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new BitfabError(
-          `HTTP ${response.status}: ${errorText.slice(0, 500)}`,
-          void 0,
-          response.status,
-          parseRetryAfterMs(readHeader(response, "retry-after"))
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof BitfabError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new BitfabError(`Request timed out after ${timeout}ms`);
-        }
-        throw new BitfabError(error.message);
-      }
-      throw new BitfabError("Unknown error occurred");
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Queue an internal trace (from local BAML execution via `call()`) onto this
-   * client's batching transport. `functionId` moves into the payload because
-   * the OTLP carrier has no path to carry it.
-   */
-  sendInternalTrace(functionId, payload) {
-    const body = {
-      ...payload,
-      functionId,
-      sdkPackage: __packageName__,
-      sdkVersion: __version__
-    };
-    this.getTraceTransport()?.submit(
-      "internal_trace",
-      body,
-      carrierMeta("internal_trace", body, void 0)
-    );
-  }
-  sendExternalSpan(payload) {
-    const ref = carrierRef(payload);
-    if (ref?.spanId !== void 0) {
-      this.traceCompletion.record(ref.traceId, ref.spanId);
-    }
-    const drop = () => {
-      if (ref?.spanId !== void 0) {
-        this.traceCompletion.abort(ref.traceId, ref.spanId);
-      }
-    };
-    const gate = this.externalSpanTransform;
-    if (gate === void 0) {
-      this.submitExternalSpan(payload);
-      return;
-    }
-    try {
-      gate(payload, (ready) => this.submitExternalSpan(ready), drop);
-    } catch (error) {
-      drop();
-      warnDroppedExternalSpan(error);
-    }
-  }
-  submitExternalSpan(payload) {
-    const body = {
-      ...payload,
-      sdkVersion: __version__
-    };
-    delete body[ROOT_TRACE_FUNCTION_KEY_FIELD];
-    delete body[DECLARED_NODE_FIELD];
-    this.getTraceTransport()?.submit(
-      "external_span",
-      body,
-      this.recordedMeta("external_span", payload, carrierRef(payload))
-    );
-  }
-  /**
-   * Queue an external trace completion (from OpenAI tracing) onto this
-   * client's batching transport. Fire-and-forget for the same reason as
-   * {@link HttpClient.sendExternalSpan}; replay confirms persistence with the
-   * server-authoritative barrier in `replay.ts`, not by awaiting this call.
-   */
-  sendExternalTrace(rawPayload) {
-    const payload = mergeCallerMetadataIntoTracePayload(rawPayload);
-    const traceId = sourceTraceIdOf(payload);
-    if (payload.completed === true && traceId !== void 0) {
-      this.traceCompletion.close(
-        traceId,
-        (expectedSpanCount) => this.sendCountedExternalTrace({ ...payload, expectedSpanCount }),
-        payload.dropped === true
-      );
-      return;
-    }
-    if (traceId !== void 0) {
-      this.traceCompletion.open(traceId);
-    }
-    this.sendCountedExternalTrace(payload);
-  }
-  sendCountedExternalTrace(payload) {
-    try {
-      const gate = this.externalTraceTransform;
-      if (gate === void 0) {
-        this.submitExternalTrace(payload);
-      } else {
-        gate(payload, (ready) => this.submitExternalTrace(ready));
-      }
-    } catch (error) {
-      warnDroppedExternalTrace(error);
-    }
-  }
-  submitExternalTrace(payload) {
-    this.getTraceTransport()?.submit(
-      "external_trace",
-      {
-        ...payload,
-        sdkPackage: __packageName__,
-        sdkVersion: __version__
-      },
-      this.recordedMeta(
-        "external_trace",
-        payload,
-        payload.completed === true ? carrierRef(payload) : void 0
-      )
-    );
-  }
-  /**
-   * Partial update of an existing trace identified by its Bitfab trace ID.
-   * Used by the detached `client.getTrace(id)` handle.
-   *
-   * Blocking, like the other trace-API calls: it resolves once the server has
-   * applied the change and rejects if the server refused it. A patch targets a
-   * trace that is already closed, so there is no batch for it to ride along
-   * with and no later signal that would reveal a silent failure.
-   */
-  async patchTrace(traceId, payload) {
-    const endpoint = `/api/sdk/traces/${encodeURIComponent(traceId)}`;
-    await this.request(endpoint, payload, { method: "PATCH" });
-  }
-  /**
-   * 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, skipAssertionJudging, experimentalSelectiveReplay, notes, metadata, dryRun, experimentGroupName, invocation) {
-    const payload = { traceFunctionKey };
-    if (experimentalSelectiveReplay !== void 0) {
-      payload.experimentalSelectiveReplay = experimentalSelectiveReplay;
-    }
-    if (limit !== void 0) {
-      payload.limit = limit;
-    }
-    if (traceIds) {
-      payload.traceIds = traceIds;
-    }
-    if (name !== void 0) {
-      payload.name = name;
-    }
-    if (notes !== void 0) {
-      payload.notes = notes;
-    }
-    if (metadata !== void 0) {
-      payload.metadata = metadata;
-    }
-    if (codeChangeDescription !== void 0) {
-      payload.codeChangeDescription = codeChangeDescription;
-    }
-    if (codeChangeFiles !== void 0) {
-      payload.codeChangeFiles = codeChangeFiles;
-    }
-    if (includeDbBranchLease) {
-      payload.includeDbBranchLease = true;
-      payload.lazyDbBranchLease = true;
-    }
-    if (experimentGroupId !== void 0) {
-      payload.experimentGroupId = experimentGroupId;
-    }
-    if (experimentGroupName !== void 0) {
-      payload.experimentGroupName = experimentGroupName;
-    }
-    if (datasetIds !== void 0) {
-      if (datasetIds.length === 1) {
-        payload.datasetId = datasetIds[0];
-      } else {
-        payload.datasetIds = datasetIds;
-      }
-    }
-    if (graderIds !== void 0) {
-      payload.graderIds = graderIds;
-    }
-    if (dbBranchSettings !== void 0) {
-      payload.dbBranchSettings = dbBranchSettings;
-    }
-    if (attempts !== void 0 && attempts > 1) {
-      payload.attempts = attempts;
-    }
-    if (includeOriginalMetadata) {
-      payload.includeOriginalMetadata = true;
-    }
-    if (onlyWithAssertions) {
-      payload.onlyWithAssertions = true;
-    }
-    if (skipAssertionJudging !== true) {
-      payload.judgeAssertions = true;
-    }
-    if (dryRun) {
-      payload.dryRun = true;
-    }
-    if (invocation !== void 0) {
-      payload.invocation = invocation;
-    }
-    const git = await resolvedGitState();
-    if (git && !isEmptyGitState(git)) {
-      payload.git = git;
-    }
-    const timeout = includeDbBranchLease ? REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS : 3e4;
-    const response = await this.request(
-      "/api/sdk/replay/start",
-      payload,
-      { timeout }
-    );
-    const { testRunId, testRunUrl, ...rest } = response;
-    const experimentId = response.experimentId ?? testRunId;
-    const experimentUrl = response.experimentUrl ?? testRunUrl;
-    if (dryRun && response.experimentId === null) {
-      return { ...rest, experimentId: null, experimentUrl: null };
-    }
-    if (experimentId === void 0 || experimentId === null || experimentUrl === void 0 || experimentUrl === null) {
-      throw new BitfabError(
-        "Replay start response is missing the experiment ID or URL."
-      );
-    }
-    return { ...rest, experimentId, experimentUrl };
-  }
-  async resumeReplay(experimentId, traceFunctionKey, codeChangeFiles, force) {
-    const payload = {
-      experimentId,
-      traceFunctionKey,
-      lazyDbBranchLease: true
-    };
-    if (force === true) {
-      payload.force = true;
-    }
-    if (codeChangeFiles !== void 0) {
-      payload.codeChangeFiles = codeChangeFiles;
-    }
-    const git = await resolvedGitState();
-    if (git && !isEmptyGitState(git)) {
-      payload.git = git;
-    }
-    const response = await this.request(
-      "/api/sdk/replay/resume",
-      payload,
-      { timeout: REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS }
-    );
-    const { testRunId, testRunUrl, ...rest } = response;
-    const resumedExperimentId = response.experimentId ?? testRunId;
-    const experimentUrl = response.experimentUrl ?? testRunUrl;
-    if (resumedExperimentId === void 0 || experimentUrl === void 0) {
-      throw new BitfabError(
-        "Replay resume response is missing the experiment ID or URL."
-      );
-    }
-    return {
-      ...rest,
-      experimentId: resumedExperimentId,
-      experimentUrl,
-      work: rest.work ?? [],
-      finished: rest.finished ?? [],
-      skippedOriginalTraceIds: rest.skippedOriginalTraceIds ?? [],
-      includeDbBranchLease: rest.includeDbBranchLease ?? false,
-      dbBranchSettings: rest.dbBranchSettings ?? null
-    };
-  }
-  /**
-   * Fetch an external span by ID.
-   * Blocking GET request.
-   * The replay view limits rawData to input/output serialization fields.
-   */
-  async getExternalSpan(spanId, options) {
-    const query = options?.view === "replay" ? "?view=replay" : "";
-    const url = `${this.serviceUrl}/api/sdk/externalSpans/${spanId}${query}`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 3e4);
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: { Authorization: `Bearer ${this.resolveApiKey() ?? ""}` },
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new BitfabError(
-          `HTTP ${response.status}: ${errorText.slice(0, 500)}`
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof BitfabError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new BitfabError("Request timed out after 30000ms");
-        }
-        throw new BitfabError(error.message);
-      }
-      throw new BitfabError("Unknown error occurred");
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Fetch the span tree for a root span.
-   * Blocking GET request.
-   *
-   * Pass `includeOutputs: false` for a payload-free tree (structure +
-   * `externalSpanId` only), so recorded outputs are fetched lazily per mocked
-   * span instead of all up front. Omit it (default eager) for `mock: "all"`.
-   * Pass `includeRootOutput: false` when the root was already fetched.
-   */
-  async getSpanTree(externalSpanId, options) {
-    const searchParams = new URLSearchParams();
-    if (options?.includeOutputs === false) {
-      searchParams.set("includeOutputs", "false");
-    }
-    if (options?.includeRootOutput === false) {
-      searchParams.set("includeRootOutput", "false");
-    }
-    const encodedQuery = searchParams.toString();
-    const query = encodedQuery ? `?${encodedQuery}` : "";
-    const url = `${this.serviceUrl}/api/sdk/replay/spanTree/${externalSpanId}${query}`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 3e4);
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: { Authorization: `Bearer ${this.resolveApiKey() ?? ""}` },
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new BitfabError(
-          `HTTP ${response.status}: ${errorText.slice(0, 500)}`
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof BitfabError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new BitfabError("Request timed out after 30000ms");
-        }
-        throw new BitfabError(error.message);
-      }
-      throw new BitfabError("Unknown error occurred");
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Read which of a replay run's traces the server has fully persisted.
-   *
-   * With `expectedSpanCounts`, a trace appears in the response only once it
-   * has a final status AND at least that many persisted spans, which is what
-   * makes this a real barrier rather than a "the row exists" check.
-   */
-  async getReplayStatus(experimentId, expectedSpanCounts) {
-    return this.request(
-      "/api/sdk/replay/status",
-      { ...experimentIdWireFields(experimentId), expectedSpanCounts },
-      { timeout: 3e4 }
-    );
-  }
-  /**
-   * Mark a replay experiment as completed.
-   * Blocking call.
-   */
-  async completeReplay(experimentId) {
-    return this.request(
-      "/api/sdk/replay/complete",
-      experimentIdWireFields(experimentId),
-      { 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`
-    );
-  }
-  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
-   * snapshot + preview branch and polls operations to readiness, which
-   * can take seconds.
-   */
-  async resolveDbBranchLease(experimentId, traceId, dbBranchSettings, attempt) {
-    return this.request(
-      "/api/sdk/replay/resolveDbBranchLease",
-      {
-        ...experimentIdWireFields(experimentId),
-        traceId,
-        dbBranchSettings,
-        ...attempt !== void 0 && attempt > 0 ? { attempt } : {}
-      },
-      { timeout: REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS }
-    );
-  }
-  /** Release a previously-resolved DB branch by deleting its Neon branch. Idempotent server-side. */
-  async releaseDbBranchLease(neonBranchId) {
-    await this.request(
-      "/api/sdk/replay/releaseDbBranchLease",
-      { neonBranchId },
-      { timeout: 3e4 }
-    );
-  }
-};
-function experimentIdWireFields(experimentId) {
-  return { experimentId, testRunId: experimentId };
-}
-
-export {
-  BitfabError,
-  gitRunner,
-  readEnv,
-  __version__,
-  asyncStorageReady,
-  createAsyncLocalStorage,
-  replayContextReady,
-  runWithReplayContext,
-  warnOnce,
-  writeOnce,
-  serializePayloadBody,
-  unrefTimer,
-  awaitOnExit,
-  flushTraces,
-  awaitPendingRequests,
-  SPAN_TYPES,
-  parseRetryAfterMs,
-  HttpClient,
-  experimentIdWireFields
-};
-//# sourceMappingURL=chunk-27B3UBSS.js.map