bitfab 0.54.14 → 0.57.1

package/dist/{chunk-NIGVK5V7.js → chunk-OBZQSMPQ.js}

@@ -187,7 +187,7 @@ function encodeRequestBody(body) {
 }
 
 // src/version.generated.ts
-var __version__ = "0.54.14";
+var __version__ = "0.57.1";
 var __packageName__ = "bitfab";
 
 // src/constants.ts
@@ -780,14 +780,6 @@ 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;
@@ -868,19 +860,25 @@ function simulationPlanEnvDisabled() {
 function missingSimulationPlanEndpoint(error) {
   return error instanceof BitfabError && error.status === 404;
 }
+function isTraceRootSpan(payload) {
+  const parentId = rawSpanOf(payload)?.parent_id;
+  return parentId === void 0 || parentId === null;
+}
 var SimulationPlan = class {
   constructor(source, enabled = true) {
     this.source = source;
     this.enabled = enabled;
     this.policyRefresh = new PolicyRefresh();
-    this.retryPending = false;
-    this.waitingForFirstLoad = 0;
+    this.firstReadOver = false;
+    this.rootWaitOver = false;
     this.held = [];
-    this.droppedWhileHolding = 0;
     this.stopped = false;
     this.loaded = new Promise((resolve) => {
       this.resolveLoaded = resolve;
     });
+    this.firstReadEnded = new Promise((resolve) => {
+      this.resolveFirstReadEnded = resolve;
+    });
   }
   disabled() {
     return !this.enabled || simulationPlanEnvDisabled();
@@ -898,19 +896,21 @@ var SimulationPlan = class {
             "sim-plan-unreadable",
             "the sim plan response was not understood"
           );
-          return;
+        } else {
+          this.markLoaded(parsed);
         }
-        this.markLoaded(parsed);
+        this.endFirstRead();
       },
       (error) => {
         if (missingSimulationPlanEndpoint(error)) {
           this.markLoaded(/* @__PURE__ */ new Map());
-          return;
+        } else {
+          this.scheduleRetry(
+            "sim-plan-unavailable",
+            `could not read the sim plan: ${error instanceof Error ? error.message : String(error)}`
+          );
         }
-        this.scheduleRetry(
-          "sim-plan-unavailable",
-          `could not read the sim plan: ${error instanceof Error ? error.message : String(error)}`
-        );
+        this.endFirstRead();
       }
     );
   }
@@ -920,11 +920,8 @@ var SimulationPlan = class {
     }
     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) {
@@ -934,39 +931,50 @@ var SimulationPlan = class {
     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.`
+      `${reason}. Until a read succeeds, spans are sent without their inputs and outputs, except each trace's root span and spans recorded by a framework integration. The read is retried on the next span after ${SIMULATION_PLAN_RETRY_MS / 1e3}s.`
     );
-    this.armRetry();
   }
-  holdsWork() {
-    return this.held.length > 0 || this.waitingForFirstLoad > 0;
-  }
-  armRetry() {
-    if (this.stopped || !this.retryPending || this.retryTimer !== void 0 || !this.holdsWork()) {
-      return;
+  endFirstRead() {
+    this.endRootWait();
+    if (!this.firstReadOver) {
+      this.firstReadOver = true;
+      this.resolveFirstReadEnded?.();
+      this.resolveFirstReadEnded = void 0;
     }
-    const timer = setTimeout(() => {
-      this.retryTimer = void 0;
-      this.policyRefresh.releaseHold();
-      this.refresh();
-    }, SIMULATION_PLAN_RETRY_MS);
-    unrefTimer(timer);
-    this.retryTimer = timer;
+    this.releaseHeld();
   }
-  clearRetryTimer() {
-    if (this.retryTimer !== void 0) {
-      clearTimeout(this.retryTimer);
-      this.retryTimer = void 0;
+  endRootWait() {
+    this.rootWaitOver = true;
+    if (this.rootWaitTimer !== void 0) {
+      clearTimeout(this.rootWaitTimer);
+      this.rootWaitTimer = void 0;
     }
+    this.resolveRootWait?.();
+    this.resolveRootWait = void 0;
   }
-  syncRetryTimer() {
-    if (this.holdsWork()) {
-      return;
+  waitForFirstRead() {
+    this.refresh();
+    if (this.rootWaitOver || this.disabled() || !this.holdingForFirstRead()) {
+      return void 0;
+    }
+    if (this.rootWait === void 0) {
+      this.rootWait = new Promise((resolve) => {
+        this.resolveRootWait = resolve;
+      });
+      this.rootWaitTimer = setTimeout(
+        () => this.endRootWait(),
+        SIMULATION_PLAN_READ_TIMEOUT_MS
+      );
     }
-    this.clearRetryTimer();
+    return this.rootWait;
+  }
+  holdingForFirstRead() {
+    return this.contentOffByKey === void 0 && !this.firstReadOver && !this.stopped;
+  }
+  unavailableNow() {
+    return !this.disabled() && this.contentOffByKey === void 0 && this.firstReadOver;
   }
   firstLoad() {
     if (this.contentOffByKey !== void 0 || this.stopped || this.disabled()) {
@@ -976,19 +984,20 @@ var SimulationPlan = class {
   }
   send(payload, traceFunctionKey, submit) {
     this.refresh();
-    if (this.stopped || this.disabled() || traceFunctionKey === void 0 || spanNameOf(payload) === void 0 || recordedByFramework(payload)) {
+    if (this.disabled() || traceFunctionKey === void 0 || spanNameOf(payload) === void 0 || recordedByFramework(payload)) {
       submit(payload);
       return;
     }
-    if (this.contentOffByKey === void 0) {
-      this.hold({ payload, traceFunctionKey, submit });
+    const entry = { payload, traceFunctionKey, submit };
+    if (this.holdingForFirstRead()) {
+      this.hold(entry);
       return;
     }
-    this.submitEntry({ payload, traceFunctionKey, submit });
+    this.submitEntry(entry);
   }
   sendTrace(payload, submit) {
     this.refresh();
-    if (this.stopped || this.disabled() || this.contentOffByKey !== void 0 || !this.holdsSpanOfTrace(traceIdOf(payload))) {
+    if (this.disabled() || !this.holdingForFirstRead() || !this.holdsSpanOfTrace(traceIdOf(payload))) {
       submit(payload);
       return;
     }
@@ -1004,17 +1013,34 @@ var SimulationPlan = class {
   }
   hold(entry) {
     this.held.push(entry);
+    let overflowed = false;
     while (this.held.length > SIMULATION_PLAN_MAX_HELD) {
-      this.held.shift();
-      this.droppedWhileHolding += 1;
+      const oldest = this.held.shift();
+      this.submitEntry(oldest);
+      overflowed = true;
+    }
+    if (overflowed) {
+      warnOnce(
+        "sim-plan-held-overflow",
+        `more than ${SIMULATION_PLAN_MAX_HELD} records were waiting for the sim plan, so the oldest were sent without their inputs and outputs.`
+      );
     }
-    this.armRetry();
+  }
+  payloadToSend(entry) {
+    if (entry.traceFunctionKey === void 0) {
+      return entry.payload;
+    }
+    if (this.contentOffByKey !== void 0) {
+      return this.apply(entry.payload, entry.traceFunctionKey);
+    }
+    if (recordedByFramework(entry.payload) || isTraceRootSpan(entry.payload)) {
+      return entry.payload;
+    }
+    return stripContent(entry.payload);
   }
   submitEntry(entry) {
     try {
-      entry.submit(
-        entry.traceFunctionKey === void 0 ? entry.payload : this.apply(entry.payload, entry.traceFunctionKey)
-      );
+      entry.submit(this.payloadToSend(entry));
     } catch (error) {
       warnOnce(
         "sim-plan-held-span-dropped",
@@ -1025,63 +1051,38 @@ var SimulationPlan = class {
   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() {
+  releaseHeldWithoutPlan() {
     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`
-    );
+    if (this.contentOffByKey === void 0) {
+      warnOnce(
+        "sim-plan-not-loaded-at-release",
+        `${this.held.length} record(s) were sent without their inputs and outputs because the sim plan had not loaded`
+      );
+    }
+    this.releaseHeld();
   }
   async release(timeoutMs) {
     this.refresh();
-    if (this.holdsWork()) {
-      await this.waitForFirstLoad(timeoutMs);
+    if (this.held.length > 0) {
+      await this.waitForFirstReadEnd(timeoutMs);
     }
-    this.warnNeverLoaded();
-    this.warnDropped();
-    return this.held.length === 0;
+    this.releaseHeldWithoutPlan();
   }
-  waitForFirstLoad(timeoutMs) {
-    const firstLoad = this.firstLoad();
-    if (firstLoad === void 0) {
+  waitForFirstReadEnd(timeoutMs) {
+    if (this.firstReadOver) {
       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(() => {
+      const timer = setTimeout(resolve, Math.max(timeoutMs, 0));
+      void this.firstReadEnded.then(() => {
         clearTimeout(timer);
-        finish();
+        resolve();
       });
     });
   }
@@ -1089,16 +1090,16 @@ var SimulationPlan = class {
     if (this.stopped) {
       return;
     }
+    this.releaseHeldWithoutPlan();
     this.stopped = true;
-    this.retryPending = false;
-    this.clearRetryTimer();
-    this.warnNeverLoaded();
-    this.held = [];
-    this.warnDropped();
+    this.endFirstRead();
   }
   contentOff(traceFunctionKey, spanName) {
     return this.contentOffByKey?.get(traceFunctionKey)?.has(spanName) === true;
   }
+  contentOffNow(traceFunctionKey, spanName) {
+    return !this.stopped && !this.disabled() && this.contentOff(traceFunctionKey, spanName);
+  }
   apply(payload, traceFunctionKey) {
     if (recordedByFramework(payload)) {
       return payload;
@@ -1226,6 +1227,14 @@ 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";
@@ -2812,8 +2821,12 @@ export {
   MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES,
   warnOnce,
   serializePayloadBody,
+  isFrameworkInstrumentation,
   makeSpanOrigin,
+  recordedByFramework,
   ROOT_TRACE_FUNCTION_KEY_FIELD,
+  CONTENT_OFF_KEY,
+  traceIdOf,
   SimulationPlan,
   recordCallerTraceMetadata,
   callerTraceMetadata,
@@ -2824,4 +2837,4 @@ export {
   parseRetryAfterMs,
   HttpClient
 };
-//# sourceMappingURL=chunk-NIGVK5V7.js.map
+//# sourceMappingURL=chunk-OBZQSMPQ.js.map