@bitfab/sdk 0.64.23 → 0.64.25

package/dist/transform/swc.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../bitfab-typescript-transform/src/swcAdapter.ts
@@ -35,8 +25,8 @@ __export(swcAdapter_exports, {
 });
 module.exports = __toCommonJS(swcAdapter_exports);
 
-// ../bitfab-typescript-transform/src/typescriptTransformer.ts
-var import_typescript = __toESM(require("typescript"), 1);
+// ../bitfab-typescript-transform/src/transform.ts
+var import_core = require("@babel/core");
 
 // ../bitfab-typescript-transform/src/transformOptions.ts
 var AUTO_TRACE_FUNCTION_ID_VERSION = "ts-auto-v1";
@@ -44,6 +34,14 @@ var AUTO_TRACE_TRANSFORM_MARKER = "__bitfab_auto_trace_transformed_v1__";
 function autoTraceFunctionId(file, name) {
   return `${AUTO_TRACE_FUNCTION_ID_VERSION}:${file}#${name}`;
 }
+function sourceFilename(filename) {
+  return filename.replace(/\\/g, "/").split(/[?#]/, 1)[0] ?? "";
+}
+function autoTraceFilename(filename, cwd) {
+  const normalized = sourceFilename(filename);
+  const normalizedCwd = cwd.replace(/\\/g, "/").replace(/\/$/, "");
+  return normalized.startsWith(`${normalizedCwd}/`) ? normalized.slice(normalizedCwd.length + 1) : normalized;
+}
 function shouldTransformBitfabFile(filename, options) {
   if (!filename) {
     return false;
@@ -51,7 +49,7 @@ function shouldTransformBitfabFile(filename, options) {
   if (options.include && !options.include(filename)) {
     return false;
   }
-  const normalized = filename.replace(/\\/g, "/").split(/[?#]/, 1)[0] ?? "";
+  const normalized = sourceFilename(filename);
   const normalizedCwd = options.cwd?.replace(/\\/g, "/").replace(/\/$/, "");
   const isAbsolute = normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized);
   if (normalizedCwd && isAbsolute && normalized !== normalizedCwd && !normalized.startsWith(`${normalizedCwd}/`)) {
@@ -60,529 +58,462 @@ function shouldTransformBitfabFile(filename, options) {
   return !normalized.includes("/node_modules/") && !normalized.endsWith(".d.ts") && /\.[cm]?[jt]sx?$/.test(normalized);
 }
 
-// ../bitfab-typescript-transform/src/typescriptTransformer.ts
-function hasUseClientDirective(sourceFile) {
-  return sourceFile.statements.some(
-    (statement) => import_typescript.default.isExpressionStatement(statement) && import_typescript.default.isStringLiteral(statement.expression) && statement.expression.text === "use client"
-  );
-}
-function hasTransformMarker(sourceFile) {
-  return sourceFile.statements.some(
-    (statement) => import_typescript.default.isVariableStatement(statement) && statement.declarationList.declarations.some(
-      (declaration) => import_typescript.default.isIdentifier(declaration.name) && declaration.name.text === AUTO_TRACE_TRANSFORM_MARKER
-    )
-  );
-}
-function isBitfabMemberCall(node, memberName) {
-  return import_typescript.default.isCallExpression(node) && import_typescript.default.isPropertyAccessExpression(node.expression) && node.expression.name.text === memberName;
+// ../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 withNodeFunctionName(node) {
-  if (!isBitfabMemberCall(node, "withNode") || node.arguments.length > 2) {
-    return null;
+function functionName(path, types) {
+  const node = path.node;
+  if (types.isFunctionDeclaration(node) || types.isFunctionExpression(node)) {
+    if (node.id) {
+      return node.id.name;
+    }
   }
-  const fn = node.arguments[node.arguments.length - 1];
-  if (import_typescript.default.isIdentifier(fn)) {
-    return fn.text;
+  if ((types.isClassMethod(node) || types.isObjectMethod(node)) && !node.computed && types.isIdentifier(node.key)) {
+    return node.key.name;
   }
-  if (import_typescript.default.isPropertyAccessExpression(fn)) {
-    return fn.name.text;
+  const parent = path.parentPath?.node;
+  if (types.isVariableDeclarator(parent)) {
+    return propertyName(parent.id, types) ?? "anonymous";
   }
-  if (import_typescript.default.isFunctionExpression(fn) && fn.name) {
-    return fn.name.text;
+  if (types.isObjectProperty(parent) && !parent.computed) {
+    return propertyName(parent.key, types) ?? "anonymous";
   }
-  return null;
+  const { line, column } = sourcePosition(path);
+  return `anonymous-${line}-${column}`;
 }
-function traceDecorators(node) {
-  if (!import_typescript.default.canHaveDecorators(node)) {
-    return [];
+function isInstrumentableFunction(node, types) {
+  if (node.generator || types.isClassPrivateMethod(node)) {
+    return false;
   }
-  return import_typescript.default.getDecorators(node) ?? [];
+  return !(types.isClassMethod(node) || types.isObjectMethod(node)) || node.kind === "method";
 }
-function isTraceDecoratorRoot(node) {
-  return traceDecorators(node).some(
-    (decorator) => isBitfabMemberCall(decorator.expression, "trace")
-  );
+function sourcePosition(path) {
+  const exportDeclaration = path.parentPath?.isExportDeclaration() ? path.parentPath.node : void 0;
+  const start = (exportDeclaration ?? path.node).loc?.start;
+  return { line: start?.line ?? 0, column: start?.column ?? 0 };
 }
-function collectBitfabWrappedFunctions(sourceFile) {
-  const inlineRoots = /* @__PURE__ */ new Set();
-  const referencedRoots = /* @__PURE__ */ new Set();
-  function visit(node) {
-    if (isBitfabMemberCall(node, "withTrace") || isBitfabMemberCall(node, "withSpan")) {
-      const fn = node.arguments[node.arguments.length - 1];
-      if (fn && (import_typescript.default.isArrowFunction(fn) || import_typescript.default.isFunctionExpression(fn))) {
-        inlineRoots.add(fn);
-      } else if (fn && import_typescript.default.isIdentifier(fn)) {
-        referencedRoots.add(fn.text);
+function qualifiedFunctionName(path, types) {
+  const ownName = functionName(path, types);
+  if (ownName.startsWith("anonymous-")) {
+    return ownName;
+  }
+  const scopes = [];
+  let ancestor = path.parentPath;
+  while (ancestor) {
+    if (ancestor.isFunction()) {
+      if (!isInstrumentableFunction(ancestor.node, types)) {
+        ancestor = ancestor.parentPath;
+        continue;
+      }
+      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);
+        }
       }
     }
-    import_typescript.default.forEachChild(node, visit);
+    ancestor = ancestor.parentPath;
   }
-  visit(sourceFile);
-  return { inlineRoots, referencedRoots };
+  return [...scopes, ownName].join(".");
 }
-function declaredFunctionName(node) {
-  if (node.name && import_typescript.default.isIdentifier(node.name)) {
-    return node.name.text;
+function isTraceDecoratorRoot(path, types) {
+  const node = path.node;
+  if (!types.isClassMethod(node) && !types.isClassPrivateMethod(node)) {
+    return false;
   }
-  if ((import_typescript.default.isArrowFunction(node) || import_typescript.default.isFunctionExpression(node)) && import_typescript.default.isVariableDeclaration(node.parent) && import_typescript.default.isIdentifier(node.parent.name)) {
-    return node.parent.name.text;
+  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 ((import_typescript.default.isArrowFunction(node) || import_typescript.default.isFunctionExpression(node)) && import_typescript.default.isPropertyAssignment(node.parent) && (import_typescript.default.isIdentifier(node.parent.name) || import_typescript.default.isStringLiteral(node.parent.name))) {
-    return node.parent.name.text;
+  if (!parent.arguments.some((argument) => argument === path.node)) {
+    return false;
   }
-  return null;
+  const callee = parent.callee;
+  return types.isMemberExpression(callee) && !callee.computed && types.isIdentifier(callee.property) && (callee.property.name === "withTrace" || callee.property.name === "withSpan");
 }
-function objectContainerName(node) {
-  if (import_typescript.default.isVariableDeclaration(node.parent) && import_typescript.default.isIdentifier(node.parent.name)) {
-    return node.parent.name.text;
+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 (import_typescript.default.isPropertyAssignment(node.parent) && (import_typescript.default.isIdentifier(node.parent.name) || import_typescript.default.isStringLiteral(node.parent.name))) {
-    return node.parent.name.text;
+  if (types.isFunctionExpression(fn) && fn.id) {
+    return fn.id.name;
   }
   return null;
 }
-function functionName(node) {
-  const ownName = declaredFunctionName(node);
-  if (ownName) {
-    const scopes = [];
-    let ancestor = node.parent;
-    while (ancestor) {
-      if (isInstrumentableFunction(ancestor)) {
-        const name = declaredFunctionName(ancestor);
-        if (name) {
-          scopes.unshift(name);
-        }
-      } else if ((import_typescript.default.isClassDeclaration(ancestor) || import_typescript.default.isClassExpression(ancestor)) && ancestor.name) {
-        scopes.unshift(ancestor.name.text);
-      } else if (import_typescript.default.isObjectLiteralExpression(ancestor)) {
-        const name = objectContainerName(ancestor);
-        if (name) {
-          scopes.unshift(name);
-        }
-      }
-      ancestor = ancestor.parent;
-    }
-    return [...scopes, ownName].join(".");
+function functionBindingName(path, types) {
+  if (types.isFunctionDeclaration(path.node) && path.node.id) {
+    return path.node.id.name;
   }
-  const sourceFile = node.getSourceFile();
-  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-  return `anonymous-${position.line + 1}-${position.character}`;
+  const parent = path.parentPath?.node;
+  if (types.isVariableDeclarator(parent) && types.isIdentifier(parent.id)) {
+    return parent.id.name;
+  }
+  return null;
 }
-function isBitfabWrappedFunction(node, inlineRoots, referencedRoots) {
-  if (inlineRoots.has(node)) {
+function isBitfabWrappedFunction(path, types) {
+  if (isBitfabWrapperArgument(path, types)) {
     return true;
   }
-  const name = declaredFunctionName(node);
-  return name !== null && referencedRoots.has(name);
-}
-function isInstrumentableFunction(node) {
-  if (!import_typescript.default.isFunctionDeclaration(node) && !import_typescript.default.isFunctionExpression(node) && !import_typescript.default.isArrowFunction(node) && !import_typescript.default.isMethodDeclaration(node)) {
+  const bindingName = functionBindingName(path, types);
+  if (!bindingName) {
     return false;
   }
-  return node.body !== void 0 && node.asteriskToken === void 0 && (!node.name || !import_typescript.default.isPrivateIdentifier(node.name));
+  const binding = path.scope.getBinding(bindingName);
+  return binding?.referencePaths.some(
+    (referencePath) => isBitfabWrapperArgument(referencePath, types)
+  ) ?? false;
 }
-function normalizedFilename(filename, cwd) {
-  const normalized = filename.replace(/\\/g, "/").split(/[?#]/, 1)[0] ?? "";
-  const normalizedCwd = cwd.replace(/\\/g, "/").replace(/\/$/, "");
-  return normalized.startsWith(`${normalizedCwd}/`) ? normalized.slice(normalizedCwd.length + 1) : normalized;
+function isBitfabManagedFunction(path, types) {
+  return isTraceDecoratorRoot(path, types) || isBitfabWrappedFunction(path, types);
 }
-function parameterInputs(factory, node) {
-  return factory.createArrayLiteralExpression(
-    node.parameters.map((parameter, index) => {
-      if (!import_typescript.default.isArrowFunction(node)) {
-        if (parameter.dotDotDotToken) {
-          return factory.createSpreadElement(
-            factory.createCallExpression(
-              factory.createPropertyAccessExpression(
-                factory.createArrayLiteralExpression([
-                  factory.createSpreadElement(
-                    factory.createIdentifier("arguments")
-                  )
+function runtimeParameters(node, types) {
+  return node.params.filter(
+    (parameter) => !types.isIdentifier(parameter, { name: "this" })
+  );
+}
+function parameterInputs(path, types) {
+  const elements = [];
+  for (const [index, parameter] of runtimeParameters(
+    path.node,
+    types
+  ).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"))
                 ]),
-                "slice"
+                types.identifier("slice")
               ),
-              void 0,
-              [factory.createNumericLiteral(index)]
+              [types.numericLiteral(index)]
             )
-          );
-        }
-        return factory.createElementAccessExpression(
-          factory.createIdentifier("arguments"),
-          factory.createNumericLiteral(index)
+          )
+        );
+      } else {
+        elements.push(
+          types.memberExpression(
+            types.identifier("arguments"),
+            types.numericLiteral(index),
+            true
+          )
         );
       }
-      if (import_typescript.default.isIdentifier(parameter.name)) {
-        const identifier = factory.createIdentifier(parameter.name.text);
-        return parameter.dotDotDotToken ? factory.createSpreadElement(identifier) : identifier;
-      }
-      throw new Error(
-        "Bitfab transform invariant: arrow parameter requires argument wrapper"
+      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(node) {
-  return import_typescript.default.isArrowFunction(node) && node.parameters.some(
-    (parameter) => !import_typescript.default.isIdentifier(parameter.name) || parameter.initializer !== void 0
+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(node) {
-  return node.parameters.length === 1 && node.parameters[0]?.dotDotDotToken !== void 0;
+function isRestWrapper(path, types) {
+  const parameters = runtimeParameters(path.node, types);
+  return parameters.length === 1 && types.isRestElement(parameters[0]);
 }
-function splitDirectivePrologue(body) {
-  const firstNonDirective = body.statements.findIndex(
-    (statement) => !(import_typescript.default.isExpressionStatement(statement) && import_typescript.default.isStringLiteral(statement.expression))
-  );
-  if (firstNonDirective === -1) {
-    return { directives: body.statements, statements: [] };
-  }
+function bitfabBabelPlugin(api) {
+  const { types } = api;
   return {
-    directives: body.statements.slice(0, firstNonDirective),
-    statements: body.statements.slice(firstNonDirective)
-  };
-}
-function updateFunctionBody(factory, node, body) {
-  if (import_typescript.default.isFunctionDeclaration(node)) {
-    return factory.updateFunctionDeclaration(
-      node,
-      node.modifiers,
-      node.asteriskToken,
-      node.name,
-      node.typeParameters,
-      node.parameters,
-      node.type,
-      body
-    );
-  }
-  if (import_typescript.default.isFunctionExpression(node)) {
-    return factory.updateFunctionExpression(
-      node,
-      node.modifiers,
-      node.asteriskToken,
-      node.name,
-      node.typeParameters,
-      node.parameters,
-      node.type,
-      body
-    );
-  }
-  if (import_typescript.default.isArrowFunction(node)) {
-    return factory.updateArrowFunction(
-      node,
-      node.modifiers,
-      node.typeParameters,
-      node.parameters,
-      node.type,
-      node.equalsGreaterThanToken,
-      body
-    );
-  }
-  if (import_typescript.default.isMethodDeclaration(node)) {
-    return factory.updateMethodDeclaration(
-      node,
-      node.modifiers,
-      node.asteriskToken,
-      node.name,
-      node.questionToken,
-      node.typeParameters,
-      node.parameters,
-      node.type,
-      body
-    );
-  }
-  return node;
-}
-function createBitfabTypeScriptTransformer(options = {}) {
-  return (context) => (sourceFile) => {
-    if (hasUseClientDirective(sourceFile) || hasTransformMarker(sourceFile) || !shouldTransformBitfabFile(sourceFile.fileName, options)) {
-      return sourceFile;
-    }
-    const { factory } = context;
-    const { inlineRoots, referencedRoots } = collectBitfabWrappedFunctions(sourceFile);
-    const runtimeIdentifier = factory.createUniqueName("bitfabAutoSpan");
-    const activeIdentifier = factory.createUniqueName("bitfabAutoTraceActive");
-    const wrapperIdentifier = factory.createUniqueName("bitfabAutoWrap");
-    const transformedNodes = /* @__PURE__ */ new Set();
-    const definitions = [];
-    let usedRuntime = false;
-    let usedWrapper = false;
-    const cwd = options.cwd ?? process.cwd();
-    const file = normalizedFilename(sourceFile.fileName, cwd);
-    const visitor = (node) => {
-      const visited = import_typescript.default.visitEachChild(node, visitor, context);
-      if (import_typescript.default.isCallExpression(node) && import_typescript.default.isCallExpression(visited)) {
-        const configuredName = withNodeFunctionName(node);
-        if (configuredName !== null) {
-          const args = [...visited.arguments];
-          if (args.length === 1) {
-            args.push(factory.createIdentifier("undefined"));
-          }
-          args.push(factory.createStringLiteral(configuredName));
-          return factory.updateCallExpression(
-            visited,
-            visited.expression,
-            visited.typeArguments,
-            args
+    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"
           );
-        }
-      }
-      if (!isInstrumentableFunction(node)) {
-        return visited;
-      }
-      if (!isInstrumentableFunction(visited) || transformedNodes.has(visited) || isTraceDecoratorRoot(node) || isBitfabWrappedFunction(node, inlineRoots, referencedRoots)) {
-        return visited;
-      }
-      const name = functionName(node);
-      if (name.startsWith("anonymous-")) {
-        return visited;
-      }
-      const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-      const definition = factory.createObjectLiteralExpression(
-        [
-          factory.createPropertyAssignment(
-            "id",
-            factory.createStringLiteral(autoTraceFunctionId(file, name))
-          ),
-          factory.createPropertyAssignment(
-            "name",
-            factory.createStringLiteral(name)
-          ),
-          factory.createPropertyAssignment(
-            "file",
-            factory.createStringLiteral(file)
-          ),
-          factory.createPropertyAssignment(
-            "line",
-            factory.createNumericLiteral(position.line + 1)
-          ),
-          factory.createPropertyAssignment(
-            "column",
-            factory.createNumericLiteral(position.character)
-          ),
-          ...node.modifiers?.some(
-            (modifier) => modifier.kind === import_typescript.default.SyntaxKind.AsyncKeyword
-          ) ? [factory.createPropertyAssignment("async", factory.createTrue())] : [],
-          ...isRestWrapper(node) ? [
-            factory.createPropertyAssignment(
-              "wrapper",
-              factory.createTrue()
-            )
-          ] : []
-        ],
-        false
-      );
-      const definitionIdentifier = factory.createUniqueName(
-        "bitfabAutoDefinition"
-      );
-      definitions.push(
-        factory.createVariableStatement(
-          void 0,
-          factory.createVariableDeclarationList(
-            [
-              factory.createVariableDeclaration(
-                definitionIdentifier,
-                void 0,
-                void 0,
-                definition
-              )
-            ],
-            import_typescript.default.NodeFlags.Const
-          )
-        )
-      );
-      if (needsArgumentWrapper(visited)) {
-        usedRuntime = true;
-        usedWrapper = true;
-        return factory.createCallExpression(wrapperIdentifier, void 0, [
-          definitionIdentifier,
-          visited
-        ]);
-      }
-      const visitedBody = visited.body;
-      const originalBody = import_typescript.default.isBlock(visitedBody) ? visitedBody : factory.createBlock(
-        [factory.createReturnStatement(visitedBody)],
-        true
-      );
-      const { directives, statements } = splitDirectivePrologue(originalBody);
-      const invoke = factory.createArrowFunction(
-        hasAsyncModifier(node) ? [factory.createModifier(import_typescript.default.SyntaxKind.AsyncKeyword)] : void 0,
-        void 0,
-        [],
-        void 0,
-        factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken),
-        factory.updateBlock(originalBody, statements)
-      );
-      const body = factory.createBlock(
-        [
-          ...directives,
-          factory.createIfStatement(
-            factory.createCallExpression(activeIdentifier, void 0, []),
-            factory.createBlock(
+          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;
+          }
+          state.file.metadata[AUTO_TRACE_TRANSFORM_MARKER] = true;
+          path.unshiftContainer("body", [
+            types.importDeclaration(
               [
-                factory.createReturnStatement(
-                  factory.createCallExpression(runtimeIdentifier, void 0, [
-                    definitionIdentifier,
-                    parameterInputs(factory, visited),
-                    invoke
-                  ])
-                )
-              ],
-              true
-            )
-          ),
-          ...statements
-        ],
-        true
-      );
-      const updated = updateFunctionBody(factory, visited, body);
-      transformedNodes.add(updated);
-      usedRuntime = true;
-      return updated;
-    };
-    const transformed = import_typescript.default.visitEachChild(sourceFile, visitor, context);
-    if (!usedRuntime) {
-      return transformed;
-    }
-    const runtimeImport = factory.createImportDeclaration(
-      void 0,
-      factory.createImportClause(
-        false,
-        void 0,
-        factory.createNamedImports([
-          factory.createImportSpecifier(
-            false,
-            factory.createIdentifier("__bitfabAutoSpan"),
-            runtimeIdentifier
-          ),
-          factory.createImportSpecifier(
-            false,
-            factory.createIdentifier("__bitfabAutoTraceActive"),
-            activeIdentifier
-          ),
-          ...usedWrapper ? [
-            factory.createImportSpecifier(
-              false,
-              factory.createIdentifier("__bitfabAutoWrap"),
-              wrapperIdentifier
-            )
-          ] : []
-        ])
-      ),
-      factory.createStringLiteral(options.runtimeModule ?? "@bitfab/sdk/auto")
-    );
-    const transformMarker = factory.createVariableStatement(
-      void 0,
-      factory.createVariableDeclarationList(
-        [
-          factory.createVariableDeclaration(
-            factory.createIdentifier(AUTO_TRACE_TRANSFORM_MARKER),
-            void 0,
-            void 0,
-            factory.createAssignment(
-              factory.createPropertyAccessExpression(
-                factory.createIdentifier("globalThis"),
-                factory.createIdentifier(AUTO_TRACE_TRANSFORM_MARKER)
-              ),
-              factory.createTrue()
-            )
-          )
-        ],
-        import_typescript.default.NodeFlags.Const
-      )
-    );
-    return factory.updateSourceFile(transformed, [
-      context.getCompilerOptions().module === import_typescript.default.ModuleKind.CommonJS ? factory.createVariableStatement(
-        void 0,
-        factory.createVariableDeclarationList(
-          [
-            factory.createVariableDeclaration(
-              factory.createObjectBindingPattern([
-                factory.createBindingElement(
-                  void 0,
-                  "__bitfabAutoSpan",
-                  runtimeIdentifier
+                types.importSpecifier(
+                  state.runtimeIdentifier,
+                  types.identifier("__bitfabAutoSpan")
                 ),
-                factory.createBindingElement(
-                  void 0,
-                  "__bitfabAutoTraceActive",
-                  activeIdentifier
+                types.importSpecifier(
+                  state.activeIdentifier,
+                  types.identifier("__bitfabAutoTraceActive")
                 ),
-                ...usedWrapper ? [
-                  factory.createBindingElement(
-                    void 0,
-                    "__bitfabAutoWrap",
-                    wrapperIdentifier
+                ...state.usedWrapper ? [
+                  types.importSpecifier(
+                    state.wrapperIdentifier,
+                    types.identifier("__bitfabAutoWrap")
                   )
                 ] : []
-              ]),
-              void 0,
-              void 0,
-              factory.createCallExpression(
-                factory.createIdentifier("require"),
-                void 0,
-                [
-                  factory.createStringLiteral(
-                    options.runtimeModule ?? "@bitfab/sdk/auto"
-                  )
-                ]
+              ],
+              types.stringLiteral(
+                state.opts.runtimeModule ?? "@bitfab/sdk/auto"
               )
-            )
-          ],
-          import_typescript.default.NodeFlags.Const
-        )
-      ) : runtimeImport,
-      transformMarker,
-      ...definitions,
-      ...transformed.statements
-    ]);
+            ),
+            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 || !isInstrumentableFunction(node, types) || isBitfabManagedFunction(path, types) || !state.runtimeIdentifier || !state.activeIdentifier || !state.wrapperIdentifier) {
+            return;
+          }
+          const name = qualifiedFunctionName(path, types);
+          if (name.startsWith("anonymous-")) {
+            return;
+          }
+          const normalizedFilename = autoTraceFilename(
+            state.file.opts.filename ?? "unknown",
+            state.opts.cwd ?? state.file.opts.cwd ?? process.cwd()
+          );
+          const { line, column } = sourcePosition(path);
+          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)) {
+            node._bitfabInstrumented = true;
+            path.replaceWith(
+              types.callExpression(types.cloneNode(state.wrapperIdentifier), [
+                types.cloneNode(definitionIdentifier),
+                node
+              ])
+            );
+            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(
+                  types.cloneNode(state.activeIdentifier),
+                  []
+                ),
+                types.blockStatement([
+                  types.returnStatement(
+                    types.callExpression(
+                      types.cloneNode(state.runtimeIdentifier),
+                      [
+                        types.cloneNode(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;
+        }
+      }
+    }
   };
 }
-function hasAsyncModifier(node) {
-  return import_typescript.default.canHaveModifiers(node) ? import_typescript.default.getModifiers(node)?.some((modifier) => modifier.kind === import_typescript.default.SyntaxKind.AsyncKeyword) ?? false : false;
+
+// ../bitfab-typescript-transform/src/transform.ts
+function parserPlugins(filename) {
+  const path = sourceFilename(filename);
+  const typescript = /\.[cm]?tsx?$/.test(path);
+  const jsx = /\.tsx$/.test(path) || /\.[cm]?jsx?$/.test(path);
+  return [
+    ...typescript ? ["typescript"] : [],
+    ...jsx ? ["jsx"] : [],
+    "decorators"
+  ];
 }
-function transformBitfabTypeScriptSource(source, filename, options = {}) {
-  const sourceFilename = filename.replace(/\\/g, "/").split(/[?#]/, 1)[0] ?? filename;
-  const sourceFile = import_typescript.default.createSourceFile(
-    sourceFilename,
-    source,
-    import_typescript.default.ScriptTarget.Latest,
-    true,
-    sourceFilename.endsWith("x") ? import_typescript.default.ScriptKind.TSX : import_typescript.default.ScriptKind.TS
-  );
-  const result = import_typescript.default.transform(sourceFile, [
-    createBitfabTypeScriptTransformer(options)
-  ]);
-  try {
-    return {
-      code: import_typescript.default.createPrinter().printFile(result.transformed[0])
-    };
-  } finally {
-    result.dispose();
+function transformBitfabSource(source, filename, options = {}) {
+  if (!shouldTransformBitfabFile(filename, options)) {
+    return { code: source };
   }
+  const result = (0, import_core.transformSync)(source, {
+    babelrc: false,
+    configFile: false,
+    filename: sourceFilename(filename),
+    parserOpts: { plugins: parserPlugins(filename), sourceType: "module" },
+    plugins: [[bitfabBabelPlugin, options]],
+    sourceMaps: true
+  });
+  if (!result?.code || !result.metadata?.[AUTO_TRACE_TRANSFORM_MARKER]) {
+    return { code: source };
+  }
+  return {
+    code: result.code,
+    ...result.map ? { map: result.map } : {}
+  };
 }
 
 // ../bitfab-typescript-transform/src/swcAdapter.ts
+function swcOptions(transformed, options) {
+  return {
+    filename: options.filename,
+    ...transformed.map && {
+      inputSourceMap: JSON.stringify(transformed.map)
+    },
+    ...options.swc
+  };
+}
 async function transformWithBitfabSwc(compiler, source, options) {
-  const transformed = transformBitfabTypeScriptSource(
+  const transformed = transformBitfabSource(
     source,
     options.filename,
     options.bitfab
   );
-  return compiler.transform(transformed.code, {
-    filename: options.filename,
-    ...options.swc
-  });
+  return compiler.transform(transformed.code, swcOptions(transformed, options));
 }
 function transformWithBitfabSwcSync(compiler, source, options) {
-  const transformed = transformBitfabTypeScriptSource(
+  const transformed = transformBitfabSource(
     source,
     options.filename,
     options.bitfab
   );
-  return compiler.transformSync(transformed.code, {
-    filename: options.filename,
-    ...options.swc
-  });
+  return compiler.transformSync(
+    transformed.code,
+    swcOptions(transformed, options)
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {