@bitfab/sdk 0.36.13 → 0.38.0

package/dist/index.cjs

@@ -42,7 +42,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.36.13";
+    __version__ = "0.38.0";
   }
 });
 
@@ -2525,12 +2525,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 {
@@ -2553,6 +2556,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(
@@ -2613,6 +2617,7 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
       return pending;
     } : void 0;
     try {
+      replayStarted = performance.now();
       const maybePromise = runWithReplayContext(
         {
           testRunId,
@@ -2625,16 +2630,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 {
@@ -2651,6 +2664,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
@@ -2667,13 +2682,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) {
@@ -2900,9 +2919,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 {
@@ -6081,7 +6104,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
                   }
                 }
               });
@@ -6413,7 +6437,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({