@bitfab/sdk 0.36.11 → 0.36.13

package/dist/{chunk-VDFPZYLH.js → chunk-XAQJOZMJ.js}

@@ -16,7 +16,7 @@ import {
   toJsonSafe,
   toJsonSafeReport,
   warnOnce
-} from "./chunk-EKOAKLZC.js";
+} from "./chunk-VOUV7ZTS.js";
 
 // src/processorPayload.ts
 var SERIALIZATION_DEGRADED_STEP = "serialization_degraded";
@@ -2978,14 +2978,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.`
@@ -2993,7 +2998,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;
             })();
           };
@@ -3035,18 +3045,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) => {
@@ -3346,7 +3361,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) {
@@ -3371,7 +3388,7 @@ var Bitfab = class {
         `Function is wrapped with trace function key '${wrappedKey}' but replay was called with '${traceFunctionKey}'. Pass matching keys, or pass the unwrapped function to replay it under the explicit key.`
       );
     }
-    const { replay: doReplay } = await import("./replay-TW3ONJ3W.js");
+    const { replay: doReplay } = await import("./replay-WHZFV6OB.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -3609,4 +3626,4 @@ export {
   BitfabFunction,
   finalizers
 };
-//# sourceMappingURL=chunk-VDFPZYLH.js.map
+//# sourceMappingURL=chunk-XAQJOZMJ.js.map