bitfab 0.38.4 → 0.38.6

package/dist/{chunk-PXAL7PPD.js → chunk-YCTQONNS.js}

@@ -5,11 +5,12 @@ import {
   runWithAutoTraceContext,
   runWithAutoTraceNodeConfiguration,
   runWithAutoTraceRootContext
-} from "./chunk-J47KPS77.js";
+} from "./chunk-ZUD7OFYB.js";
 import {
   BitfabError,
   DEFAULT_SERVICE_URL,
   HttpClient,
+  NO_MOCK_OVERRIDE,
   deserializeValue,
   getReplayContext,
   randomUuid,
@@ -18,7 +19,7 @@ import {
   toJsonSafe,
   toJsonSafeReport,
   warnOnce
-} from "./chunk-LHFNHB2J.js";
+} from "./chunk-O75EYGVO.js";
 import {
   __privateAdd,
   __privateGet,
@@ -2392,8 +2393,9 @@ var Bitfab = class {
    * Decorate a class method as an automatically expanded trace root.
    *
    * Build instrumentation turns repository functions called beneath this
-   * method into nested spans. Every generated span preserves structure; only
-   * function IDs selected by the capture policy include inputs and output.
+   * method into nested spans that capture inputs, outputs, and errors by
+   * default. A confirmed capture policy can narrow rich capture to selected
+   * function IDs.
    * Without a compatible build transform, this still records the decorated
    * method as a normal rich root span but cannot discover child calls.
    *
@@ -2603,7 +2605,7 @@ var Bitfab = class {
               type: nodeConfiguration?.type ?? "function",
               captureWhen: "nested",
               functionId: definition.id,
-              captureContent: nodeConfiguration !== void 0 || capturePolicy.has(definition.id),
+              captureContent: nodeConfiguration !== void 0 || capturePolicy === void 0 || capturePolicy.has(definition.id),
               autoTraceDefinition: definition,
               ...nodeConfiguration?.testRunId !== void 0 && {
                 testRunId: nodeConfiguration.testRunId
@@ -2668,7 +2670,11 @@ var Bitfab = class {
       const functionIds = Array.isArray(policy.functionIds) ? policy.functionIds.filter(
         (id) => typeof id === "string" && id.startsWith(`${AUTO_TRACE_PROTOCOL}:`)
       ).slice(0, DEFAULT_AUTO_TRACE_MAX_SPANS) : [];
-      __setBitfabAutoTraceCapturePolicy(this, traceFunctionKey, functionIds);
+      __setBitfabAutoTraceCapturePolicy(
+        this,
+        traceFunctionKey,
+        policy.revision === null ? void 0 : functionIds
+      );
       state.refreshAfter = Date.now() + AUTO_TRACE_POLICY_REFRESH_MS;
     }).catch(() => {
       state.refreshAfter = Date.now() + AUTO_TRACE_POLICY_RETRY_MS;
@@ -3280,6 +3286,49 @@ var Bitfab = class {
           } catch {
           }
         };
+        const recordSpan = (result) => {
+          if (options.finalize) {
+            void self.httpClient.trackDeferred(
+              Promise.resolve().then(() => options.finalize(result)).then((output) => sendSpan({ result: output })).catch(
+                (error) => sendSpan({
+                  result: void 0,
+                  error: error instanceof Error ? `finalize failed: ${error.message}` : `finalize failed: ${String(error)}`
+                })
+              )
+            );
+          } else {
+            void sendSpan({ result });
+          }
+        };
+        executeWithContext = () => {
+          let result;
+          try {
+            result = fn.apply(this, args);
+          } catch (error) {
+            void sendSpan({
+              result: void 0,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          }
+          if (result instanceof Promise) {
+            return result.then((resolvedResult) => {
+              recordSpan(resolvedResult);
+              return resolvedResult;
+            }).catch((error) => {
+              void sendSpan({
+                result: void 0,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              throw error;
+            });
+          }
+          if (isAsyncGenerator(result)) {
+            return wrapAsyncGenerator(result, newStack, sendSpan);
+          }
+          recordSpan(result);
+          return result;
+        };
         const replayCtxForMock = getReplayContext();
         if (replayCtxForMock?.mockTree && !isRootSpan) {
           const counters = replayCtxForMock.callCounters;
@@ -3338,6 +3387,7 @@ var Bitfab = class {
             }
             return output;
           };
+          const shouldMockWithBaseStrategy = replayCtxForMock.mockStrategy === "all" || replayCtxForMock.mockStrategy === "marked" && options.mockOnReplay === true;
           if (replayCtxForMock.mockOverrides?.length) {
             const nodeMeta = {
               traceFunctionKey,
@@ -3345,28 +3395,75 @@ var Bitfab = class {
               type: options.type ?? "custom",
               originalSpanId: mockSpan?.sourceSpanId
             };
-            const override = replayCtxForMock.mockOverrides.find(
-              (o) => o.match(nodeMeta)
-            );
-            if (override) {
-              const injected = resolveMockValue(override.value, {
-                node: nodeMeta,
-                inputs: args,
-                getOriginalOutput: () => Promise.resolve(resolveRecordedOutput())
-              });
-              if (injected instanceof Promise) {
-                return emitMockAsync(injected, "override");
+            const overrideCtx = {
+              node: nodeMeta,
+              inputs: args,
+              getOriginalOutput: () => Promise.resolve(resolveRecordedOutput())
+            };
+            const resolveOverrideFrom = (startIndex) => {
+              for (let index = startIndex; index < replayCtxForMock.mockOverrides.length; index += 1) {
+                const override = replayCtxForMock.mockOverrides[index];
+                if (!override?.match(nodeMeta)) {
+                  continue;
+                }
+                const injected = resolveMockValue(override.value, overrideCtx);
+                if (injected instanceof Promise) {
+                  return injected.then(
+                    (output) => output === NO_MOCK_OVERRIDE ? resolveOverrideFrom(index + 1) : { matched: true, output }
+                  );
+                }
+                if (injected !== NO_MOCK_OVERRIDE) {
+                  return { matched: true, output: injected };
+                }
+              }
+              return { matched: false };
+            };
+            const resolution = resolveOverrideFrom(0);
+            if (resolution instanceof Promise) {
+              if (!fnReturnsPromise) {
+                throw new BitfabError(
+                  `Cannot resolve an asynchronous mock override for synchronous span "${traceFunctionKey}". Make the wrapped function async or return NO_MOCK_OVERRIDE synchronously.`
+                );
               }
-              return emitMock(injected, "override");
+              return runWithSpanStack(newStack, async () => {
+                const resolved = await resolution;
+                if (resolved.matched) {
+                  void sendSpan({
+                    result: resolved.output,
+                    mocked: true,
+                    mockTarget: "output",
+                    mockSource: "override"
+                  });
+                  return resolved.output;
+                }
+                if (shouldMockWithBaseStrategy && !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 (shouldMockWithBaseStrategy) {
+                  const output = await resolveRecordedOutput();
+                  void sendSpan({
+                    result: output,
+                    mocked: true,
+                    mockTarget: "output",
+                    mockSource: "recorded"
+                  });
+                  return output;
+                }
+                return executeWithContext();
+              });
+            }
+            if (resolution.matched) {
+              return emitMock(resolution.output, "override");
             }
           }
-          const shouldMock = replayCtxForMock.mockStrategy === "all" || replayCtxForMock.mockStrategy === "marked" && options.mockOnReplay === true;
-          if (shouldMock && !mockSpan) {
+          if (shouldMockWithBaseStrategy && !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) {
+          if (shouldMockWithBaseStrategy) {
             const recorded = resolveRecordedOutput();
             if (recorded instanceof Promise) {
               return emitMockAsync(recorded, "recorded");
@@ -3374,49 +3471,6 @@ var Bitfab = class {
             return emitMock(recorded, "recorded");
           }
         }
-        const recordSpan = (result) => {
-          if (options.finalize) {
-            void self.httpClient.trackDeferred(
-              Promise.resolve().then(() => options.finalize(result)).then((output) => sendSpan({ result: output })).catch(
-                (error) => sendSpan({
-                  result: void 0,
-                  error: error instanceof Error ? `finalize failed: ${error.message}` : `finalize failed: ${String(error)}`
-                })
-              )
-            );
-          } else {
-            void sendSpan({ result });
-          }
-        };
-        executeWithContext = () => {
-          let result;
-          try {
-            result = fn.apply(this, args);
-          } catch (error) {
-            void sendSpan({
-              result: void 0,
-              error: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-          }
-          if (result instanceof Promise) {
-            return result.then((resolvedResult) => {
-              recordSpan(resolvedResult);
-              return resolvedResult;
-            }).catch((error) => {
-              void sendSpan({
-                result: void 0,
-                error: error instanceof Error ? error.message : String(error)
-              });
-              throw error;
-            });
-          }
-          if (isAsyncGenerator(result)) {
-            return wrapAsyncGenerator(result, newStack, sendSpan);
-          }
-          recordSpan(result);
-          return result;
-        };
       } catch (setupError) {
         if (registeredTraceId) {
           activeTraceStates.delete(registeredTraceId);
@@ -3703,8 +3757,40 @@ var Bitfab = class {
       ...params.mockSource && { mockSource: params.mockSource }
     });
   }
-  registerMockOverride(overrideOrMatch, value) {
-    const override = typeof overrideOrMatch === "function" ? { match: overrideOrMatch, value } : overrideOrMatch;
+  registerMockOverride(overrideOrResolverOrMatch, ...values) {
+    let override;
+    if (typeof overrideOrResolverOrMatch === "string") {
+      const keyedOverride = values[0];
+      if (values.length !== 1 || keyedOverride === void 0) {
+        throw new BitfabError(
+          "registerMockOverride(traceFunctionKey, override) requires a resolver function or { match, value } override."
+        );
+      }
+      if (typeof keyedOverride === "function") {
+        override = {
+          match: (node) => node.traceFunctionKey === overrideOrResolverOrMatch,
+          value: keyedOverride
+        };
+      } else if (typeof keyedOverride === "object" && keyedOverride !== null && "match" in keyedOverride && "value" in keyedOverride) {
+        override = {
+          match: (node) => node.traceFunctionKey === overrideOrResolverOrMatch && keyedOverride.match(node),
+          value: keyedOverride.value
+        };
+      } else {
+        throw new BitfabError(
+          "registerMockOverride(traceFunctionKey, override) requires a resolver function or { match, value } override."
+        );
+      }
+    } else if (typeof overrideOrResolverOrMatch !== "function") {
+      override = overrideOrResolverOrMatch;
+    } else if (values.length === 0) {
+      override = { match: () => true, value: overrideOrResolverOrMatch };
+    } else {
+      override = {
+        match: overrideOrResolverOrMatch,
+        value: values[0]
+      };
+    }
     this.mockOverrides.push(override);
   }
   /** Remove all overrides registered via {@link registerMockOverride}. */
@@ -3725,7 +3811,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-BYW5MCLO.js");
+    const { replay: doReplay } = await import("./replay-K3UMQAKO.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -3969,4 +4055,4 @@ export {
   finalizers,
   defineReplayRegistry
 };
-//# sourceMappingURL=chunk-PXAL7PPD.js.map
+//# sourceMappingURL=chunk-YCTQONNS.js.map