bitfab 0.38.2 → 0.38.4

package/dist/index.cjs

@@ -51,7 +51,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.38.2";
+    __version__ = "0.38.4";
     __packageName__ = "bitfab";
   }
 });
@@ -2813,6 +2813,11 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       );
     }
   }
+  if (options?.traceIds !== void 0 && options?.datasetId !== void 0) {
+    throw new BitfabError(
+      "traceIds and datasetId select different replay sources and cannot be used together."
+    );
+  }
   if (options?.limit !== void 0 && options?.traceIds !== void 0) {
     try {
       console.warn(
@@ -3140,6 +3145,7 @@ __export(index_exports, {
   ReplayError: () => ReplayError,
   SUPPORTED_PROVIDERS: () => SUPPORTED_PROVIDERS,
   __version__: () => __version__,
+  defineReplayRegistry: () => defineReplayRegistry,
   finalizers: () => finalizers,
   flushTraces: () => flushTraces,
   getCurrentReplayBranch: () => getCurrentReplayBranch,
@@ -3791,6 +3797,29 @@ function runWithAutoTraceContext(context, fn, depth = 0) {
     autoTraceState.browserScope = previous;
   }
 }
+function runWithAutoTraceNodeConfiguration(nodeConfiguration, fn) {
+  const scope = currentAutoTraceScope();
+  if (!scope) {
+    return fn();
+  }
+  const configuredScope = { ...scope, nodeConfiguration };
+  let result;
+  if (autoTraceState.storage) {
+    result = autoTraceState.storage.run(configuredScope, fn);
+  } else {
+    const previous = autoTraceState.browserScope;
+    autoTraceState.browserScope = configuredScope;
+    try {
+      result = fn();
+    } finally {
+      autoTraceState.browserScope = previous;
+    }
+  }
+  if (isAutoTraceAsyncGenerator(result)) {
+    return wrapAutoTraceNodeAsyncGenerator(nodeConfiguration, result);
+  }
+  return result;
+}
 function runWithAutoTraceRootContext(context, fn) {
   autoTraceState.activeRoots += 1;
   let result;
@@ -3829,6 +3858,29 @@ function wrapAutoTraceAsyncGenerator(context, source) {
   };
   return wrapped;
 }
+function wrapAutoTraceNodeAsyncGenerator(nodeConfiguration, source) {
+  const step = (method, value) => runWithAutoTraceNodeConfiguration(
+    nodeConfiguration,
+    () => source[method](value)
+  );
+  const wrapped = {
+    next: (value) => step("next", value),
+    return: (value) => step("return", value),
+    throw: (error) => step("throw", error),
+    [Symbol.asyncIterator]: () => wrapped
+  };
+  return wrapped;
+}
+function __bitfabAutoTraceActive() {
+  if (autoTraceState.activeRoots === 0) {
+    return false;
+  }
+  return currentAutoTraceScope() !== void 0;
+}
+function currentAutoTraceScope() {
+  initializeAutoTraceStorage();
+  return autoTraceState.storage?.getStore() ?? autoTraceState.browserScope;
+}
 function __setBitfabAutoTraceCapturePolicy(client, traceFunctionKey, functionIds) {
   const policies = autoTraceState.capturePolicies.get(client) ?? /* @__PURE__ */ new Map();
   policies.set(traceFunctionKey, new Set(functionIds));
@@ -5681,6 +5733,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(
@@ -5719,29 +5867,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);
           }
@@ -6311,18 +6481,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
           });
@@ -6355,9 +6524,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
                 }
@@ -7072,6 +7239,13 @@ var finalizers = {
 // src/index.ts
 init_http();
 init_replay();
+
+// src/replayRegistry.ts
+init_errors();
+init_replay();
+function defineReplayRegistry(registry) {
+  return registry;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BITFAB_PROGRESS_PREFIX,
@@ -7090,6 +7264,7 @@ init_replay();
   ReplayError,
   SUPPORTED_PROVIDERS,
   __version__,
+  defineReplayRegistry,
   finalizers,
   flushTraces,
   getCurrentReplayBranch,