@bitfab/sdk 0.36.11 → 0.36.13

package/dist/index.cjs

@@ -42,7 +42,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.36.11";
+    __version__ = "0.36.13";
   }
 });
 
@@ -2586,20 +2586,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();
@@ -6101,14 +6098,19 @@ var Bitfab = class {
           counters.set(counterKey, callIndex + 1);
           const mockKey = `${counterKey}:${callIndex}`;
           const mockSpan = replayCtxForMock.mockTree.spans.get(mockKey);
-          const emitMock = (output) => {
-            void sendSpan({ result: output, mocked: true });
+          const emitMock = (output, mockSource) => {
+            void sendSpan({
+              result: output,
+              mocked: true,
+              mockTarget: "output",
+              mockSource
+            });
             if (fnReturnsPromise) {
               return Promise.resolve(output);
             }
             return output;
           };
-          const emitMockAsync = (pending) => {
+          const emitMockAsync = (pending, mockSource) => {
             if (!fnReturnsPromise) {
               throw new BitfabError(
                 `Cannot mock synchronous span "${traceFunctionKey}" with an asynchronously-resolved value (lazy recorded-output fetch or an async value function). Make the wrapped function async, or use mock: "all" so recorded outputs are fetched eagerly.`
@@ -6116,7 +6118,12 @@ var Bitfab = class {
             }
             return (async () => {
               const output = await pending;
-              void sendSpan({ result: output, mocked: true });
+              void sendSpan({
+                result: output,
+                mocked: true,
+                mockTarget: "output",
+                mockSource
+              });
               return output;
             })();
           };
@@ -6158,18 +6165,23 @@ var Bitfab = class {
                 getOriginalOutput: () => Promise.resolve(resolveRecordedOutput())
               });
               if (injected instanceof Promise) {
-                return emitMockAsync(injected);
+                return emitMockAsync(injected, "override");
               }
-              return emitMock(injected);
+              return emitMock(injected, "override");
             }
           }
           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);
+              return emitMockAsync(recorded, "recorded");
             }
-            return emitMock(recorded);
+            return emitMock(recorded, "recorded");
           }
         }
         const recordSpan = (result) => {
@@ -6469,7 +6481,9 @@ var Bitfab = class {
       traceFunctionKey: params.traceFunctionKey,
       rawSpan: externalSpan,
       ...params.testRunId && { testRunId: params.testRunId },
-      ...params.mocked && { mocked: true }
+      ...params.mocked && { mocked: true },
+      ...params.mockTarget && { mockTarget: params.mockTarget },
+      ...params.mockSource && { mockSource: params.mockSource }
     });
   }
   registerMockOverride(overrideOrMatch, value) {