bitfab 0.38.2 → 0.38.4

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

@@ -1,9 +1,11 @@
 import {
+  __bitfabAutoTraceActive,
   __setBitfabAutoTraceCapturePolicy,
   getAutoTraceCapturePolicy,
   runWithAutoTraceContext,
+  runWithAutoTraceNodeConfiguration,
   runWithAutoTraceRootContext
-} from "./chunk-GFBQ2AMO.js";
+} from "./chunk-J47KPS77.js";
 import {
   BitfabError,
   DEFAULT_SERVICE_URL,
@@ -16,7 +18,7 @@ import {
   toJsonSafe,
   toJsonSafeReport,
   warnOnce
-} from "./chunk-QWV7JDLQ.js";
+} from "./chunk-LHFNHB2J.js";
 import {
   __privateAdd,
   __privateGet,
@@ -2447,6 +2449,102 @@ var Bitfab = class {
     const name = fn.name !== "" ? fn.name : traceFunctionKey;
     return this.createAutoTraceRoot(traceFunctionKey, name, options, fn);
   }
+  /**
+   * Configure a transformed class method when it is discovered beneath a
+   * {@link Bitfab.trace} root.
+   *
+   * The decorator creates no span or trace by itself. Beneath an active trace,
+   * it can rename or retype the discovered call, capture its contents, mark it
+   * for recorded-output replay, finalize its output, or omit it while leaving
+   * captured descendants attached to the nearest captured parent.
+   *
+   * @param options - Trace-owned call configuration.
+   * @experimental Automatic child-call instrumentation is experimental.
+   */
+  node(options = {}) {
+    const configuration = this.resolveNodeConfiguration(options);
+    const decorator = (...args) => {
+      if (args.length === 3) {
+        const descriptor = args[2];
+        if (!descriptor || typeof descriptor.value !== "function") {
+          throw new BitfabError("@bitfab.node can only decorate methods");
+        }
+        if (!this.explicitlyEnabled) {
+          return;
+        }
+        descriptor.value = this.createAutoTraceNode(
+          configuration,
+          descriptor.value,
+          String(args[1])
+        );
+        return;
+      }
+      const method = args[0];
+      const context = args[1];
+      if (typeof method !== "function" || context?.kind !== "method") {
+        throw new BitfabError("@bitfab.node can only decorate methods");
+      }
+      if (!this.explicitlyEnabled) {
+        return method;
+      }
+      return this.createAutoTraceNode(
+        configuration,
+        method,
+        String(context.name)
+      );
+    };
+    return decorator;
+  }
+  withNode(optionsOrFn, maybeFn, internalFunctionName) {
+    const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+    const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+    if (!fn) {
+      throw new BitfabError("bitfab.withNode requires a function");
+    }
+    const configuration = this.resolveNodeConfiguration(options);
+    if (!this.explicitlyEnabled) {
+      return fn;
+    }
+    const functionName = internalFunctionName ?? fn.name;
+    if (functionName === "") {
+      throw new BitfabError(
+        "bitfab.withNode requires a named function so the subtree transform can bind its configuration to the correct call."
+      );
+    }
+    return this.createAutoTraceNode(configuration, fn, functionName);
+  }
+  resolveNodeConfiguration(options) {
+    const capture = options.capture ?? true;
+    if (!capture && options.mockOnReplay === true) {
+      throw new BitfabError(
+        "bitfab.node({ capture: false }) cannot use mockOnReplay: true because an uncaptured node has no recorded output."
+      );
+    }
+    return {
+      capture,
+      type: options.type ?? "custom",
+      ...options.name !== void 0 && { name: options.name },
+      ...options.testRunId !== void 0 && {
+        testRunId: options.testRunId
+      },
+      ...options.mockOnReplay !== void 0 && {
+        mockOnReplay: options.mockOnReplay
+      },
+      ...options.finalize !== void 0 && { finalize: options.finalize }
+    };
+  }
+  createAutoTraceNode(configuration, fn, functionName) {
+    const nodeConfiguration = { ...configuration, functionName };
+    return function(...args) {
+      if (!__bitfabAutoTraceActive()) {
+        return fn.apply(this, args);
+      }
+      return runWithAutoTraceNodeConfiguration(
+        nodeConfiguration,
+        () => fn.apply(this, args)
+      );
+    };
+  }
   createAutoTraceRoot(traceFunctionKey, name, options, fn) {
     const self = this;
     const maxDepth = autoTraceLimit(
@@ -2485,29 +2583,51 @@ var Bitfab = class {
           );
         };
         const autoTraceContext = {
-          invoke(definition, inputs, invokeFn, depth) {
+          invoke(definition, inputs, invokeFn, depth, nodeConfiguration) {
             const nameParts = definition.name.split(".");
             const simpleName = nameParts[nameParts.length - 1];
-            if (excluded.has(definition.name) || simpleName !== void 0 && excluded.has(simpleName) || definition.wrapper === true && !includeWrappers) {
-              return invokeFn();
+            const invokeWithoutNode = () => nodeConfiguration === void 0 ? invokeFn() : runWithAutoTraceContext(autoTraceContext, invokeFn, depth);
+            if (excluded.has(definition.name) || simpleName !== void 0 && excluded.has(simpleName) || nodeConfiguration === void 0 && definition.wrapper === true && !includeWrappers) {
+              return invokeWithoutNode();
+            }
+            if (nodeConfiguration?.capture === false) {
+              return runWithAutoTraceContext(autoTraceContext, invokeFn, depth);
             }
             if (depth >= maxDepth || spansUsed >= maxSpans) {
               warnTruncated();
-              return invokeFn();
+              return invokeWithoutNode();
             }
             spansUsed += 1;
             const childOptions = {
-              name: definition.name,
-              type: "function",
+              name: nodeConfiguration?.name ?? definition.name,
+              type: nodeConfiguration?.type ?? "function",
               captureWhen: "nested",
               functionId: definition.id,
-              captureContent: capturePolicy.has(definition.id),
-              autoTraceDefinition: definition
+              captureContent: nodeConfiguration !== void 0 || capturePolicy.has(definition.id),
+              autoTraceDefinition: definition,
+              ...nodeConfiguration?.testRunId !== void 0 && {
+                testRunId: nodeConfiguration.testRunId
+              },
+              ...nodeConfiguration?.mockOnReplay !== void 0 && {
+                mockOnReplay: nodeConfiguration.mockOnReplay
+              },
+              ...nodeConfiguration?.finalize !== void 0 && {
+                finalize: nodeConfiguration.finalize
+              }
             };
+            const invokeWithAutoTraceContext = () => runWithAutoTraceContext(autoTraceContext, invokeFn, depth + 1);
+            if (definition.async === true) {
+              const tracedAsyncChild = self.withSpan(
+                traceFunctionKey,
+                childOptions,
+                async (..._inputs) => await invokeWithAutoTraceContext()
+              );
+              return tracedAsyncChild(...inputs);
+            }
             const tracedChild = self.withSpan(
               traceFunctionKey,
               childOptions,
-              (..._inputs) => runWithAutoTraceContext(autoTraceContext, invokeFn, depth + 1)
+              (..._inputs) => invokeWithAutoTraceContext()
             );
             return tracedChild(...inputs);
           }
@@ -3077,18 +3197,17 @@ var Bitfab = class {
         newStack = [...currentStack, newContext];
         const inputs = args;
         const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const replayCtxAtStart = getReplayContext();
+        const testRunId = replayCtxAtStart?.testRunId ?? options.testRunId;
         if (isRootSpan && !activeTraceStates.has(traceId)) {
-          const replayCtxAtRoot = getReplayContext();
           const dbSnapshotRef = buildSnapshotRef(self.dbSnapshot, startedAt);
           activeTraceStates.set(traceId, {
             traceId,
             startedAt,
             contexts: [],
-            ...replayCtxAtRoot?.testRunId && {
-              testRunId: replayCtxAtRoot.testRunId
-            },
-            ...replayCtxAtRoot?.inputSourceTraceId && {
-              inputSourceTraceId: replayCtxAtRoot.inputSourceTraceId
+            ...testRunId !== void 0 && { testRunId },
+            ...replayCtxAtStart?.inputSourceTraceId && {
+              inputSourceTraceId: replayCtxAtStart.inputSourceTraceId
             },
             dbSnapshotRef
           });
@@ -3121,9 +3240,7 @@ var Bitfab = class {
                 contexts: newContext.contexts,
                 prompt: newContext.prompt,
                 endedAt,
-                ...replayCtx?.testRunId && {
-                  testRunId: replayCtx.testRunId
-                },
+                ...testRunId !== void 0 && { testRunId },
                 ...replayCtx?.inputSourceSpanId && {
                   inputSourceSpanId: replayCtx.inputSourceSpanId
                 }
@@ -3608,7 +3725,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-DDAYVRET.js");
+    const { replay: doReplay } = await import("./replay-BYW5MCLO.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -3832,6 +3949,11 @@ var finalizers = {
   readableStream
 };
 
+// src/replayRegistry.ts
+function defineReplayRegistry(registry) {
+  return registry;
+}
+
 export {
   BitfabClaudeAgentHandler,
   SUPPORTED_PROVIDERS,
@@ -3844,6 +3966,7 @@ export {
   getCurrentTrace,
   Bitfab,
   BitfabFunction,
-  finalizers
+  finalizers,
+  defineReplayRegistry
 };
-//# sourceMappingURL=chunk-JSU2Z2Z7.js.map
+//# sourceMappingURL=chunk-PXAL7PPD.js.map