@bitfab/sdk 0.36.12 → 0.38.0

package/dist/node.cjs

@@ -88,7 +88,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.36.12";
+    __version__ = "0.38.0";
   }
 });
 
@@ -2532,12 +2532,15 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
   let lease = includeDbBranchLease ? serverItem.dbBranchLease : void 0;
   let leaseError = includeDbBranchLease ? serverItem.dbBranchLeaseError : void 0;
   let dbSnapshotRef = serverItem.dbSnapshotRef;
+  let dbBranchTimings = includeDbBranchLease ? serverItem.dbBranchTimings : void 0;
   let inputs = [];
   let originalOutput;
   let result;
   let error = null;
   let traceError = null;
   let replayError = null;
+  let replayDurationMs = null;
+  let replayStarted = null;
   const originalTraceId = serverItem.originalTraceId ?? serverItem.sourceTraceId;
   const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
   try {
@@ -2560,6 +2563,7 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
       lease = resolved.lease ?? void 0;
       leaseError = resolved.leaseError ?? void 0;
       dbSnapshotRef = resolved.dbSnapshotRef ?? dbSnapshotRef;
+      dbBranchTimings = resolved.timings ?? dbBranchTimings;
     }
     if (leaseError) {
       throw new DbBranchReplayError(
@@ -2593,20 +2597,17 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
           includeOutputs,
           includeRootOutput: false
         });
-        if (treeResponse.root) {
-          mockTree = buildMockTree(treeResponse.root);
-        } else if (mockStrategy === "all" || hasOverrides) {
+        if (!treeResponse.root) {
           throw new BitfabError(
             `Replay mock strategy "${mockStrategy}"${hasOverrides ? " with overrides" : ""} requires a span tree root for original span ${originalSpanId}.`
           );
-        } else {
-          mockTree = void 0;
         }
-      } catch (e) {
-        if (mockStrategy === "all" || hasOverrides) {
-          throw e;
+        mockTree = buildMockTree(treeResponse.root);
+      } catch (error2) {
+        if (mockStrategy !== "marked" || hasOverrides) {
+          throw error2;
         }
-        mockTree = void 0;
+        mockTree = { spans: /* @__PURE__ */ new Map() };
       }
     }
     const outputCache = /* @__PURE__ */ new Map();
@@ -2623,6 +2624,7 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
       return pending;
     } : void 0;
     try {
+      replayStarted = performance.now();
       const maybePromise = runWithReplayContext(
         {
           testRunId,
@@ -2635,16 +2637,24 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
           mockStrategy,
           mockOverrides: hasOverrides ? resolvedOverrides : void 0,
           fetchSpanOutput,
-          dbBranchLease: lease
+          dbBranchLease: lease,
+          dbBranchTimings
         },
         () => fn(...inputs)
       );
       result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
+      replayDurationMs = Math.round(performance.now() - replayStarted);
     } catch (e) {
+      if (replayStarted !== null) {
+        replayDurationMs = Math.round(performance.now() - replayStarted);
+      }
       traceError = e;
       error = errorMessage(e);
     }
   } catch (e) {
+    if (replayStarted !== null) {
+      replayDurationMs = Math.round(performance.now() - replayStarted);
+    }
     replayError = e;
     error = replayItemErrorMessage(e);
   } finally {
@@ -2661,6 +2671,8 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
       }
     }
   }
+  const originalDurationMs = serverItem.originalDurationMs ?? serverItem.durationMs ?? null;
+  const originalModel = serverItem.originalModel ?? serverItem.model ?? null;
   return {
     // Written in by replay() from the complete-replay response once the server
     // has minted this replay trace's row. Null until then: the client-side
@@ -2677,13 +2689,17 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
     error,
     traceError,
     replayError,
-    durationMs: serverItem.durationMs ?? null,
+    durationMs: replayDurationMs,
+    originalDurationMs,
+    originalTokens: serverItem.originalTokens ?? serverItem.tokens ?? null,
+    originalModel,
     // Filled in by replay() from the complete-replay response once the
     // replay traces are persisted and their spans aggregated server-side.
     // Null here (and on older servers) means "replay tokens not known".
     tokens: null,
-    model: serverItem.model ?? null,
-    dbSnapshotRef: dbSnapshotRef ?? null
+    model: originalModel,
+    dbSnapshotRef: dbSnapshotRef ?? null,
+    dbBranchTimings: dbBranchTimings ?? null
   };
 }
 async function waitForReplayPersistence(httpClient, testRunId, replayedTraceIds) {
@@ -2910,9 +2926,13 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
             traceError: item.traceError,
             replayError: item.replayError,
             durationMs: item.durationMs,
+            originalDurationMs: item.originalDurationMs,
+            originalTokens: item.originalTokens,
+            originalModel: item.originalModel,
             tokens: item.tokens,
             model: item.model,
-            dbSnapshotRef: item.dbSnapshotRef
+            dbSnapshotRef: item.dbSnapshotRef,
+            dbBranchTimings: item.dbBranchTimings
           }
         });
       } catch {
@@ -6098,7 +6118,8 @@ var Bitfab = class {
                     snapshotTimestamp: replayCtx.dbBranchLease.snapshotTimestamp,
                     region: replayCtx.dbBranchLease.region,
                     originalTraceId: replayCtx.sourceBitfabTraceId,
-                    accessed: replayCtx.dbSnapshotAccessed === true
+                    accessed: replayCtx.dbSnapshotAccessed === true,
+                    timings: replayCtx.dbBranchTimings
                   }
                 }
               });
@@ -6188,7 +6209,12 @@ var Bitfab = class {
             }
           }
           const shouldMock = replayCtxForMock.mockStrategy === "all" || replayCtxForMock.mockStrategy === "marked" && options.mockOnReplay === true;
-          if (shouldMock && mockSpan) {
+          if (shouldMock && !mockSpan) {
+            throw new BitfabError(
+              `Replay selected span "${traceFunctionKey}:${baseSpanParams.spanName}" for mocking, but recorded occurrence ${callIndex + 1} is unavailable. The real span was not executed.`
+            );
+          }
+          if (shouldMock) {
             const recorded = resolveRecordedOutput();
             if (recorded instanceof Promise) {
               return emitMockAsync(recorded, "recorded");
@@ -6425,7 +6451,13 @@ var Bitfab = class {
           // against servers that predate the rename.
           source_trace_id: params.dbSnapshotUsage.originalTraceId
         },
-        accessed: params.dbSnapshotUsage.accessed
+        accessed: params.dbSnapshotUsage.accessed,
+        // Echoed verbatim (camelCase inside) rather than re-cased into this
+        // record's snake_case: it is the server's own object coming back, and
+        // a translation layer here is one more thing to drift.
+        ...params.dbSnapshotUsage.timings && {
+          timings: params.dbSnapshotUsage.timings
+        }
       };
     }
     this.httpClient.sendExternalTrace({