bitfab 0.61.0 → 0.61.1

package/dist/node.js

@@ -35,8 +35,8 @@ import {
   getCurrentTrace,
   reseedFromRegistry,
   seedFromRegistry
-} from "./chunk-O52C6BRF.js";
-import "./chunk-5DNB7EN7.js";
+} from "./chunk-ENHRFXCR.js";
+import "./chunk-BMJNDIVA.js";
 import {
   BITFAB_PROGRESS_PREFIX,
   DbBranchReplayError,
@@ -44,7 +44,7 @@ import {
   ReplayError,
   reportReplayProgress,
   serializeReplayResult
-} from "./chunk-6JQL37VC.js";
+} from "./chunk-VKGLQL7V.js";
 import {
   BitfabError,
   DEFAULT_SERVICE_URL,
@@ -52,7 +52,7 @@ import {
   MixedTracingError,
   __version__,
   flushTraces
-} from "./chunk-2M62EGYK.js";
+} from "./chunk-HKUHPLAM.js";
 import {
   assertAsyncStorageRegistered,
   registerAsyncLocalStorageClass

package/dist/{replay-XC2YOK4X.js → replay-KVENJRCX.js}

@@ -8,8 +8,8 @@ import {
   serializeReplayResult,
   sleepForReplayPersistence,
   waitForReplayPersistence
-} from "./chunk-6JQL37VC.js";
-import "./chunk-2M62EGYK.js";
+} from "./chunk-VKGLQL7V.js";
+import "./chunk-HKUHPLAM.js";
 import "./chunk-BAOIRE5T.js";
 export {
   BITFAB_PROGRESS_PREFIX,
@@ -22,4 +22,4 @@ export {
   sleepForReplayPersistence,
   waitForReplayPersistence
 };
-//# sourceMappingURL=replay-XC2YOK4X.js.map
+//# sourceMappingURL=replay-KVENJRCX.js.map

package/dist/replayCli.js

@@ -7,10 +7,10 @@ import {
   runRegistryMain,
   runReplayCli,
   runSeedCli
-} from "./chunk-J54ZR6NF.js";
+} from "./chunk-S4WE6U2Y.js";
 import {
   BitfabError
-} from "./chunk-3BTITSNA.js";
+} from "./chunk-I5J2FDKH.js";
 
 // src/cloudReplayCli.ts
 var CLOUD_REPLAY_HELP = "Direct GitHub replay: --cloud <pipeline> --trace-ids <UUIDs> [--registry <path>] [--max-concurrency 1..32] [--cloud-include <file>] [--cloud-dry-run] [--cloud-detach] [--cloud-request-id <UUID>]. Lifecycle: --cloud-status|--cloud-watch|--cloud-cancel|--cloud-cleanup <UUID>. Requires git, gh auth login, Python 3.10+, and bitfab:setup cloud.";

package/dist/seedCli.js

@@ -6,8 +6,8 @@ import {
   runIfEntrypoint,
   runRegistryMain,
   runSeedCli
-} from "./chunk-J54ZR6NF.js";
-import "./chunk-3BTITSNA.js";
+} from "./chunk-S4WE6U2Y.js";
+import "./chunk-I5J2FDKH.js";
 
 // src/seedCli.ts
 var USAGE = "Usage: bitfab-seed --registry <path> <pipeline> --from-trace <id>[,<id>...]\n       bitfab-seed --registry <path> <pipeline> --cases <cases.jsonl> [--run]\nRun bitfab-seed --registry <path> <pipeline> --help for details.";

package/dist/transform/babel.cjs

@@ -0,0 +1,418 @@
+"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);
+
+// ../bitfab-typescript-transform/src/babelPlugin.ts
+var babelPlugin_exports = {};
+__export(babelPlugin_exports, {
+  default: () => bitfabBabelPlugin
+});
+module.exports = __toCommonJS(babelPlugin_exports);
+
+// ../bitfab-typescript-transform/src/transformOptions.ts
+var AUTO_TRACE_FUNCTION_ID_VERSION = "ts-auto-v1";
+var AUTO_TRACE_TRANSFORM_MARKER = "__bitfab_auto_trace_transformed_v1__";
+function autoTraceFunctionId(file, name) {
+  return `${AUTO_TRACE_FUNCTION_ID_VERSION}:${file}#${name}`;
+}
+function shouldTransformBitfabFile(filename, options) {
+  if (!filename) {
+    return false;
+  }
+  if (options.include && !options.include(filename)) {
+    return false;
+  }
+  const normalized = filename.replace(/\\/g, "/").split(/[?#]/, 1)[0] ?? "";
+  const normalizedCwd = options.cwd?.replace(/\\/g, "/").replace(/\/$/, "");
+  const isAbsolute = normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized);
+  if (normalizedCwd && isAbsolute && normalized !== normalizedCwd && !normalized.startsWith(`${normalizedCwd}/`)) {
+    return false;
+  }
+  return !normalized.includes("/node_modules/") && !normalized.endsWith(".d.ts") && /\.[cm]?[jt]sx?$/.test(normalized);
+}
+
+// ../bitfab-typescript-transform/src/babelPlugin.ts
+function propertyName(node, types) {
+  if (types.isIdentifier(node)) {
+    return node.name;
+  }
+  if (types.isStringLiteral(node)) {
+    return node.value;
+  }
+  return null;
+}
+function functionName(path, types) {
+  const node = path.node;
+  if (types.isFunctionDeclaration(node) || types.isFunctionExpression(node)) {
+    if (node.id) {
+      return node.id.name;
+    }
+  }
+  if ((types.isClassMethod(node) || types.isObjectMethod(node)) && !node.computed) {
+    return propertyName(node.key, types) ?? "anonymous";
+  }
+  const parent = path.parentPath?.node;
+  if (types.isVariableDeclarator(parent)) {
+    return propertyName(parent.id, types) ?? "anonymous";
+  }
+  if (types.isObjectProperty(parent) && !parent.computed) {
+    return propertyName(parent.key, types) ?? "anonymous";
+  }
+  const line = node.loc?.start.line ?? 0;
+  const column = node.loc?.start.column ?? 0;
+  return `anonymous-${line}-${column}`;
+}
+function qualifiedFunctionName(path, types) {
+  const ownName = functionName(path, types);
+  const scopes = [];
+  let ancestor = path.parentPath;
+  while (ancestor) {
+    if (ancestor.isFunction()) {
+      const name = functionName(
+        ancestor,
+        types
+      );
+      if (!name.startsWith("anonymous-")) {
+        scopes.unshift(name);
+      }
+    } else if ((ancestor.isClassDeclaration() || ancestor.isClassExpression()) && ancestor.node.id) {
+      scopes.unshift(ancestor.node.id.name);
+    } else if (ancestor.isObjectExpression()) {
+      const parent = ancestor.parentPath?.node;
+      if (types.isVariableDeclarator(parent)) {
+        const name = propertyName(parent.id, types);
+        if (name) {
+          scopes.unshift(name);
+        }
+      } else if (types.isObjectProperty(parent) && !parent.computed) {
+        const name = propertyName(parent.key, types);
+        if (name) {
+          scopes.unshift(name);
+        }
+      }
+    }
+    ancestor = ancestor.parentPath;
+  }
+  return [...scopes, ownName].join(".");
+}
+function isTraceDecoratorRoot(path, types) {
+  const node = path.node;
+  if (!types.isClassMethod(node) && !types.isClassPrivateMethod(node)) {
+    return false;
+  }
+  return node.decorators?.some((decorator) => {
+    const expression = decorator.expression;
+    if (!types.isCallExpression(expression)) {
+      return false;
+    }
+    const callee = expression.callee;
+    return types.isMemberExpression(callee) && !callee.computed && types.isIdentifier(callee.property, { name: "trace" });
+  }) ?? false;
+}
+function isBitfabWrapperArgument(path, types) {
+  const parent = path.parentPath?.node;
+  if (!types.isCallExpression(parent)) {
+    return false;
+  }
+  if (!parent.arguments.some((argument) => argument === path.node)) {
+    return false;
+  }
+  const callee = parent.callee;
+  return types.isMemberExpression(callee) && !callee.computed && types.isIdentifier(callee.property) && (callee.property.name === "withTrace" || callee.property.name === "withSpan");
+}
+function withNodeFunctionName(path, types) {
+  if (path.node.arguments.length > 2) {
+    return null;
+  }
+  const callee = path.node.callee;
+  if (!types.isMemberExpression(callee) || callee.computed || !types.isIdentifier(callee.property, { name: "withNode" })) {
+    return null;
+  }
+  const fn = path.node.arguments[path.node.arguments.length - 1];
+  if (types.isIdentifier(fn)) {
+    return fn.name;
+  }
+  if (types.isMemberExpression(fn) && !fn.computed) {
+    return propertyName(fn.property, types);
+  }
+  if (types.isFunctionExpression(fn) && fn.id) {
+    return fn.id.name;
+  }
+  return null;
+}
+function functionBindingName(path, types) {
+  if (types.isFunctionDeclaration(path.node) && path.node.id) {
+    return path.node.id.name;
+  }
+  const parent = path.parentPath?.node;
+  if (types.isVariableDeclarator(parent) && types.isIdentifier(parent.id)) {
+    return parent.id.name;
+  }
+  return null;
+}
+function isBitfabWrappedFunction(path, types) {
+  if (isBitfabWrapperArgument(path, types)) {
+    return true;
+  }
+  const bindingName = functionBindingName(path, types);
+  if (!bindingName) {
+    return false;
+  }
+  const binding = path.scope.getBinding(bindingName);
+  return binding?.referencePaths.some(
+    (referencePath) => isBitfabWrapperArgument(referencePath, types)
+  ) ?? false;
+}
+function isBitfabManagedFunction(path, types) {
+  return isTraceDecoratorRoot(path, types) || isBitfabWrappedFunction(path, types);
+}
+function parameterInputs(path, types) {
+  const elements = [];
+  for (const [index, parameter] of (path.node.params ?? []).entries()) {
+    if (!types.isArrowFunctionExpression(path.node)) {
+      if (types.isRestElement(parameter)) {
+        elements.push(
+          types.spreadElement(
+            types.callExpression(
+              types.memberExpression(
+                types.arrayExpression([
+                  types.spreadElement(types.identifier("arguments"))
+                ]),
+                types.identifier("slice")
+              ),
+              [types.numericLiteral(index)]
+            )
+          )
+        );
+      } else {
+        elements.push(
+          types.memberExpression(
+            types.identifier("arguments"),
+            types.numericLiteral(index),
+            true
+          )
+        );
+      }
+      continue;
+    }
+    if (types.isIdentifier(parameter)) {
+      elements.push(types.identifier(parameter.name));
+    } else if (types.isRestElement(parameter) && types.isIdentifier(parameter.argument)) {
+      elements.push(
+        types.spreadElement(types.identifier(parameter.argument.name))
+      );
+    }
+  }
+  return types.arrayExpression(elements);
+}
+function needsArgumentWrapper(path, types) {
+  return types.isArrowFunctionExpression(path.node) && path.node.params.some(
+    (parameter) => !types.isIdentifier(parameter) && !(types.isRestElement(parameter) && types.isIdentifier(parameter.argument))
+  );
+}
+function isRestWrapper(path, types) {
+  return path.node.params.length === 1 && types.isRestElement(path.node.params[0]);
+}
+function bitfabBabelPlugin(api) {
+  const { types } = api;
+  return {
+    name: "bitfab-auto-trace",
+    visitor: {
+      Program: {
+        enter(path, state) {
+          const filename = state.file.opts.filename ?? "unknown";
+          state.skipFile = !shouldTransformBitfabFile(filename, state.opts) || path.scope.hasBinding(AUTO_TRACE_TRANSFORM_MARKER) || path.node.directives.some(
+            (directive) => directive.value.value === "use client"
+          );
+          state.runtimeIdentifier = path.scope.generateUidIdentifier("bitfabAutoSpan");
+          state.activeIdentifier = path.scope.generateUidIdentifier(
+            "bitfabAutoTraceActive"
+          );
+          state.wrapperIdentifier = path.scope.generateUidIdentifier("bitfabAutoWrap");
+          state.definitions = [];
+          state.usedRuntime = false;
+          state.usedWrapper = false;
+        },
+        exit(path, state) {
+          if (state.skipFile || !state.usedRuntime || !state.runtimeIdentifier || !state.activeIdentifier || !state.wrapperIdentifier) {
+            return;
+          }
+          path.unshiftContainer("body", [
+            types.importDeclaration(
+              [
+                types.importSpecifier(
+                  state.runtimeIdentifier,
+                  types.identifier("__bitfabAutoSpan")
+                ),
+                types.importSpecifier(
+                  state.activeIdentifier,
+                  types.identifier("__bitfabAutoTraceActive")
+                ),
+                ...state.usedWrapper ? [
+                  types.importSpecifier(
+                    state.wrapperIdentifier,
+                    types.identifier("__bitfabAutoWrap")
+                  )
+                ] : []
+              ],
+              types.stringLiteral(
+                state.opts.runtimeModule ?? "bitfab/auto"
+              )
+            ),
+            types.variableDeclaration("const", [
+              types.variableDeclarator(
+                types.identifier(AUTO_TRACE_TRANSFORM_MARKER),
+                types.assignmentExpression(
+                  "=",
+                  types.memberExpression(
+                    types.identifier("globalThis"),
+                    types.identifier(AUTO_TRACE_TRANSFORM_MARKER)
+                  ),
+                  types.booleanLiteral(true)
+                )
+              )
+            ]),
+            ...state.definitions ?? []
+          ]);
+        }
+      },
+      CallExpression: {
+        exit(path, state) {
+          if (state.skipFile) {
+            return;
+          }
+          const configuredName = withNodeFunctionName(path, types);
+          if (configuredName === null) {
+            return;
+          }
+          if (path.node.arguments.length === 1) {
+            path.node.arguments.push(types.identifier("undefined"));
+          }
+          path.node.arguments.push(types.stringLiteral(configuredName));
+        }
+      },
+      Function: {
+        exit(path, state) {
+          const node = path.node;
+          if (state.skipFile || node._bitfabInstrumented || node.generator || isBitfabManagedFunction(path, types) || !state.runtimeIdentifier || !state.activeIdentifier || !state.wrapperIdentifier) {
+            return;
+          }
+          if ((types.isClassMethod(node) || types.isObjectMethod(node)) && node.kind !== "method" || types.isClassPrivateMethod(node)) {
+            return;
+          }
+          const name = qualifiedFunctionName(path, types);
+          if (name.startsWith("anonymous-")) {
+            return;
+          }
+          const filename = state.file.opts.filename ?? "unknown";
+          const cwd = state.opts.cwd ?? state.file.opts.cwd ?? process.cwd();
+          const normalizedFilename = filename.replace(`${cwd}/`, "").replace(/\\/g, "/");
+          const line = node.loc?.start.line ?? 0;
+          const column = node.loc?.start.column ?? 0;
+          const definition = types.objectExpression([
+            types.objectProperty(
+              types.identifier("id"),
+              types.stringLiteral(
+                autoTraceFunctionId(normalizedFilename, name)
+              )
+            ),
+            types.objectProperty(
+              types.identifier("name"),
+              types.stringLiteral(name)
+            ),
+            types.objectProperty(
+              types.identifier("file"),
+              types.stringLiteral(normalizedFilename)
+            ),
+            types.objectProperty(
+              types.identifier("line"),
+              types.numericLiteral(line)
+            ),
+            types.objectProperty(
+              types.identifier("column"),
+              types.numericLiteral(column)
+            ),
+            ...node.async ? [
+              types.objectProperty(
+                types.identifier("async"),
+                types.booleanLiteral(true)
+              )
+            ] : [],
+            ...isRestWrapper(path, types) ? [
+              types.objectProperty(
+                types.identifier("wrapper"),
+                types.booleanLiteral(true)
+              )
+            ] : []
+          ]);
+          const definitionIdentifier = path.scope.getProgramParent().generateUidIdentifier("bitfabAutoDefinition");
+          state.definitions?.push(
+            types.variableDeclaration("const", [
+              types.variableDeclarator(definitionIdentifier, definition)
+            ])
+          );
+          if (needsArgumentWrapper(path, types)) {
+            const original = types.cloneNode(
+              node,
+              true
+            );
+            original._bitfabInstrumented = true;
+            path.replaceWith(
+              types.callExpression(state.wrapperIdentifier, [
+                definitionIdentifier,
+                original
+              ])
+            );
+            state.usedRuntime = true;
+            state.usedWrapper = true;
+            return;
+          }
+          const originalBody = types.isBlockStatement(node.body) ? node.body : types.blockStatement([types.returnStatement(node.body)]);
+          const directives = originalBody.directives;
+          originalBody.directives = [];
+          const body = types.blockStatement(
+            [
+              types.ifStatement(
+                types.callExpression(state.activeIdentifier, []),
+                types.blockStatement([
+                  types.returnStatement(
+                    types.callExpression(state.runtimeIdentifier, [
+                      definitionIdentifier,
+                      parameterInputs(path, types),
+                      types.arrowFunctionExpression(
+                        [],
+                        types.cloneNode(originalBody, true),
+                        node.async ?? false
+                      )
+                    ])
+                  )
+                ])
+              ),
+              ...originalBody.body
+            ],
+            directives
+          );
+          node.body = body;
+          node._bitfabInstrumented = true;
+          state.usedRuntime = true;
+        }
+      }
+    }
+  };
+}
+//# sourceMappingURL=babel.cjs.map

package/dist/transform/babel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../bitfab-typescript-transform/src/babelPlugin.ts","../../../bitfab-typescript-transform/src/transformOptions.ts"],"sourcesContent":["import type { NodePath, PluginObj, PluginPass } from \"@babel/core\"\nimport type * as BabelTypes from \"@babel/types\"\nimport type { BitfabTransformOptions } from \"./transformOptions.js\"\nimport {\n  AUTO_TRACE_TRANSFORM_MARKER,\n  autoTraceFunctionId,\n  shouldTransformBitfabFile,\n} from \"./transformOptions.js\"\n\ntype BabelTypesApi = typeof BabelTypes\n\ntype BitfabPluginOptions = BitfabTransformOptions\n\ninterface BitfabPluginState extends PluginPass {\n  opts: BitfabPluginOptions\n  runtimeIdentifier?: ReturnType<BabelTypesApi[\"identifier\"]>\n  activeIdentifier?: ReturnType<BabelTypesApi[\"identifier\"]>\n  wrapperIdentifier?: ReturnType<BabelTypesApi[\"identifier\"]>\n  definitions?: Array<ReturnType<BabelTypesApi[\"variableDeclaration\"]>>\n  skipFile?: boolean\n  usedRuntime?: boolean\n  usedWrapper?: boolean\n}\n\ninterface InstrumentedFunction {\n  _bitfabInstrumented?: boolean\n}\n\nfunction propertyName(\n  node: BabelTypes.Node | null | undefined,\n  types: BabelTypesApi,\n): string | null {\n  if (types.isIdentifier(node)) {\n    return node.name\n  }\n  if (types.isStringLiteral(node)) {\n    return node.value\n  }\n  return null\n}\n\nfunction functionName(\n  path: NodePath<BabelTypes.Function>,\n  types: BabelTypesApi,\n): string {\n  const node = path.node\n  if (types.isFunctionDeclaration(node) || types.isFunctionExpression(node)) {\n    if (node.id) {\n      return node.id.name\n    }\n  }\n\n  if (\n    (types.isClassMethod(node) || types.isObjectMethod(node)) &&\n    !node.computed\n  ) {\n    return propertyName(node.key, types) ?? \"anonymous\"\n  }\n\n  const parent = path.parentPath?.node\n  if (types.isVariableDeclarator(parent)) {\n    return propertyName(parent.id, types) ?? \"anonymous\"\n  }\n  if (types.isObjectProperty(parent) && !parent.computed) {\n    return propertyName(parent.key, types) ?? \"anonymous\"\n  }\n\n  const line = node.loc?.start.line ?? 0\n  const column = node.loc?.start.column ?? 0\n  return `anonymous-${line}-${column}`\n}\n\nfunction qualifiedFunctionName(\n  path: NodePath<BabelTypes.Function>,\n  types: BabelTypesApi,\n): string {\n  const ownName = functionName(path, types)\n  const scopes: string[] = []\n  let ancestor: NodePath | null = path.parentPath\n  while (ancestor) {\n    if (ancestor.isFunction()) {\n      const name = functionName(\n        ancestor as NodePath<BabelTypes.Function>,\n        types,\n      )\n      if (!name.startsWith(\"anonymous-\")) {\n        scopes.unshift(name)\n      }\n    } else if (\n      (ancestor.isClassDeclaration() || ancestor.isClassExpression()) &&\n      ancestor.node.id\n    ) {\n      scopes.unshift(ancestor.node.id.name)\n    } else if (ancestor.isObjectExpression()) {\n      const parent = ancestor.parentPath?.node\n      if (types.isVariableDeclarator(parent)) {\n        const name = propertyName(parent.id, types)\n        if (name) {\n          scopes.unshift(name)\n        }\n      } else if (types.isObjectProperty(parent) && !parent.computed) {\n        const name = propertyName(parent.key, types)\n        if (name) {\n          scopes.unshift(name)\n        }\n      }\n    }\n    ancestor = ancestor.parentPath\n  }\n  return [...scopes, ownName].join(\".\")\n}\n\nfunction isTraceDecoratorRoot(\n  path: NodePath<BabelTypes.Function>,\n  types: BabelTypesApi,\n): boolean {\n  const node = path.node\n  if (!types.isClassMethod(node) && !types.isClassPrivateMethod(node)) {\n    return false\n  }\n\n  return (\n    node.decorators?.some((decorator) => {\n      const expression = decorator.expression\n      if (!types.isCallExpression(expression)) {\n        return false\n      }\n      const callee = expression.callee\n      return (\n        types.isMemberExpression(callee) &&\n        !callee.computed &&\n        types.isIdentifier(callee.property, { name: \"trace\" })\n      )\n    }) ?? false\n  )\n}\n\nfunction isBitfabWrapperArgument(\n  path: NodePath,\n  types: BabelTypesApi,\n): boolean {\n  const parent = path.parentPath?.node\n  if (!types.isCallExpression(parent)) {\n    return false\n  }\n  if (!parent.arguments.some((argument) => argument === path.node)) {\n    return false\n  }\n\n  const callee = parent.callee\n  return (\n    types.isMemberExpression(callee) &&\n    !callee.computed &&\n    types.isIdentifier(callee.property) &&\n    (callee.property.name === \"withTrace\" ||\n      callee.property.name === \"withSpan\")\n  )\n}\n\nfunction withNodeFunctionName(\n  path: NodePath<BabelTypes.CallExpression>,\n  types: BabelTypesApi,\n): string | null {\n  if (path.node.arguments.length > 2) {\n    return null\n  }\n  const callee = path.node.callee\n  if (\n    !types.isMemberExpression(callee) ||\n    callee.computed ||\n    !types.isIdentifier(callee.property, { name: \"withNode\" })\n  ) {\n    return null\n  }\n  const fn = path.node.arguments[path.node.arguments.length - 1]\n  if (types.isIdentifier(fn)) {\n    return fn.name\n  }\n  if (types.isMemberExpression(fn) && !fn.computed) {\n    return propertyName(fn.property, types)\n  }\n  if (types.isFunctionExpression(fn) && fn.id) {\n    return fn.id.name\n  }\n  return null\n}\n\nfunction functionBindingName(\n  path: NodePath<BabelTypes.Function>,\n  types: BabelTypesApi,\n): string | null {\n  if (types.isFunctionDeclaration(path.node) && path.node.id) {\n    return path.node.id.name\n  }\n\n  const parent = path.parentPath?.node\n  if (types.isVariableDeclarator(parent) && types.isIdentifier(parent.id)) {\n    return parent.id.name\n  }\n  return null\n}\n\nfunction isBitfabWrappedFunction(\n  path: NodePath<BabelTypes.Function>,\n  types: BabelTypesApi,\n): boolean {\n  if (isBitfabWrapperArgument(path, types)) {\n    return true\n  }\n\n  const bindingName = functionBindingName(path, types)\n  if (!bindingName) {\n    return false\n  }\n  const binding = path.scope.getBinding(bindingName)\n  return (\n    binding?.referencePaths.some((referencePath) =>\n      isBitfabWrapperArgument(referencePath, types),\n    ) ?? false\n  )\n}\n\nfunction isBitfabManagedFunction(\n  path: NodePath<BabelTypes.Function>,\n  types: BabelTypesApi,\n): boolean {\n  return (\n    isTraceDecoratorRoot(path, types) || isBitfabWrappedFunction(path, types)\n  )\n}\n\nfunction parameterInputs(\n  path: NodePath<BabelTypes.Function>,\n  types: BabelTypesApi,\n): ReturnType<BabelTypesApi[\"arrayExpression\"]> {\n  const elements: Array<BabelTypes.Expression | BabelTypes.SpreadElement> = []\n\n  for (const [index, parameter] of (path.node.params ?? []).entries()) {\n    if (!types.isArrowFunctionExpression(path.node)) {\n      if (types.isRestElement(parameter)) {\n        elements.push(\n          types.spreadElement(\n            types.callExpression(\n              types.memberExpression(\n                types.arrayExpression([\n                  types.spreadElement(types.identifier(\"arguments\")),\n                ]),\n                types.identifier(\"slice\"),\n              ),\n              [types.numericLiteral(index)],\n            ),\n          ),\n        )\n      } else {\n        elements.push(\n          types.memberExpression(\n            types.identifier(\"arguments\"),\n            types.numericLiteral(index),\n            true,\n          ),\n        )\n      }\n      continue\n    }\n\n    if (types.isIdentifier(parameter)) {\n      elements.push(types.identifier(parameter.name))\n    } else if (\n      types.isRestElement(parameter) &&\n      types.isIdentifier(parameter.argument)\n    ) {\n      elements.push(\n        types.spreadElement(types.identifier(parameter.argument.name)),\n      )\n    }\n  }\n\n  return types.arrayExpression(elements)\n}\n\nfunction needsArgumentWrapper(\n  path: NodePath<BabelTypes.Function>,\n  types: BabelTypesApi,\n): boolean {\n  return (\n    types.isArrowFunctionExpression(path.node) &&\n    path.node.params.some(\n      (parameter) =>\n        !types.isIdentifier(parameter) &&\n        !(\n          types.isRestElement(parameter) &&\n          types.isIdentifier(parameter.argument)\n        ),\n    )\n  )\n}\n\nfunction isRestWrapper(\n  path: NodePath<BabelTypes.Function>,\n  types: BabelTypesApi,\n): boolean {\n  return (\n    path.node.params.length === 1 && types.isRestElement(path.node.params[0])\n  )\n}\n\n/**\n * Babel adapter for Bitfab's experimental automatic call-span runtime.\n *\n * @experimental The transform protocol and generated function identities may\n * change before the feature is stable.\n */\nexport default function bitfabBabelPlugin(api: {\n  types: BabelTypesApi\n}): PluginObj<BitfabPluginState> {\n  const { types } = api\n\n  return {\n    name: \"bitfab-auto-trace\",\n    visitor: {\n      Program: {\n        enter(path: NodePath<BabelTypes.Program>, state: BitfabPluginState) {\n          const filename = state.file.opts.filename ?? \"unknown\"\n          state.skipFile =\n            !shouldTransformBitfabFile(filename, state.opts) ||\n            path.scope.hasBinding(AUTO_TRACE_TRANSFORM_MARKER) ||\n            path.node.directives.some(\n              (directive) => directive.value.value === \"use client\",\n            )\n          state.runtimeIdentifier =\n            path.scope.generateUidIdentifier(\"bitfabAutoSpan\")\n          state.activeIdentifier = path.scope.generateUidIdentifier(\n            \"bitfabAutoTraceActive\",\n          )\n          state.wrapperIdentifier =\n            path.scope.generateUidIdentifier(\"bitfabAutoWrap\")\n          state.definitions = []\n          state.usedRuntime = false\n          state.usedWrapper = false\n        },\n        exit(path: NodePath<BabelTypes.Program>, state: BitfabPluginState) {\n          if (\n            state.skipFile ||\n            !state.usedRuntime ||\n            !state.runtimeIdentifier ||\n            !state.activeIdentifier ||\n            !state.wrapperIdentifier\n          ) {\n            return\n          }\n\n          path.unshiftContainer(\"body\", [\n            types.importDeclaration(\n              [\n                types.importSpecifier(\n                  state.runtimeIdentifier,\n                  types.identifier(\"__bitfabAutoSpan\"),\n                ),\n                types.importSpecifier(\n                  state.activeIdentifier,\n                  types.identifier(\"__bitfabAutoTraceActive\"),\n                ),\n                ...(state.usedWrapper\n                  ? [\n                      types.importSpecifier(\n                        state.wrapperIdentifier,\n                        types.identifier(\"__bitfabAutoWrap\"),\n                      ),\n                    ]\n                  : []),\n              ],\n              types.stringLiteral(\n                state.opts.runtimeModule ?? \"bitfab/auto\",\n              ),\n            ),\n            types.variableDeclaration(\"const\", [\n              types.variableDeclarator(\n                types.identifier(AUTO_TRACE_TRANSFORM_MARKER),\n                types.assignmentExpression(\n                  \"=\",\n                  types.memberExpression(\n                    types.identifier(\"globalThis\"),\n                    types.identifier(AUTO_TRACE_TRANSFORM_MARKER),\n                  ),\n                  types.booleanLiteral(true),\n                ),\n              ),\n            ]),\n            ...(state.definitions ?? []),\n          ])\n        },\n      },\n      CallExpression: {\n        exit(\n          path: NodePath<BabelTypes.CallExpression>,\n          state: BitfabPluginState,\n        ) {\n          if (state.skipFile) {\n            return\n          }\n          const configuredName = withNodeFunctionName(path, types)\n          if (configuredName === null) {\n            return\n          }\n          if (path.node.arguments.length === 1) {\n            path.node.arguments.push(types.identifier(\"undefined\"))\n          }\n          path.node.arguments.push(types.stringLiteral(configuredName))\n        },\n      },\n      Function: {\n        exit(path: NodePath<BabelTypes.Function>, state: BitfabPluginState) {\n          const node = path.node as typeof path.node & InstrumentedFunction\n          if (\n            state.skipFile ||\n            node._bitfabInstrumented ||\n            node.generator ||\n            isBitfabManagedFunction(path, types) ||\n            !state.runtimeIdentifier ||\n            !state.activeIdentifier ||\n            !state.wrapperIdentifier\n          ) {\n            return\n          }\n          if (\n            ((types.isClassMethod(node) || types.isObjectMethod(node)) &&\n              node.kind !== \"method\") ||\n            types.isClassPrivateMethod(node)\n          ) {\n            return\n          }\n\n          const name = qualifiedFunctionName(path, types)\n          if (name.startsWith(\"anonymous-\")) {\n            return\n          }\n          const filename = state.file.opts.filename ?? \"unknown\"\n          const cwd = state.opts.cwd ?? state.file.opts.cwd ?? process.cwd()\n          const normalizedFilename = filename\n            .replace(`${cwd}/`, \"\")\n            .replace(/\\\\/g, \"/\")\n          const line = node.loc?.start.line ?? 0\n          const column = node.loc?.start.column ?? 0\n          const definition = types.objectExpression([\n            types.objectProperty(\n              types.identifier(\"id\"),\n              types.stringLiteral(\n                autoTraceFunctionId(normalizedFilename, name),\n              ),\n            ),\n            types.objectProperty(\n              types.identifier(\"name\"),\n              types.stringLiteral(name),\n            ),\n            types.objectProperty(\n              types.identifier(\"file\"),\n              types.stringLiteral(normalizedFilename),\n            ),\n            types.objectProperty(\n              types.identifier(\"line\"),\n              types.numericLiteral(line),\n            ),\n            types.objectProperty(\n              types.identifier(\"column\"),\n              types.numericLiteral(column),\n            ),\n            ...(node.async\n              ? [\n                  types.objectProperty(\n                    types.identifier(\"async\"),\n                    types.booleanLiteral(true),\n                  ),\n                ]\n              : []),\n            ...(isRestWrapper(path, types)\n              ? [\n                  types.objectProperty(\n                    types.identifier(\"wrapper\"),\n                    types.booleanLiteral(true),\n                  ),\n                ]\n              : []),\n          ])\n          const definitionIdentifier = path.scope\n            .getProgramParent()\n            .generateUidIdentifier(\"bitfabAutoDefinition\")\n          state.definitions?.push(\n            types.variableDeclaration(\"const\", [\n              types.variableDeclarator(definitionIdentifier, definition),\n            ]),\n          )\n\n          if (needsArgumentWrapper(path, types)) {\n            const original = types.cloneNode(\n              node,\n              true,\n            ) as BabelTypes.ArrowFunctionExpression & InstrumentedFunction\n            original._bitfabInstrumented = true\n            path.replaceWith(\n              types.callExpression(state.wrapperIdentifier, [\n                definitionIdentifier,\n                original,\n              ]),\n            )\n            state.usedRuntime = true\n            state.usedWrapper = true\n            return\n          }\n\n          const originalBody = types.isBlockStatement(node.body)\n            ? node.body\n            : types.blockStatement([types.returnStatement(node.body)])\n          const directives = originalBody.directives\n          originalBody.directives = []\n\n          const body = types.blockStatement(\n            [\n              types.ifStatement(\n                types.callExpression(state.activeIdentifier, []),\n                types.blockStatement([\n                  types.returnStatement(\n                    types.callExpression(state.runtimeIdentifier, [\n                      definitionIdentifier,\n                      parameterInputs(path, types),\n                      types.arrowFunctionExpression(\n                        [],\n                        types.cloneNode(originalBody, true),\n                        node.async ?? false,\n                      ),\n                    ]),\n                  ),\n                ]),\n              ),\n              ...originalBody.body,\n            ],\n            directives,\n          )\n          node.body = body\n          node._bitfabInstrumented = true\n          state.usedRuntime = true\n        },\n      },\n    },\n  }\n}\n","export interface BitfabTransformOptions {\n  /** Module that exports the automatic span runtime. */\n  runtimeModule?: string\n  /** Working directory removed from generated function IDs. */\n  cwd?: string\n  /** Return false to leave a file unchanged. */\n  include?: (filename: string) => boolean\n}\n\nconst AUTO_TRACE_FUNCTION_ID_VERSION = \"ts-auto-v1\"\nexport const AUTO_TRACE_TRANSFORM_MARKER =\n  \"__bitfab_auto_trace_transformed_v1__\"\n\nexport function autoTraceFunctionId(file: string, name: string): string {\n  return `${AUTO_TRACE_FUNCTION_ID_VERSION}:${file}#${name}`\n}\n\nexport function shouldTransformBitfabFile(\n  filename: string,\n  options: BitfabTransformOptions,\n): boolean {\n  if (!filename) {\n    return false\n  }\n  if (options.include && !options.include(filename)) {\n    return false\n  }\n\n  const normalized = filename.replace(/\\\\/g, \"/\").split(/[?#]/, 1)[0] ?? \"\"\n  const normalizedCwd = options.cwd?.replace(/\\\\/g, \"/\").replace(/\\/$/, \"\")\n  const isAbsolute =\n    normalized.startsWith(\"/\") || /^[A-Za-z]:\\//.test(normalized)\n  if (\n    normalizedCwd &&\n    isAbsolute &&\n    normalized !== normalizedCwd &&\n    !normalized.startsWith(`${normalizedCwd}/`)\n  ) {\n    return false\n  }\n  return (\n    !normalized.includes(\"/node_modules/\") &&\n    !normalized.endsWith(\".d.ts\") &&\n    /\\.[cm]?[jt]sx?$/.test(normalized)\n  )\n}\n"],"mappings":"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","names":[]}

package/dist/transform/babel.d.cts

@@ -0,0 +1,27 @@
+import { PluginObj, PluginPass } from '@babel/core';
+import * as BabelTypes from '@babel/types';
+import { B as BitfabTransformOptions } from '../transformOptions-Df2_Chtc.cjs';
+
+type BabelTypesApi = typeof BabelTypes;
+type BitfabPluginOptions = BitfabTransformOptions;
+interface BitfabPluginState extends PluginPass {
+    opts: BitfabPluginOptions;
+    runtimeIdentifier?: ReturnType<BabelTypesApi["identifier"]>;
+    activeIdentifier?: ReturnType<BabelTypesApi["identifier"]>;
+    wrapperIdentifier?: ReturnType<BabelTypesApi["identifier"]>;
+    definitions?: Array<ReturnType<BabelTypesApi["variableDeclaration"]>>;
+    skipFile?: boolean;
+    usedRuntime?: boolean;
+    usedWrapper?: boolean;
+}
+/**
+ * Babel adapter for Bitfab's experimental automatic call-span runtime.
+ *
+ * @experimental The transform protocol and generated function identities may
+ * change before the feature is stable.
+ */
+declare function bitfabBabelPlugin(api: {
+    types: BabelTypesApi;
+}): PluginObj<BitfabPluginState>;
+
+export { bitfabBabelPlugin as default };

package/dist/transform/babel.d.ts

@@ -0,0 +1,27 @@
+import { PluginObj, PluginPass } from '@babel/core';
+import * as BabelTypes from '@babel/types';
+import { B as BitfabTransformOptions } from '../transformOptions-Df2_Chtc.js';
+
+type BabelTypesApi = typeof BabelTypes;
+type BitfabPluginOptions = BitfabTransformOptions;
+interface BitfabPluginState extends PluginPass {
+    opts: BitfabPluginOptions;
+    runtimeIdentifier?: ReturnType<BabelTypesApi["identifier"]>;
+    activeIdentifier?: ReturnType<BabelTypesApi["identifier"]>;
+    wrapperIdentifier?: ReturnType<BabelTypesApi["identifier"]>;
+    definitions?: Array<ReturnType<BabelTypesApi["variableDeclaration"]>>;
+    skipFile?: boolean;
+    usedRuntime?: boolean;
+    usedWrapper?: boolean;
+}
+/**
+ * Babel adapter for Bitfab's experimental automatic call-span runtime.
+ *
+ * @experimental The transform protocol and generated function identities may
+ * change before the feature is stable.
+ */
+declare function bitfabBabelPlugin(api: {
+    types: BabelTypesApi;
+}): PluginObj<BitfabPluginState>;
+
+export { bitfabBabelPlugin as default };