@bitfab/sdk 0.38.10 → 0.40.0

package/dist/chunk-E2V4HFSM.js

@@ -0,0 +1,1863 @@
+// 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.40.0";
+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/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;
+  }
+});
+
+// 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 warnOnce(key, message) {
+  if (warned.has(key)) {
+    return;
+  }
+  warned.add(key);
+  try {
+    console.warn(`[bitfab] ${message}`);
+  } catch {
+  }
+}
+
+// src/serializePayload.ts
+function serializePayloadBody(payload, maxCarrierBytes = MAX_SPAN_CARRIER_BYTES) {
+  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/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 = 8192;
+var DIRECT_MAX_EXPORT_BATCH_SIZE = 512;
+var DIRECT_MAX_REQUEST_BATCH_SIZE = 128;
+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 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();
+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 requestsFlushed = await awaitPendingRequests(timeoutMs);
+  const transportsFlushed = await flushTraceTransports(
+    Math.max(0, deadline - Date.now())
+  );
+  return 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;
+    void Promise.allSettled([
+      ...Array.from(pendingTracePromises).map((p) => p.catch(() => {
+      })),
+      shutdownTraceTransports(EXIT_FLUSH_TIMEOUT_MS).catch(() => false)
+    ]).then(() => {
+      isFlushing = false;
+    });
+  });
+}
+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;
+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.closed = false;
+    this.apiKey = config.apiKey;
+    this.serviceUrl = config.serviceUrl;
+    this.timeout = config.timeout ?? 12e4;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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) {
+    await replayContextReady.catch(() => {
+    });
+    return waitForPromises(Array.from(this.deferredWork), timeoutMs);
+  }
+  /**
+   * 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(timeoutMs);
+    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 () => {
+      const settled = await this.settleDeferredWork(
+        Math.max(0, deadline - Date.now())
+      );
+      this.closed = true;
+      const transport = this.traceTransport;
+      this.traceTransport = void 0;
+      const shutdownOk = await transport?.shutdown(Math.max(0, deadline - Date.now())) ?? true;
+      return settled && shutdownOk;
+    })();
+    return 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 getAutoTracePolicy(traceFunctionKey, protocol) {
+    return this.request("/api/sdk/auto-trace/policy", {
+      traceFunctionKey,
+      protocol
+    });
+  }
+  async getTraceSpan(traceId, lookup) {
+    const searchParams = new URLSearchParams();
+    if (lookup.id !== void 0) {
+      searchParams.set("id", lookup.id);
+    } else {
+      searchParams.set("name", lookup.name);
+      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;
+  }
+  /**
+   * GET a JSON endpoint on the service with the client's API key. Throws a
+   * `BitfabError` carrying the status text for any non-2xx response.
+   */
+  async get(endpoint) {
+    const url = `${this.serviceUrl}${endpoint}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    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)}`,
+          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 ${this.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)
+    );
+  }
+  /**
+   * Queue an external span (from withSpan wrapper or OpenAI tracing) onto this
+   * client's batching transport. Fire-and-forget: the transport owns delivery,
+   * so callers await `flushTraces()` or `close()` rather than a per-span
+   * promise.
+   */
+  sendExternalSpan(payload) {
+    this.getTraceTransport()?.submit(
+      "external_span",
+      { ...payload, sdkVersion: __version__ },
+      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(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 a test run and returns lightweight item references.
+   */
+  async startReplay(traceFunctionKey, limit, traceIds, name, codeChangeDescription, codeChangeFiles, includeDbBranchLease, experimentGroupId, datasetId, graderIds, dbBranchSettings) {
+    const payload = { traceFunctionKey };
+    if (limit !== void 0) {
+      payload.limit = limit;
+    }
+    if (traceIds) {
+      payload.traceIds = traceIds;
+    }
+    if (name !== void 0) {
+      payload.name = name;
+    }
+    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 (datasetId !== void 0) {
+      payload.datasetId = datasetId;
+    }
+    if (graderIds !== void 0) {
+      payload.graderIds = graderIds;
+    }
+    if (dbBranchSettings !== void 0) {
+      payload.dbBranchSettings = dbBranchSettings;
+    }
+    const timeout = includeDbBranchLease ? REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS : 3e4;
+    return this.request("/api/sdk/replay/start", payload, {
+      timeout
+    });
+  }
+  /**
+   * 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(testRunId, expectedSpanCounts) {
+    return this.request(
+      "/api/sdk/replay/status",
+      { testRunId, expectedSpanCounts },
+      { timeout: 3e4 }
+    );
+  }
+  /**
+   * Mark a replay test run as completed.
+   * Blocking call.
+   */
+  async completeReplay(testRunId) {
+    return this.request(
+      "/api/sdk/replay/complete",
+      { testRunId },
+      { 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(testRunId, traceId, dbBranchSettings) {
+    return this.request(
+      "/api/sdk/replay/resolveDbBranchLease",
+      { testRunId, traceId, dbBranchSettings },
+      { 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 }
+    );
+  }
+};
+
+export {
+  BitfabError,
+  serializePayloadBody,
+  awaitOnExit,
+  flushTraces,
+  awaitPendingRequests,
+  parseRetryAfterMs,
+  HttpClient
+};
+//# sourceMappingURL=chunk-E2V4HFSM.js.map