@bitfab/sdk 0.65.4 → 0.65.6

package/dist/autoTrace.cjs

@@ -1,354 +1,16 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/autoTrace.ts
-var autoTrace_exports = {};
-__export(autoTrace_exports, {
-  __bitfabAutoSpan: () => __bitfabAutoSpan,
-  __bitfabAutoTraceActive: () => __bitfabAutoTraceActive,
-  __bitfabAutoWrap: () => __bitfabAutoWrap,
-  _resetAutoTraceTransformDetection: () => _resetAutoTraceTransformDetection,
-  clearAutoTraceNodeConfiguration: () => clearAutoTraceNodeConfiguration,
-  currentAutoTraceEntries: () => currentAutoTraceEntries,
-  invokeThroughAutoTraceEntries: () => invokeThroughAutoTraceEntries,
-  runAsAutoTraceRootFunction: () => runAsAutoTraceRootFunction,
-  runWithAutoTraceEntry: () => runWithAutoTraceEntry,
-  runWithAutoTraceNodeConfiguration: () => runWithAutoTraceNodeConfiguration,
-  runWithAutoTraceRootContext: () => runWithAutoTraceRootContext
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
 });
-module.exports = __toCommonJS(autoTrace_exports);
-
-// src/asyncStorage.ts
-var AsyncLocalStorageClass = null;
-var initDone = false;
-function registerAsyncLocalStorageClass(cls) {
-  if (!AsyncLocalStorageClass) {
-    AsyncLocalStorageClass = cls;
-  }
-  initDone = true;
-}
-var asyncStorageReady = (typeof process !== "undefined" && process.versions?.node ? (
-  // The join trick hides "node:async_hooks" from static analysis so
-  // bundlers that ban Node.js built-ins don't fail at build time.
-  // webpackIgnore tells webpack/turbopack to emit a native import()
-  // so Node.js can resolve the module at runtime.
-  import(
-    /* webpackIgnore: true */
-    ["node", "async_hooks"].join(":")
-  ).then(
-    (mod) => {
-      registerAsyncLocalStorageClass(mod.AsyncLocalStorage);
-    }
-  ).catch(() => {
-  })
-) : Promise.resolve()).then(() => {
-  initDone = true;
-});
-function createAsyncLocalStorage() {
-  return AsyncLocalStorageClass ? new AsyncLocalStorageClass() : null;
-}
-
-// src/captureSuppression.ts
-var suppressionGlobal = globalThis;
-var suppressionState = suppressionGlobal.__bitfabCaptureSuppressionV1 ?? { depth: 0 };
-suppressionGlobal.__bitfabCaptureSuppressionV1 = suppressionState;
-function isCaptureSuppressed() {
-  return suppressionState.depth > 0;
-}
-
-// src/warnOnce.ts
-var warned = /* @__PURE__ */ new Set();
-function warn(message) {
-  try {
-    console.warn(`[bitfab] ${message}`);
-  } catch {
-  }
-}
-function warnOnce(key, message) {
-  if (warned.has(key)) {
-    return;
-  }
-  warned.add(key);
-  warn(message);
-}
-
-// src/autoTrace.ts
-var autoTraceGlobal = globalThis;
-var autoTraceState = autoTraceGlobal.__bitfabAutoTraceStateV4 ?? {
-  storage: null,
-  browserScope: void 0,
-  capturePolicies: /* @__PURE__ */ new WeakMap(),
-  activeRoots: 0
-};
-autoTraceGlobal.__bitfabAutoTraceStateV4 = autoTraceState;
-function initializeAutoTraceStorage() {
-  autoTraceState.storage ?? (autoTraceState.storage = createAsyncLocalStorage());
-}
-function runWithAutoTraceScope(scope, fn) {
-  initializeAutoTraceStorage();
-  if (autoTraceState.storage) {
-    return autoTraceState.storage.run(scope, fn);
-  }
-  const previous = autoTraceState.browserScope;
-  autoTraceState.browserScope = scope;
-  try {
-    return fn();
-  } finally {
-    autoTraceState.browserScope = previous;
-  }
-}
-function currentAutoTraceEntries() {
-  return currentAutoTraceScope()?.entries ?? [];
-}
-function replaceEntry(entries, previous, updated) {
-  return entries.map((entry) => entry === previous ? updated : entry);
-}
-function runWithAutoTraceEntry(previous, updated, fn) {
-  const result = runWithAutoTraceScope(
-    { entries: replaceEntry(currentAutoTraceEntries(), previous, updated) },
-    fn
-  );
-  if (isAutoTraceAsyncGenerator(result)) {
-    return wrapAutoTraceEntryAsyncGenerator(previous, updated, result);
-  }
-  return result;
-}
-function wrapAutoTraceEntryAsyncGenerator(previous, updated, source) {
-  const step = (method, value) => runWithAutoTraceScope(
-    { entries: replaceEntry(currentAutoTraceEntries(), previous, updated) },
-    () => 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 clearAutoTraceNodeConfiguration(fn) {
-  return runWithAutoTraceScope({ entries: currentAutoTraceEntries() }, fn);
-}
-function runWithAutoTraceNodeConfiguration(nodeConfiguration, fn) {
-  const scope = currentAutoTraceScope();
-  if (!scope || scope.entries.length === 0) {
-    return fn();
-  }
-  const result = runWithAutoTraceScope({ ...scope, nodeConfiguration }, fn);
-  if (isAutoTraceAsyncGenerator(result)) {
-    return wrapAutoTraceNodeAsyncGenerator(nodeConfiguration, result);
-  }
-  return result;
-}
-function runAsAutoTraceRootFunction(functionName, fn) {
-  const scope = currentAutoTraceScope();
-  if (!scope || scope.entries.length === 0 || functionName === "") {
-    return fn();
-  }
-  const rootFunction = {
-    name: functionName,
-    entering: true
-  };
-  try {
-    return runWithAutoTraceScope({ ...scope, rootFunction }, fn);
-  } finally {
-    rootFunction.entering = false;
-  }
-}
-function isRootFunctionEntry(scope, simpleName) {
-  const rootFunction = scope.rootFunction;
-  if (rootFunction === void 0 || !rootFunction.entering) {
-    return false;
-  }
-  rootFunction.entering = false;
-  return rootFunction.name === simpleName;
-}
-var SUBTREE_TRACING_DOCS_URL = "https://docs.bitfab.ai/typescript-sdk#experimental-subtree-tracing";
-function noteTransformedModule() {
-  autoTraceGlobal.__bitfab_auto_trace_transformed_v1__ = true;
-}
-function transformInstalled() {
-  return autoTraceGlobal.__bitfab_auto_trace_transformed_v1__ === true;
-}
-function runsOnNode() {
-  return typeof process !== "undefined" && Boolean(process.versions?.node);
-}
-function closeAutoTraceRoot() {
-  autoTraceState.activeRoots -= 1;
-}
-function settleAutoTraceRoot(context) {
-  closeAutoTraceRoot();
-  if (transformInstalled() || !runsOnNode()) {
-    return;
-  }
-  warnOnce(
-    "auto-trace-transform-missing",
-    `trace root "${context.traceFunctionKey}" recorded only its own span. No module in this build was compiled by @bitfab/sdk/transform, so calls beneath the root were not discovered. Add the SDK's transform adapter to the server build: ${SUBTREE_TRACING_DOCS_URL}`
-  );
-}
-function runWithAutoTraceRootContext(context, spanStack, fn) {
-  autoTraceState.activeRoots += 1;
-  const entries = [
-    ...currentAutoTraceEntries(),
-    { context, depth: 0, spanStack }
-  ];
-  let result;
-  try {
-    result = runWithAutoTraceScope({ entries }, fn);
-  } catch (error) {
-    settleAutoTraceRoot(context);
-    throw error;
-  }
-  if (isAutoTraceAsyncGenerator(result)) {
-    closeAutoTraceRoot();
-    return wrapAutoTraceAsyncGenerator(context, spanStack, result);
-  }
-  if (result instanceof Promise) {
-    return result.finally(() => {
-      settleAutoTraceRoot(context);
-    });
-  }
-  settleAutoTraceRoot(context);
-  return result;
-}
-function invokeThroughAutoTraceEntries(entries, step, fn) {
-  let run = fn;
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const entry = entries[index];
-    const next = run;
-    run = () => step(entry, next);
-  }
-  return run();
-}
-function isAutoTraceAsyncGenerator(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.next === "function" && typeof candidate.return === "function" && typeof candidate.throw === "function" && typeof candidate[Symbol.asyncIterator] === "function";
-}
-function wrapAutoTraceAsyncGenerator(context, spanStack, source) {
-  const step = (method, value) => runWithAutoTraceRootContext(context, spanStack, () => 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 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 shareFinalize(configuration) {
-  const finalize = configuration.finalize;
-  if (finalize === void 0) {
-    return configuration;
-  }
-  let settled;
-  return {
-    ...configuration,
-    finalize: (result) => {
-      settled ?? (settled = Promise.resolve().then(() => finalize(result)));
-      return settled;
-    }
-  };
-}
-function __bitfabAutoSpan(definition, inputs, fn) {
-  noteTransformedModule();
-  const scope = currentAutoTraceScope();
-  if (!scope || scope.entries.length === 0 || isCaptureSuppressed()) {
-    return fn();
-  }
-  const nameParts = definition.name.split(".");
-  const simpleName = nameParts[nameParts.length - 1];
-  if (isRootFunctionEntry(scope, simpleName)) {
-    return fn();
-  }
-  const nodeConfiguration = simpleName === scope.nodeConfiguration?.functionName ? shareFinalize(scope.nodeConfiguration) : void 0;
-  return invokeThroughAutoTraceEntries(
-    scope.entries,
-    (entry, next) => entry.context.invoke(definition, inputs, next, entry, nodeConfiguration),
-    fn
-  );
-}
-function __bitfabAutoWrap(definition, fn) {
-  noteTransformedModule();
-  if (fn.name === "") {
-    const nameParts = definition.name.split(".");
-    const inferredName = nameParts[nameParts.length - 1];
-    if (inferredName !== void 0) {
-      Object.defineProperty(fn, "name", {
-        configurable: true,
-        value: inferredName
-      });
-    }
-  }
-  const target = fn;
-  return new Proxy(target, {
-    apply(callTarget, thisArg, args) {
-      if (!__bitfabAutoTraceActive()) {
-        return Reflect.apply(callTarget, thisArg, args);
-      }
-      return __bitfabAutoSpan(
-        definition,
-        args,
-        () => Reflect.apply(callTarget, thisArg, args)
-      );
-    }
-  });
-}
-function __bitfabAutoTraceActive() {
-  if (autoTraceState.activeRoots === 0 || isCaptureSuppressed()) {
-    return false;
-  }
-  return currentAutoTraceEntries().length > 0;
-}
-function currentAutoTraceScope() {
-  initializeAutoTraceStorage();
-  return autoTraceState.storage?.getStore() ?? autoTraceState.browserScope;
-}
-function _resetAutoTraceTransformDetection() {
-  autoTraceGlobal.__bitfab_auto_trace_transformed_v1__ = void 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  __bitfabAutoSpan,
-  __bitfabAutoTraceActive,
-  __bitfabAutoWrap,
-  _resetAutoTraceTransformDetection,
-  clearAutoTraceNodeConfiguration,
-  currentAutoTraceEntries,
-  invokeThroughAutoTraceEntries,
-  runAsAutoTraceRootFunction,
-  runWithAutoTraceEntry,
-  runWithAutoTraceNodeConfiguration,
-  runWithAutoTraceRootContext
-});
-//# sourceMappingURL=autoTrace.cjs.map
+const require_autoTrace = require("./autoTrace-CQw0qMBt.cjs");
+exports.__bitfabAutoSpan = require_autoTrace.__bitfabAutoSpan;
+exports.__bitfabAutoTraceActive = require_autoTrace.__bitfabAutoTraceActive;
+exports.__bitfabAutoWrap = require_autoTrace.__bitfabAutoWrap;
+exports._resetAutoTraceTransformDetection = require_autoTrace._resetAutoTraceTransformDetection;
+exports.clearAutoTraceNodeConfiguration = require_autoTrace.clearAutoTraceNodeConfiguration;
+exports.currentAutoTraceEntries = require_autoTrace.currentAutoTraceEntries;
+exports.invokeThroughAutoTraceEntries = require_autoTrace.invokeThroughAutoTraceEntries;
+exports.runAsAutoTraceRootFunction = require_autoTrace.runAsAutoTraceRootFunction;
+exports.runWithAutoTraceEntry = require_autoTrace.runWithAutoTraceEntry;
+exports.runWithAutoTraceNodeConfiguration = require_autoTrace.runWithAutoTraceNodeConfiguration;
+exports.runWithAutoTraceRootContext = require_autoTrace.runWithAutoTraceRootContext;

package/dist/autoTrace.d.cts

@@ -1,47 +1,52 @@
-interface AutoTraceFunctionDefinition {
-    id: string;
-    name: string;
-    file: string;
-    line: number;
-    column: number;
-    async?: boolean;
-    wrapper?: boolean;
+//#region src/autoTrace.d.ts
+export interface AutoTraceFunctionDefinition {
+  id: string;
+  name: string;
+  file: string;
+  line: number;
+  column: number;
+  async?: boolean;
+  wrapper?: boolean;
 }
-interface AutoTraceNodeConfiguration {
-    functionName: string;
-    name?: string;
-    type?: "llm" | "agent" | "function" | "guardrail" | "handoff" | "custom";
-    capture: boolean;
-    experimentId?: string;
-    /** @deprecated Use experimentId. */
-    testRunId?: string;
-    mockOnReplay?: boolean;
-    replayReusable?: boolean;
-    finalize?: (result: any) => unknown | Promise<unknown>;
+export interface AutoTraceNodeConfiguration {
+  functionName: string;
+  name?: string;
+  type?: "llm" | "agent" | "function" | "guardrail" | "handoff" | "custom";
+  capture: boolean;
+  experimentId?: string;
+  /** @deprecated Use experimentId. */
+  testRunId?: string;
+  mockOnReplay?: boolean;
+  replayReusable?: boolean;
+  finalize?: (result: any) => unknown | Promise<unknown>;
 }
-interface NestedTraceLink {
-    traceFunctionKey: string;
-    traceId?: string;
-    rootSpanId?: string;
+export interface NestedTraceLink {
+  traceFunctionKey: string;
+  traceId?: string;
+  rootSpanId?: string;
 }
-interface AutoTraceEntry {
-    context: AutoTraceContext;
-    depth: number;
-    spanStack: unknown;
+export interface SpanDetails {
+  contexts: Record<string, unknown>[];
+  prompt?: string;
 }
-interface AutoTraceContext {
-    readonly traceFunctionKey: string;
-    invoke<T>(definition: AutoTraceFunctionDefinition, inputs: unknown[], fn: () => T, entry: AutoTraceEntry, nodeConfiguration?: AutoTraceNodeConfiguration): T;
-    invokeNestedRoot<T>(name: string, functionName: string, inputs: unknown[], fn: () => T, entry: AutoTraceEntry, link: NestedTraceLink | undefined): T;
+export interface AutoTraceEntry {
+  context: AutoTraceContext;
+  depth: number;
+  spanStack: unknown;
 }
-declare function currentAutoTraceEntries(): readonly AutoTraceEntry[];
-declare function runWithAutoTraceEntry<T>(previous: AutoTraceEntry, updated: AutoTraceEntry, fn: () => T): T;
-declare function clearAutoTraceNodeConfiguration<T>(fn: () => T): T;
-declare function runWithAutoTraceNodeConfiguration<T>(nodeConfiguration: AutoTraceNodeConfiguration, fn: () => T): T;
-declare function runAsAutoTraceRootFunction<T>(functionName: string, fn: () => T): T;
-declare function runWithAutoTraceRootContext<T>(context: AutoTraceContext, spanStack: unknown, fn: () => T): T;
-declare function invokeThroughAutoTraceEntries<T>(entries: readonly AutoTraceEntry[], step: (entry: AutoTraceEntry, next: () => T) => T, fn: () => T): T;
-declare function __bitfabAutoSpan<T>(definition: AutoTraceFunctionDefinition, inputs: unknown[], fn: () => T): T;
+export interface AutoTraceContext {
+  readonly traceFunctionKey: string;
+  invoke<T>(definition: AutoTraceFunctionDefinition, inputs: unknown[], fn: () => T, entry: AutoTraceEntry, spanDetails: SpanDetails, nodeConfiguration?: AutoTraceNodeConfiguration): T;
+  invokeNestedRoot<T>(name: string, functionName: string, inputs: unknown[], fn: () => T, entry: AutoTraceEntry, link: NestedTraceLink | undefined, spanDetails: SpanDetails): T;
+}
+export declare function currentAutoTraceEntries(): readonly AutoTraceEntry[];
+export declare function runWithAutoTraceEntry<T>(previous: AutoTraceEntry, updated: AutoTraceEntry, fn: () => T): T;
+export declare function clearAutoTraceNodeConfiguration<T>(fn: () => T): T;
+export declare function runWithAutoTraceNodeConfiguration<T>(nodeConfiguration: AutoTraceNodeConfiguration, fn: () => T): T;
+export declare function runAsAutoTraceRootFunction<T>(functionName: string, fn: () => T): T;
+export declare function runWithAutoTraceRootContext<T>(context: AutoTraceContext, spanStack: unknown, fn: () => T): T;
+export declare function invokeThroughAutoTraceEntries<T>(entries: readonly AutoTraceEntry[], step: (entry: AutoTraceEntry, next: () => T) => T, fn: () => T): T;
+export declare function __bitfabAutoSpan<T>(definition: AutoTraceFunctionDefinition, inputs: unknown[], fn: () => T): T;
 /**
  * Preserve a function's original call arguments for transform cases where
  * parameter bindings discard them, such as destructured arrow parameters.
@@ -52,7 +57,7 @@ declare function __bitfabAutoSpan<T>(definition: AutoTraceFunctionDefinition, in
  *
  * @experimental The automatic tracing protocol may change.
  */
-declare function __bitfabAutoWrap<T extends (...args: never[]) => unknown>(definition: AutoTraceFunctionDefinition, fn: T): T;
+export declare function __bitfabAutoWrap<T extends (...args: never[]) => unknown>(definition: AutoTraceFunctionDefinition, fn: T): T;
 /**
  * Return whether the current call is inside an automatic trace root.
  *
@@ -62,7 +67,6 @@ declare function __bitfabAutoWrap<T extends (...args: never[]) => unknown>(defin
  *
  * @experimental The automatic tracing protocol may change.
  */
-declare function __bitfabAutoTraceActive(): boolean;
-declare function _resetAutoTraceTransformDetection(): void;
-
-export { type AutoTraceContext, type AutoTraceEntry, type AutoTraceFunctionDefinition, type AutoTraceNodeConfiguration, type NestedTraceLink, __bitfabAutoSpan, __bitfabAutoTraceActive, __bitfabAutoWrap, _resetAutoTraceTransformDetection, clearAutoTraceNodeConfiguration, currentAutoTraceEntries, invokeThroughAutoTraceEntries, runAsAutoTraceRootFunction, runWithAutoTraceEntry, runWithAutoTraceNodeConfiguration, runWithAutoTraceRootContext };
+export declare function __bitfabAutoTraceActive(): boolean;
+export declare function _resetAutoTraceTransformDetection(): void;
+//#endregion

package/dist/autoTrace.d.ts

@@ -1,47 +1,52 @@
-interface AutoTraceFunctionDefinition {
-    id: string;
-    name: string;
-    file: string;
-    line: number;
-    column: number;
-    async?: boolean;
-    wrapper?: boolean;
+//#region src/autoTrace.d.ts
+export interface AutoTraceFunctionDefinition {
+  id: string;
+  name: string;
+  file: string;
+  line: number;
+  column: number;
+  async?: boolean;
+  wrapper?: boolean;
 }
-interface AutoTraceNodeConfiguration {
-    functionName: string;
-    name?: string;
-    type?: "llm" | "agent" | "function" | "guardrail" | "handoff" | "custom";
-    capture: boolean;
-    experimentId?: string;
-    /** @deprecated Use experimentId. */
-    testRunId?: string;
-    mockOnReplay?: boolean;
-    replayReusable?: boolean;
-    finalize?: (result: any) => unknown | Promise<unknown>;
+export interface AutoTraceNodeConfiguration {
+  functionName: string;
+  name?: string;
+  type?: "llm" | "agent" | "function" | "guardrail" | "handoff" | "custom";
+  capture: boolean;
+  experimentId?: string;
+  /** @deprecated Use experimentId. */
+  testRunId?: string;
+  mockOnReplay?: boolean;
+  replayReusable?: boolean;
+  finalize?: (result: any) => unknown | Promise<unknown>;
 }
-interface NestedTraceLink {
-    traceFunctionKey: string;
-    traceId?: string;
-    rootSpanId?: string;
+export interface NestedTraceLink {
+  traceFunctionKey: string;
+  traceId?: string;
+  rootSpanId?: string;
 }
-interface AutoTraceEntry {
-    context: AutoTraceContext;
-    depth: number;
-    spanStack: unknown;
+export interface SpanDetails {
+  contexts: Record<string, unknown>[];
+  prompt?: string;
 }
-interface AutoTraceContext {
-    readonly traceFunctionKey: string;
-    invoke<T>(definition: AutoTraceFunctionDefinition, inputs: unknown[], fn: () => T, entry: AutoTraceEntry, nodeConfiguration?: AutoTraceNodeConfiguration): T;
-    invokeNestedRoot<T>(name: string, functionName: string, inputs: unknown[], fn: () => T, entry: AutoTraceEntry, link: NestedTraceLink | undefined): T;
+export interface AutoTraceEntry {
+  context: AutoTraceContext;
+  depth: number;
+  spanStack: unknown;
 }
-declare function currentAutoTraceEntries(): readonly AutoTraceEntry[];
-declare function runWithAutoTraceEntry<T>(previous: AutoTraceEntry, updated: AutoTraceEntry, fn: () => T): T;
-declare function clearAutoTraceNodeConfiguration<T>(fn: () => T): T;
-declare function runWithAutoTraceNodeConfiguration<T>(nodeConfiguration: AutoTraceNodeConfiguration, fn: () => T): T;
-declare function runAsAutoTraceRootFunction<T>(functionName: string, fn: () => T): T;
-declare function runWithAutoTraceRootContext<T>(context: AutoTraceContext, spanStack: unknown, fn: () => T): T;
-declare function invokeThroughAutoTraceEntries<T>(entries: readonly AutoTraceEntry[], step: (entry: AutoTraceEntry, next: () => T) => T, fn: () => T): T;
-declare function __bitfabAutoSpan<T>(definition: AutoTraceFunctionDefinition, inputs: unknown[], fn: () => T): T;
+export interface AutoTraceContext {
+  readonly traceFunctionKey: string;
+  invoke<T>(definition: AutoTraceFunctionDefinition, inputs: unknown[], fn: () => T, entry: AutoTraceEntry, spanDetails: SpanDetails, nodeConfiguration?: AutoTraceNodeConfiguration): T;
+  invokeNestedRoot<T>(name: string, functionName: string, inputs: unknown[], fn: () => T, entry: AutoTraceEntry, link: NestedTraceLink | undefined, spanDetails: SpanDetails): T;
+}
+export declare function currentAutoTraceEntries(): readonly AutoTraceEntry[];
+export declare function runWithAutoTraceEntry<T>(previous: AutoTraceEntry, updated: AutoTraceEntry, fn: () => T): T;
+export declare function clearAutoTraceNodeConfiguration<T>(fn: () => T): T;
+export declare function runWithAutoTraceNodeConfiguration<T>(nodeConfiguration: AutoTraceNodeConfiguration, fn: () => T): T;
+export declare function runAsAutoTraceRootFunction<T>(functionName: string, fn: () => T): T;
+export declare function runWithAutoTraceRootContext<T>(context: AutoTraceContext, spanStack: unknown, fn: () => T): T;
+export declare function invokeThroughAutoTraceEntries<T>(entries: readonly AutoTraceEntry[], step: (entry: AutoTraceEntry, next: () => T) => T, fn: () => T): T;
+export declare function __bitfabAutoSpan<T>(definition: AutoTraceFunctionDefinition, inputs: unknown[], fn: () => T): T;
 /**
  * Preserve a function's original call arguments for transform cases where
  * parameter bindings discard them, such as destructured arrow parameters.
@@ -52,7 +57,7 @@ declare function __bitfabAutoSpan<T>(definition: AutoTraceFunctionDefinition, in
  *
  * @experimental The automatic tracing protocol may change.
  */
-declare function __bitfabAutoWrap<T extends (...args: never[]) => unknown>(definition: AutoTraceFunctionDefinition, fn: T): T;
+export declare function __bitfabAutoWrap<T extends (...args: never[]) => unknown>(definition: AutoTraceFunctionDefinition, fn: T): T;
 /**
  * Return whether the current call is inside an automatic trace root.
  *
@@ -62,7 +67,6 @@ declare function __bitfabAutoWrap<T extends (...args: never[]) => unknown>(defin
  *
  * @experimental The automatic tracing protocol may change.
  */
-declare function __bitfabAutoTraceActive(): boolean;
-declare function _resetAutoTraceTransformDetection(): void;
-
-export { type AutoTraceContext, type AutoTraceEntry, type AutoTraceFunctionDefinition, type AutoTraceNodeConfiguration, type NestedTraceLink, __bitfabAutoSpan, __bitfabAutoTraceActive, __bitfabAutoWrap, _resetAutoTraceTransformDetection, clearAutoTraceNodeConfiguration, currentAutoTraceEntries, invokeThroughAutoTraceEntries, runAsAutoTraceRootFunction, runWithAutoTraceEntry, runWithAutoTraceNodeConfiguration, runWithAutoTraceRootContext };
+export declare function __bitfabAutoTraceActive(): boolean;
+export declare function _resetAutoTraceTransformDetection(): void;
+//#endregion

package/dist/autoTrace.js

@@ -1,28 +1 @@
-import {
-  __bitfabAutoSpan,
-  __bitfabAutoTraceActive,
-  __bitfabAutoWrap,
-  _resetAutoTraceTransformDetection,
-  clearAutoTraceNodeConfiguration,
-  currentAutoTraceEntries,
-  invokeThroughAutoTraceEntries,
-  runAsAutoTraceRootFunction,
-  runWithAutoTraceEntry,
-  runWithAutoTraceNodeConfiguration,
-  runWithAutoTraceRootContext
-} from "./chunk-QRNHRY7F.js";
-import "./chunk-MT36GJMW.js";
-export {
-  __bitfabAutoSpan,
-  __bitfabAutoTraceActive,
-  __bitfabAutoWrap,
-  _resetAutoTraceTransformDetection,
-  clearAutoTraceNodeConfiguration,
-  currentAutoTraceEntries,
-  invokeThroughAutoTraceEntries,
-  runAsAutoTraceRootFunction,
-  runWithAutoTraceEntry,
-  runWithAutoTraceNodeConfiguration,
-  runWithAutoTraceRootContext
-};
-//# sourceMappingURL=autoTrace.js.map
+export { t as __bitfabAutoSpan, n as __bitfabAutoTraceActive, r as __bitfabAutoWrap, i as _resetAutoTraceTransformDetection, a as clearAutoTraceNodeConfiguration, o as currentAutoTraceEntries, s as invokeThroughAutoTraceEntries, c as runAsAutoTraceRootFunction, l as runWithAutoTraceEntry, u as runWithAutoTraceNodeConfiguration, d as runWithAutoTraceRootContext } from "./autoTrace-O40k8f5M.js";