@bitfab/sdk 0.34.1 → 0.36.0

package/dist/{chunk-5ZMEY5NX.js → chunk-4YTIVUYX.js}

@@ -207,8 +207,78 @@ var BitfabError = class extends Error {
   }
 };
 
+// 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
+  );
+}
+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)) {
+    return { body };
+  }
+  const bytes = new TextEncoder().encode(body);
+  if (bytes.byteLength < MIN_COMPRESSED_BYTES) {
+    return { body };
+  }
+  if (gzipNode) {
+    return gzipNode(bytes).then(
+      (compressed) => ({
+        body: toArrayBuffer(compressed),
+        contentEncoding: "gzip"
+      }),
+      () => ({ body })
+    );
+  }
+  if (typeof CompressionStream === "undefined") {
+    return { body };
+  }
+  return gzipViaStream(bytes).then(
+    (compressed) => ({ body: compressed, contentEncoding: "gzip" }),
+    () => ({ body })
+  );
+}
+
 // src/version.generated.ts
-var __version__ = "0.34.1";
+var __version__ = "0.36.0";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -279,6 +349,125 @@ function runWithReplayContext(ctx, fn) {
   return fn();
 }
 
+// src/payloadBudget.ts
+var MAX_SPAN_CARRIER_BYTES = 28e5;
+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) {
+  const units = body.length;
+  if (units * MAX_BYTES_PER_UNIT + 2 <= MAX_SPAN_CARRIER_BYTES) {
+    return true;
+  }
+  if (units + 2 > MAX_SPAN_CARRIER_BYTES) {
+    return false;
+  }
+  return carrierByteLength(body) <= MAX_SPAN_CARRIER_BYTES;
+}
+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) {
+  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)) {
+      return { value: copy, trimmed };
+    }
+  }
+  return void 0;
+}
+function markPayloadTrimmed(value, trimmed) {
+  const existing = Array.isArray(value.errors) ? value.errors : [];
+  value.errors = [
+    ...existing,
+    {
+      source: "sdk",
+      step: "payload_budget",
+      error: `trimmed oversized field(s) to fit the ${MAX_SPAN_CARRIER_BYTES}-byte span carrier budget: ${[
+        ...new Set(trimmed)
+      ].join(", ")}`
+    }
+  ];
+}
+
 // src/warnOnce.ts
 var warned = /* @__PURE__ */ new Set();
 function warnOnce(key, message) {
@@ -294,8 +483,37 @@ function warnOnce(key, message) {
 
 // src/serializePayload.ts
 function serializePayloadBody(payload) {
+  const encoded = encodePayloadBody(payload);
+  if (fitsCarrierBudget(encoded.body)) {
+    return { body: encoded.body, dropped: encoded.dropped };
+  }
+  return applyPayloadBudget(encoded);
+}
+function applyPayloadBudget(encoded) {
+  const result = encoded.value ? trimPayloadToBudget(
+    encoded.value,
+    (value) => encodePayloadBody(value).body
+  ) : void 0;
+  if (!result) {
+    return { body: encoded.body, dropped: encoded.dropped };
+  }
+  warnOnce(
+    "payload:over-budget",
+    `a span payload exceeded the ${MAX_SPAN_CARRIER_BYTES}-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);
+  return {
+    body: encodePayloadBody(result.value).body,
+    dropped: encoded.dropped
+  };
+}
+function encodePayloadBody(payload) {
   try {
-    return { body: JSON.stringify(payload), dropped: [] };
+    return { body: JSON.stringify(payload), dropped: [], value: payload };
   } catch {
     const dropped = [];
     const sanitize = (value, seen) => {
@@ -360,12 +578,11 @@ function serializePayloadBody(payload) {
       sanitized = sanitize(payload, /* @__PURE__ */ new WeakSet());
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      return {
-        body: JSON.stringify({ error: `payload_serialize_failed: ${message}` }),
-        dropped
-      };
+      const marker = { error: `payload_serialize_failed: ${message}` };
+      return { body: JSON.stringify(marker), dropped, value: marker };
     }
-    if (dropped.length > 0 && typeof sanitized === "object" && sanitized !== null && !Array.isArray(sanitized)) {
+    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 = [
@@ -379,7 +596,11 @@ function serializePayloadBody(payload) {
         }
       ];
     }
-    return { body: JSON.stringify(sanitized), dropped };
+    return {
+      body: JSON.stringify(sanitized),
+      dropped,
+      value: isRecord ? sanitized : void 0
+    };
   }
 }
 
@@ -395,14 +616,6 @@ import {
   BatchSpanProcessor
 } from "@opentelemetry/sdk-trace-base";
 
-// src/readEnv.ts
-function readEnv(name) {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[name];
-  }
-  return void 0;
-}
-
 // src/unrefTimer.ts
 function unrefTimer(timer) {
   const handle = timer;
@@ -418,10 +631,8 @@ var OTLP_TRACES_ENDPOINT = "/api/sdk/otel/v1/traces";
 var MAX_EXPORT_REQUEST_BYTES = 3e6;
 var MAX_REQUEST_BYTES_ENV = "BITFAB_OTEL_MAX_REQUEST_BYTES";
 var EXPORT_CONCURRENCY_ENV = "BITFAB_OTEL_EXPORT_CONCURRENCY";
-var COLLECTOR_ENDPOINT_ENV = "BITFAB_OTEL_EXPORTER_ENDPOINT";
 var MAX_QUEUE_SIZE = 8192;
 var DIRECT_MAX_EXPORT_BATCH_SIZE = 512;
-var COLLECTOR_MAX_EXPORT_BATCH_SIZE = 32;
 var DIRECT_MAX_REQUEST_BATCH_SIZE = 8;
 var DEFAULT_EXPORT_CONCURRENCY = 32;
 var MAX_EXPORT_CONCURRENCY = 64;
@@ -466,7 +677,7 @@ function recordTraceSubmission(operation, payload) {
     return;
   }
   if (operation === "external_span") {
-    const rawSpan = asRecord(payload.rawSpan);
+    const rawSpan = asRecord2(payload.rawSpan);
     if (typeof rawSpan?.id !== "string") {
       submissionCounter += 1;
     }
@@ -503,14 +714,14 @@ function takeReplaySpanCounts(traceIds) {
   }
   return counts;
 }
-function asRecord(value) {
+function asRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function resolveSourceTraceId(payload) {
   if (typeof payload.sourceTraceId === "string") {
     return payload.sourceTraceId;
   }
-  const rawTrace = asRecord(payload.externalTrace) ?? asRecord(payload.rawTrace);
+  const rawTrace = asRecord2(payload.externalTrace) ?? asRecord2(payload.rawTrace);
   return typeof rawTrace?.id === "string" ? rawTrace.id : void 0;
 }
 function otlpValue(value) {
@@ -568,32 +779,28 @@ function spanToOtlp(span) {
   }
   return result;
 }
-function buildOtlpRequest(first, spans) {
+var SPAN_SEPARATOR_BYTES = 1;
+function encodeSpan(span) {
+  const json = JSON.stringify(spanToOtlp(span));
+  return { json, size: byteLength(json) };
+}
+function requestEnvelope(first) {
   const scope = first.instrumentationScope;
-  return {
-    resourceSpans: [
-      {
-        resource: {
-          attributes: otlpAttributes(
-            first.resource.attributes
-          )
-        },
-        scopeSpans: [
-          {
-            scope: { name: scope.name, version: scope.version ?? "" },
-            spans
-          }
-        ]
-      }
-    ]
-  };
+  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 encodedSize(value) {
-  const json = JSON.stringify(value);
-  if (typeof TextEncoder !== "undefined") {
-    return new TextEncoder().encode(json).length;
-  }
-  return json.length;
+function encodeRequest(envelope, spans) {
+  return envelope.head + spans.map((span) => span.json).join(",") + envelope.tail;
 }
 function delay(ms) {
   return new Promise((resolve) => {
@@ -671,57 +878,55 @@ var BitfabSpanExporter = class {
       return true;
     }
     let encoded;
+    let envelope;
     try {
-      encoded = spans.map(spanToOtlp);
+      encoded = spans.map(encodeSpan);
+      envelope = requestEnvelope(spans[0]);
     } catch (error) {
       logError("failed to encode an OpenTelemetry span batch", error);
       return false;
     }
-    const first = spans[0];
-    const batches = this.buildRequestBatches(first, encoded);
+    const batches = this.buildRequestBatches(envelope, encoded);
     const results = await mapWithConcurrency(
       batches,
       this.exportConcurrency,
-      (batch) => this.send(first, batch)
+      (batch) => this.send(envelope, batch)
     );
     return results.every(Boolean);
   }
-  buildRequestBatches(first, spans) {
+  buildRequestBatches(envelope, spans) {
     const batches = [];
     let current = [];
+    let size = envelope.size;
     for (const span of spans) {
-      if (current.length >= this.maxRequestBatchSize) {
-        batches.push(current);
+      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;
       }
-      const candidate = [...current, span];
-      if (current.length > 0 && encodedSize(buildOtlpRequest(first, candidate)) > this.maxRequestBytes) {
-        batches.push(current);
-        current = [span];
-      } else {
-        current = candidate;
-      }
+      current.push(span);
+      size += span.size + (current.length > 1 ? SPAN_SEPARATOR_BYTES : 0);
     }
     if (current.length > 0) {
-      batches.push(current);
+      batches.push({ spans: current, size });
     }
     return batches;
   }
-  async send(first, spans) {
-    const payload = buildOtlpRequest(first, spans);
-    if (encodedSize(payload) > this.maxRequestBytes) {
+  async send(envelope, batch) {
+    if (batch.size > this.maxRequestBytes) {
       logError(
         "a single OpenTelemetry span exceeded the configured request-size target and could not be exported"
       );
       return false;
     }
     try {
-      await this.sendWithRetries(payload);
+      await this.sendWithRetries(encodeRequest(envelope, batch.spans));
       return true;
     } catch (error) {
       if (error instanceof OtlpPayloadTooLargeError) {
         logError(
-          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"
+          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;
       }
@@ -745,15 +950,15 @@ var BitfabSpanExporter = class {
    * the server does not yet understand. The fix is a client-supplied
    * idempotency key that ingestion dedupes on.
    */
-  async sendWithRetries(payload) {
+  async sendWithRetries(body) {
     for (let attempt = 0; attempt < MAX_SEND_ATTEMPTS; attempt += 1) {
       try {
         const response = await this.directSender(
           OTLP_TRACES_ENDPOINT,
-          payload,
+          body,
           EXPORT_TIMEOUT_MILLIS
         );
-        const partialSuccess = asRecord(response?.partialSuccess);
+        const partialSuccess = asRecord2(response?.partialSuccess);
         const rejected = partialSuccess?.rejectedSpans;
         if (rejected !== void 0 && rejected !== "0" && rejected !== 0) {
           logError(
@@ -781,115 +986,6 @@ var BitfabSpanExporter = class {
   async forceFlush() {
   }
 };
-var CollectorSpanExporter = class {
-  constructor(endpoint, apiKey, maxRequestBytes) {
-    this.endpoint = endpoint;
-    this.apiKey = apiKey;
-    this.maxRequestBytes = maxRequestBytes;
-  }
-  /**
-   * Loaded through a dynamic import rather than a top-level one so bundlers
-   * code-split it: Collector delivery is opt-in, and a consumer who never sets
-   * an endpoint should not pay for the exporter in their initial bundle. It is
-   * a hard dependency, so this cannot fail for want of the package.
-   */
-  loadExporterModule() {
-    if (!this.pendingModule) {
-      this.pendingModule = import("@opentelemetry/exporter-trace-otlp-proto");
-    }
-    return this.pendingModule;
-  }
-  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 delegate;
-    try {
-      delegate = await this.resolveDelegate();
-    } catch (error) {
-      logError("failed to build the OTLP Collector exporter", error);
-      return false;
-    }
-    const results = await Promise.all(
-      this.partition(spans).map(
-        (batch) => new Promise((resolve) => {
-          try {
-            delegate.export(batch, (result) => {
-              resolve(result.code === ExportResultCode.SUCCESS);
-            });
-          } catch (error) {
-            logError("Collector export threw", error);
-            resolve(false);
-          }
-        })
-      )
-    );
-    return results.every(Boolean);
-  }
-  /**
-   * Partition by the encoded JSON size of each carrier rather than its encoded
-   * protobuf size. Protobuf is strictly smaller than the equivalent JSON for
-   * these payloads, so the JSON figure is a conservative bound that keeps every
-   * request under the target without pulling `@opentelemetry/otlp-transformer`
-   * into the dependency set purely to measure bytes.
-   */
-  partition(spans) {
-    const batches = [];
-    let current = [];
-    let currentSize = 0;
-    for (const span of spans) {
-      const size = encodedSize(spanToOtlp(span));
-      if (current.length > 0 && currentSize + size > this.maxRequestBytes) {
-        batches.push(current);
-        current = [];
-        currentSize = 0;
-      }
-      current.push(span);
-      currentSize += size;
-    }
-    if (current.length > 0) {
-      batches.push(current);
-    }
-    return batches;
-  }
-  async resolveDelegate() {
-    const apiKey = this.apiKey() ?? "";
-    if (this.delegate && this.delegateApiKey === apiKey) {
-      return this.delegate;
-    }
-    const { OTLPTraceExporter } = await this.loadExporterModule();
-    const previous = this.delegate;
-    this.delegate = new OTLPTraceExporter({
-      url: this.endpoint,
-      headers: { Authorization: `Bearer ${apiKey}` },
-      timeoutMillis: EXPORT_TIMEOUT_MILLIS
-    });
-    this.delegateApiKey = apiKey;
-    if (previous) {
-      void previous.shutdown().catch(() => {
-      });
-    }
-    return this.delegate;
-  }
-  async shutdown() {
-    await this.delegate?.shutdown();
-  }
-  async forceFlush() {
-    await this.delegate?.forceFlush?.();
-  }
-};
 var DeliveryTrackingExporter = class {
   constructor(exporter) {
     this.exporter = exporter;
@@ -932,27 +1028,22 @@ var DeliveryTrackingExporter = class {
 var OtelBatchTransport = class {
   constructor(options) {
     this.closed = false;
-    const collectorEndpoint = options.collectorEndpoint;
     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(
-      collectorEndpoint === void 0 ? new BitfabSpanExporter(
+      new BitfabSpanExporter(
         options.directSender,
         maxRequestBytes,
         maxRequestBatchSize,
         options.exportConcurrency ?? DEFAULT_EXPORT_CONCURRENCY
-      ) : new CollectorSpanExporter(
-        normalizeCollectorEndpoint(collectorEndpoint),
-        options.apiKey,
-        maxRequestBytes
       )
     );
     this.processor = new BatchSpanProcessor(this.deliveryTracker, {
       maxQueueSize: options.maxQueueSize ?? MAX_QUEUE_SIZE,
-      maxExportBatchSize: options.maxExportBatchSize ?? (collectorEndpoint === void 0 ? DIRECT_MAX_EXPORT_BATCH_SIZE : COLLECTOR_MAX_EXPORT_BATCH_SIZE),
+      maxExportBatchSize: options.maxExportBatchSize ?? DIRECT_MAX_EXPORT_BATCH_SIZE,
       scheduledDelayMillis: SCHEDULE_DELAY_MILLIS,
       exportTimeoutMillis: options.exportTimeoutMillis ?? EXPORT_TIMEOUT_MILLIS
     });
@@ -1037,16 +1128,12 @@ var OtelBatchTransport = class {
     return flushed && shutdownCompleted;
   }
 };
-function normalizeCollectorEndpoint(endpoint) {
-  const trimmed = endpoint.replace(/\/+$/, "");
-  return trimmed.endsWith("/v1/traces") ? trimmed : `${trimmed}/v1/traces`;
-}
 function endSpan(span, endTime) {
   span.end(endTime);
 }
 function spanName(operation, payload) {
   if (operation === "external_span") {
-    const spanData = asRecord(asRecord(payload.rawSpan)?.span_data);
+    const spanData = asRecord2(asRecord2(payload.rawSpan)?.span_data);
     if (typeof spanData?.name === "string") {
       return spanData.name;
     }
@@ -1057,8 +1144,8 @@ function spanName(operation, payload) {
   return `bitfab.${operation}`;
 }
 function payloadTimestamp(payload, field) {
-  const rawSpan = asRecord(payload.rawSpan);
-  const rawTrace = asRecord(payload.externalTrace) ?? asRecord(payload.rawTrace);
+  const rawSpan = asRecord2(payload.rawSpan);
+  const rawTrace = asRecord2(payload.externalTrace) ?? asRecord2(payload.rawTrace);
   const raw = rawSpan?.[field] ?? rawTrace?.[field];
   if (typeof raw !== "string") {
     return void 0;
@@ -1067,7 +1154,7 @@ function payloadTimestamp(payload, field) {
   return Number.isNaN(parsed) ? void 0 : parsed;
 }
 function hasError(payload) {
-  const spanData = asRecord(asRecord(payload.rawSpan)?.span_data);
+  const spanData = asRecord2(asRecord2(payload.rawSpan)?.span_data);
   if (spanData?.error != null) {
     return true;
   }
@@ -1077,7 +1164,6 @@ function hasError(payload) {
 function createOtelTransport(options) {
   return new OtelBatchTransport({
     ...options,
-    collectorEndpoint: readEnv(COLLECTOR_ENDPOINT_ENV) || void 0,
     exportConcurrency: readBoundedIntEnv(
       EXPORT_CONCURRENCY_ENV,
       MAX_EXPORT_CONCURRENCY,
@@ -1225,8 +1311,7 @@ var HttpClient = class {
     }
     if (!this.traceTransport) {
       this.traceTransport = createTraceTransport({
-        apiKey: () => this.resolveApiKey(),
-        directSender: (endpoint, payload, timeoutMs) => this.request(endpoint, payload, {
+        directSender: (endpoint, body, timeoutMs) => this.sendEncoded(endpoint, body, {
           timeout: timeoutMs
         })
       });
@@ -1296,11 +1381,6 @@ var HttpClient = class {
    * @throws {BitfabError} If the request fails
    */
   async request(endpoint, payload, 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 { body, dropped } = serializePayloadBody(payload);
     if (dropped.length > 0) {
       try {
@@ -1310,14 +1390,33 @@ var HttpClient = class {
       } 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 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 prepared = encodeRequestBody(body);
+    const encoded = prepared instanceof Promise ? await prepared : prepared;
+    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: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.resolveApiKey() ?? ""}`
-        },
-        body,
+        headers,
+        body: encoded.body,
         signal: controller.signal
       });
       if (!response.ok) {
@@ -1657,8 +1756,8 @@ function fallbackUuidV4() {
 
 // src/serialize.ts
 import superjson from "superjson";
-var MAX_SERIALIZED_BYTES = 512e3;
-var MAX_FRAMEWORK_SERIALIZED_BYTES = 2e6;
+var MAX_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
+var MAX_FRAMEWORK_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
 function describeValue(value) {
   try {
     const ctorName = value?.constructor?.name;
@@ -2296,4 +2395,4 @@ export {
   reportReplayProgress,
   replay
 };
-//# sourceMappingURL=chunk-5ZMEY5NX.js.map
+//# sourceMappingURL=chunk-4YTIVUYX.js.map