bitfab 0.53.0 → 0.53.1

package/dist/{chunk-6IMGAODW.js → chunk-ASMHSKFS.js}

@@ -99,7 +99,7 @@ function encodeRequestBody(body) {
 }
 
 // src/version.generated.ts
-var __version__ = "0.53.0";
+var __version__ = "0.53.1";
 var __packageName__ = "bitfab";
 
 // src/constants.ts
@@ -385,8 +385,8 @@ function encodePayloadBody(payload) {
       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 isRecord3 = typeof sanitized === "object" && sanitized !== null && !Array.isArray(sanitized);
+    if (dropped.length > 0 && isRecord3) {
       const obj = sanitized;
       const existing = Array.isArray(obj.errors) ? obj.errors : [];
       obj.errors = [
@@ -403,11 +403,431 @@ function encodePayloadBody(payload) {
     return {
       body: JSON.stringify(sanitized),
       dropped,
-      value: isRecord ? sanitized : void 0
+      value: isRecord3 ? sanitized : void 0
     };
   }
 }
 
+// src/policyRefresh.ts
+var PolicyRefresh = class {
+  constructor() {
+    this.refreshAfter = 0;
+  }
+  due() {
+    return this.inFlight === void 0 && Date.now() >= this.refreshAfter;
+  }
+  hold(durationMs) {
+    this.refreshAfter = Date.now() + durationMs;
+  }
+  releaseHold() {
+    this.refreshAfter = 0;
+  }
+  run(read, onLoaded, onFailed) {
+    if (!this.due()) {
+      return;
+    }
+    let request;
+    try {
+      request = read().then(onLoaded).catch(onFailed).finally(() => {
+        this.inFlight = void 0;
+      });
+    } catch (error) {
+      onFailed(error);
+      return;
+    }
+    this.inFlight = request;
+  }
+};
+
+// src/spanOrigin.ts
+var SPAN_ORIGIN_NAME = "bitfab.sdk.typescript";
+var SPAN_INSTRUMENTATIONS = [
+  "span",
+  "trace",
+  "openai-agents",
+  "langgraph",
+  "claude-agent-sdk",
+  "vercel-ai"
+];
+var FRAMEWORK_INSTRUMENTATIONS = [
+  "openai-agents",
+  "langgraph",
+  "claude-agent-sdk",
+  "vercel-ai"
+];
+var FRAMEWORK_INSTRUMENTATION_SET = new Set(
+  FRAMEWORK_INSTRUMENTATIONS
+);
+function isFrameworkInstrumentation(value) {
+  return typeof value === "string" && FRAMEWORK_INSTRUMENTATION_SET.has(value);
+}
+function makeSpanOrigin(instrumentation) {
+  return {
+    name: SPAN_ORIGIN_NAME,
+    version: __version__,
+    instrumentation: { name: instrumentation }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function spanOriginOf(payload) {
+  const rawSpan = payload.rawSpan;
+  if (!isRecord(rawSpan)) {
+    return void 0;
+  }
+  const origin = rawSpan.span_origin;
+  if (!isRecord(origin) || !isRecord(origin.instrumentation)) {
+    return void 0;
+  }
+  const { name, version } = origin;
+  const instrumentation = origin.instrumentation.name;
+  if (typeof name !== "string" || typeof version !== "string" || typeof instrumentation !== "string" || !SPAN_INSTRUMENTATIONS.includes(instrumentation)) {
+    return void 0;
+  }
+  return {
+    name,
+    version,
+    instrumentation: { name: instrumentation }
+  };
+}
+function spanInstrumentationOf(payload) {
+  return spanOriginOf(payload)?.instrumentation.name;
+}
+function recordedByFramework(payload) {
+  return isFrameworkInstrumentation(spanInstrumentationOf(payload));
+}
+
+// src/unrefTimer.ts
+function unrefTimer(timer) {
+  const handle = timer;
+  if (typeof handle.unref === "function") {
+    handle.unref();
+  }
+}
+
+// src/simulationPlan.ts
+var SIMULATION_PLAN_REFRESH_MS = 6e4;
+var SIMULATION_PLAN_RETRY_MS = 1e4;
+var SIMULATION_PLAN_READ_TIMEOUT_MS = 5e3;
+var SIMULATION_PLAN_MAX_HELD = 1e3;
+var DISABLE_SIMULATION_PLAN_ENV = "BITFAB_DISABLE_SIM_PLAN";
+var ROOT_TRACE_FUNCTION_KEY_FIELD = "rootTraceFunctionKey";
+var CONTENT_OFF_KEY = "content_off_by_simulation_plan";
+var CONTENT_KEYS = ["input", "input_meta", "output", "output_meta"];
+function planWaitSliceMs(timeoutMs) {
+  return Math.min(SIMULATION_PLAN_READ_TIMEOUT_MS, Math.max(timeoutMs, 0) / 2);
+}
+function parseSimulationPlan(body) {
+  if (typeof body !== "object" || body === null) {
+    return null;
+  }
+  const nodes = body.nodes;
+  if (!Array.isArray(nodes)) {
+    return null;
+  }
+  const contentOff = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (typeof node !== "object" || node === null) {
+      continue;
+    }
+    const { traceFunctionKey, name, captureContent } = node;
+    if (typeof traceFunctionKey !== "string" || typeof name !== "string" || typeof captureContent !== "boolean") {
+      continue;
+    }
+    if (captureContent) {
+      continue;
+    }
+    const names = contentOff.get(traceFunctionKey) ?? /* @__PURE__ */ new Set();
+    names.add(name);
+    contentOff.set(traceFunctionKey, names);
+  }
+  return contentOff;
+}
+function traceIdOf(payload) {
+  const traceId = payload.traceId;
+  if (typeof traceId === "string") {
+    return traceId;
+  }
+  const id = payload.id;
+  return typeof id === "string" ? id : void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function rawSpanOf(payload) {
+  return isRecord2(payload.rawSpan) ? payload.rawSpan : void 0;
+}
+function spanDataOf(payload) {
+  const spanData = rawSpanOf(payload)?.span_data;
+  return isRecord2(spanData) ? spanData : void 0;
+}
+function spanNameOf(payload) {
+  const name = spanDataOf(payload)?.name;
+  return typeof name === "string" ? name : void 0;
+}
+function stripContent(payload) {
+  const rawSpan = rawSpanOf(payload);
+  const spanData = spanDataOf(payload);
+  if (rawSpan === void 0 || spanData === void 0) {
+    return payload;
+  }
+  const kept = { ...spanData };
+  for (const key of CONTENT_KEYS) {
+    delete kept[key];
+  }
+  kept[CONTENT_OFF_KEY] = true;
+  return { ...payload, rawSpan: { ...rawSpan, span_data: kept } };
+}
+function simulationPlanEnvDisabled() {
+  const value = readEnv(DISABLE_SIMULATION_PLAN_ENV);
+  return typeof value === "string" && value.trim() !== "";
+}
+function missingSimulationPlanEndpoint(error) {
+  return error instanceof BitfabError && error.status === 404;
+}
+var SimulationPlan = class {
+  constructor(source, enabled = true) {
+    this.source = source;
+    this.enabled = enabled;
+    this.policyRefresh = new PolicyRefresh();
+    this.retryPending = false;
+    this.waitingForFirstLoad = 0;
+    this.held = [];
+    this.droppedWhileHolding = 0;
+    this.stopped = false;
+    this.loaded = new Promise((resolve) => {
+      this.resolveLoaded = resolve;
+    });
+  }
+  disabled() {
+    return !this.enabled || simulationPlanEnvDisabled();
+  }
+  refresh() {
+    if (this.stopped || this.disabled()) {
+      return;
+    }
+    this.policyRefresh.run(
+      () => this.source.getSimulationPlan(),
+      (body) => {
+        const parsed = parseSimulationPlan(body);
+        if (parsed === null) {
+          this.scheduleRetry(
+            "sim-plan-unreadable",
+            "the sim plan response was not understood"
+          );
+          return;
+        }
+        this.markLoaded(parsed);
+      },
+      (error) => {
+        if (missingSimulationPlanEndpoint(error)) {
+          this.markLoaded(/* @__PURE__ */ new Map());
+          return;
+        }
+        this.scheduleRetry(
+          "sim-plan-unavailable",
+          `could not read the sim plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    );
+  }
+  markLoaded(parsed) {
+    if (this.stopped) {
+      return;
+    }
+    this.contentOffByKey = parsed;
+    this.policyRefresh.hold(SIMULATION_PLAN_REFRESH_MS);
+    this.retryPending = false;
+    this.clearRetryTimer();
+    this.resolveLoaded?.();
+    this.resolveLoaded = void 0;
+    this.releaseHeld();
+  }
+  scheduleRetry(warnKey, reason) {
+    if (this.stopped) {
+      return;
+    }
+    this.policyRefresh.hold(SIMULATION_PLAN_RETRY_MS);
+    if (this.contentOffByKey !== void 0) {
+      return;
+    }
+    this.retryPending = true;
+    warnOnce(
+      warnKey,
+      `${reason}. Spans are held until the first read succeeds; while a record is held it is retried every ${SIMULATION_PLAN_RETRY_MS / 1e3}s, otherwise on the next span.`
+    );
+    this.armRetry();
+  }
+  holdsWork() {
+    return this.held.length > 0 || this.waitingForFirstLoad > 0;
+  }
+  armRetry() {
+    if (this.stopped || !this.retryPending || this.retryTimer !== void 0 || !this.holdsWork()) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      this.retryTimer = void 0;
+      this.policyRefresh.releaseHold();
+      this.refresh();
+    }, SIMULATION_PLAN_RETRY_MS);
+    unrefTimer(timer);
+    this.retryTimer = timer;
+  }
+  clearRetryTimer() {
+    if (this.retryTimer !== void 0) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+  }
+  syncRetryTimer() {
+    if (this.holdsWork()) {
+      return;
+    }
+    this.clearRetryTimer();
+  }
+  firstLoad() {
+    if (this.contentOffByKey !== void 0 || this.stopped || this.disabled()) {
+      return void 0;
+    }
+    return this.loaded;
+  }
+  send(payload, traceFunctionKey, submit) {
+    this.refresh();
+    if (this.stopped || this.disabled() || traceFunctionKey === void 0 || spanNameOf(payload) === void 0 || recordedByFramework(payload)) {
+      submit(payload);
+      return;
+    }
+    if (this.contentOffByKey === void 0) {
+      this.hold({ payload, traceFunctionKey, submit });
+      return;
+    }
+    this.submitEntry({ payload, traceFunctionKey, submit });
+  }
+  sendTrace(payload, submit) {
+    this.refresh();
+    if (this.stopped || this.disabled() || this.contentOffByKey !== void 0 || !this.holdsSpanOfTrace(traceIdOf(payload))) {
+      submit(payload);
+      return;
+    }
+    this.hold({ payload, traceFunctionKey: void 0, submit });
+  }
+  holdsSpanOfTrace(traceId) {
+    if (traceId === void 0) {
+      return false;
+    }
+    return this.held.some(
+      (entry) => entry.traceFunctionKey !== void 0 && traceIdOf(entry.payload) === traceId
+    );
+  }
+  hold(entry) {
+    this.held.push(entry);
+    while (this.held.length > SIMULATION_PLAN_MAX_HELD) {
+      this.held.shift();
+      this.droppedWhileHolding += 1;
+    }
+    this.armRetry();
+  }
+  submitEntry(entry) {
+    try {
+      entry.submit(
+        entry.traceFunctionKey === void 0 ? entry.payload : this.apply(entry.payload, entry.traceFunctionKey)
+      );
+    } catch (error) {
+      warnOnce(
+        "sim-plan-held-span-dropped",
+        `a span held for the sim plan was dropped when released: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  releaseHeld() {
+    const held = this.held;
+    this.held = [];
+    this.syncRetryTimer();
+    this.warnDropped();
+    for (const entry of held) {
+      this.submitEntry(entry);
+    }
+  }
+  warnDropped() {
+    if (this.droppedWhileHolding === 0) {
+      return;
+    }
+    const dropped = this.droppedWhileHolding;
+    this.droppedWhileHolding = 0;
+    warnOnce(
+      "sim-plan-held-overflow",
+      `${dropped} record(s) were dropped while the sim plan was still loading; at most ${SIMULATION_PLAN_MAX_HELD} are held per client.`
+    );
+  }
+  warnNeverLoaded() {
+    if (this.held.length === 0) {
+      return;
+    }
+    warnOnce(
+      "sim-plan-never-loaded",
+      `${this.held.length} record(s) were not sent because the sim plan never loaded`
+    );
+  }
+  async release(timeoutMs) {
+    this.refresh();
+    if (this.holdsWork()) {
+      await this.waitForFirstLoad(timeoutMs);
+    }
+    this.warnNeverLoaded();
+    this.warnDropped();
+  }
+  waitForFirstLoad(timeoutMs) {
+    const firstLoad = this.firstLoad();
+    if (firstLoad === void 0) {
+      return Promise.resolve();
+    }
+    this.waitingForFirstLoad += 1;
+    this.armRetry();
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        this.waitingForFirstLoad -= 1;
+        this.syncRetryTimer();
+        resolve();
+      };
+      const timer = setTimeout(finish, Math.max(timeoutMs, 0));
+      void firstLoad.then(() => {
+        clearTimeout(timer);
+        finish();
+      });
+    });
+  }
+  stop() {
+    if (this.stopped) {
+      return;
+    }
+    this.stopped = true;
+    this.retryPending = false;
+    this.clearRetryTimer();
+    this.warnNeverLoaded();
+    this.held = [];
+    this.warnDropped();
+  }
+  contentOff(traceFunctionKey, spanName) {
+    return this.contentOffByKey?.get(traceFunctionKey)?.has(spanName) === true;
+  }
+  apply(payload, traceFunctionKey) {
+    if (recordedByFramework(payload)) {
+      return payload;
+    }
+    const name = spanNameOf(payload);
+    if (name === void 0 || !this.contentOff(traceFunctionKey, name)) {
+      return payload;
+    }
+    return stripContent(payload);
+  }
+};
+
 // src/traceMetadata.ts
 var RETAINED_COMPLETED_TRACES = 128;
 var activeRecords = /* @__PURE__ */ new Map();
@@ -523,14 +943,6 @@ var DeliveryError = class extends Error {
   }
 };
 
-// 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";
@@ -1153,6 +1565,18 @@ 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);
+  for (const client of [...liveHttpClients]) {
+    await client.releaseHeldExternalSpans?.(Math.max(0, deadline - Date.now()));
+  }
+}
+function stopSimulationPlans() {
+  for (const client of [...liveHttpClients]) {
+    client.stopSimulationPlan?.();
+  }
+}
 function awaitOnExit(promise) {
   pendingTracePromises.add(promise);
   void promise.finally(() => {
@@ -1163,7 +1587,10 @@ function awaitOnExit(promise) {
 }
 async function flushTraces(timeoutMs = 5e3) {
   const deadline = Date.now() + Math.max(timeoutMs, 0);
-  const requestsFlushed = await awaitPendingRequests(timeoutMs);
+  await releaseHeldExternalSpans(planWaitSliceMs(timeoutMs));
+  const requestsFlushed = await awaitPendingRequests(
+    Math.max(0, deadline - Date.now())
+  );
   const transportsFlushed = await flushTraceTransports(
     Math.max(0, deadline - Date.now())
   );
@@ -1200,12 +1627,27 @@ if (typeof process !== "undefined" && process.versions != null && process.versio
       return;
     }
     isFlushing = true;
-    void Promise.allSettled([
-      ...Array.from(pendingTracePromises).map((p) => p.catch(() => {
-      })),
-      shutdownTraceTransports(EXIT_FLUSH_TIMEOUT_MS).catch(() => false)
-    ]).then(() => {
+    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();
     });
   });
 }
@@ -1299,6 +1741,21 @@ function sourceTraceIdOf(payload) {
   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
@@ -1313,6 +1770,7 @@ var HttpClient = class {
     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
@@ -1510,9 +1968,14 @@ var HttpClient = class {
    * 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);
+    await this.releaseHeldExternalSpans?.(planWaitSliceMs(timeoutMs));
     await replayContextReady.catch(() => {
     });
-    return waitForPromises(Array.from(this.deferredWork), timeoutMs);
+    return waitForPromises(
+      Array.from(this.deferredWork),
+      Math.max(0, deadline - Date.now())
+    );
   }
   /**
    * Wait for spans queued by this client to be delivered, within one deadline.
@@ -1520,7 +1983,9 @@ var HttpClient = class {
    */
   async waitForPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
     const deadline = Date.now() + Math.max(timeoutMs, 0);
-    const settled = await this.settleDeferredWork(timeoutMs);
+    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;
   }
@@ -1535,6 +2000,13 @@ var HttpClient = class {
     }
     const deadline = Date.now() + Math.max(timeoutMs, 0);
     this.closing = (async () => {
+      await this.releaseHeldExternalSpans?.(planWaitSliceMs(timeoutMs));
+      this.stopSimulationPlan?.();
+      this.externalSpanTransform = void 0;
+      this.externalTraceTransform = void 0;
+      this.releaseHeldExternalSpans = void 0;
+      this.stopSimulationPlan = void 0;
+      liveHttpClients.delete(this);
       const settled = await this.settleDeferredWork(
         Math.max(0, deadline - Date.now())
       );
@@ -1646,6 +2118,13 @@ var HttpClient = class {
       protocol
     });
   }
+  async getSimulationPlan() {
+    return this.get(
+      "/api/sdk/sim-plan",
+      SIMULATION_PLAN_READ_TIMEOUT_MS,
+      { Connection: "close" }
+    );
+  }
   async getTraceSpan(traceId, lookup) {
     const searchParams = new URLSearchParams();
     if (lookup.id !== void 0) {
@@ -1662,14 +2141,18 @@ var HttpClient = class {
    * 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) {
+  async get(endpoint, timeoutMs, extraHeaders) {
     const url = `${this.serviceUrl}${endpoint}`;
+    const timeout = timeoutMs ?? this.timeout;
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
       const response = await fetch(url, {
         method: "GET",
-        headers: { Authorization: `Bearer ${this.resolveApiKey() ?? ""}` },
+        headers: {
+          Authorization: `Bearer ${this.resolveApiKey() ?? ""}`,
+          ...extraHeaders
+        },
         signal: controller.signal
       });
       if (!response.ok) {
@@ -1688,7 +2171,7 @@ var HttpClient = class {
       }
       if (error instanceof Error) {
         if (error.name === "AbortError") {
-          throw new BitfabError(`Request timed out after ${this.timeout}ms`);
+          throw new BitfabError(`Request timed out after ${timeout}ms`);
         }
         throw new BitfabError(error.message);
       }
@@ -1715,16 +2198,27 @@ var HttpClient = class {
       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) {
+    const gate = this.externalSpanTransform;
+    if (gate === void 0) {
+      this.submitExternalSpan(payload);
+      return;
+    }
+    try {
+      gate(payload, (ready) => this.submitExternalSpan(ready));
+    } catch (error) {
+      warnDroppedExternalSpan(error);
+    }
+  }
+  submitExternalSpan(payload) {
+    const body = {
+      ...payload,
+      sdkVersion: __version__
+    };
+    delete body[ROOT_TRACE_FUNCTION_KEY_FIELD];
     this.getTraceTransport()?.submit(
       "external_span",
-      { ...payload, sdkVersion: __version__ },
+      body,
       this.recordedMeta("external_span", payload, carrierRef(payload))
     );
   }
@@ -1736,6 +2230,18 @@ var HttpClient = class {
    */
   sendExternalTrace(rawPayload) {
     const payload = mergeCallerMetadataIntoTracePayload(rawPayload);
+    const gate = this.externalTraceTransform;
+    if (gate === void 0) {
+      this.submitExternalTrace(payload);
+      return;
+    }
+    try {
+      gate(payload, (ready) => this.submitExternalTrace(ready));
+    } catch (error) {
+      warnDroppedExternalTrace(error);
+    }
+  }
+  submitExternalTrace(payload) {
     this.getTraceTransport()?.submit(
       "external_trace",
       {
@@ -1983,6 +2489,10 @@ export {
   MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES,
   warnOnce,
   serializePayloadBody,
+  PolicyRefresh,
+  makeSpanOrigin,
+  ROOT_TRACE_FUNCTION_KEY_FIELD,
+  SimulationPlan,
   recordCallerTraceMetadata,
   callerTraceMetadata,
   retireTraceMetadata,
@@ -1992,4 +2502,4 @@ export {
   parseRetryAfterMs,
   HttpClient
 };
-//# sourceMappingURL=chunk-6IMGAODW.js.map
+//# sourceMappingURL=chunk-ASMHSKFS.js.map