@bitfab/sdk 0.64.23 → 0.64.25

package/dist/transform/nodeLoader.js

@@ -6,7 +6,15 @@ import { fileURLToPath, pathToFileURL } from "url";
 
 // ../bitfab-typescript-transform/src/loaderRuntime.ts
 import { dirname } from "path";
-import ts2 from "typescript";
+import {
+  transformFromAstSync,
+  transformSync as transformSync2
+} from "@babel/core";
+import decoratorsPlugin from "@babel/plugin-proposal-decorators";
+import commonJsPlugin from "@babel/plugin-transform-modules-commonjs";
+import reactJsxPlugin from "@babel/plugin-transform-react-jsx";
+import typeScriptPlugin from "@babel/plugin-transform-typescript";
+import { getTsconfig, parseTsconfig } from "get-tsconfig";
 
 // ../bitfab-typescript-transform/src/transformOptions.ts
 var AUTO_TRACE_FUNCTION_ID_VERSION = "ts-auto-v1";
@@ -14,6 +22,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;
@@ -21,7 +37,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 isAbsolute2 = normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized);
   if (normalizedCwd && isAbsolute2 && normalized !== normalizedCwd && !normalized.startsWith(`${normalizedCwd}/`)) {
@@ -30,566 +46,503 @@ function shouldTransformBitfabFile(filename, options) {
   return !normalized.includes("/node_modules/") && !normalized.endsWith(".d.ts") && /\.[cm]?[jt]sx?$/.test(normalized);
 }
 
-// ../bitfab-typescript-transform/src/typescriptTransformer.ts
-import ts from "typescript";
-function hasUseClientDirective(sourceFile) {
-  return sourceFile.statements.some(
-    (statement) => ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression) && statement.expression.text === "use client"
-  );
-}
-function hasTransformMarker(sourceFile) {
-  return sourceFile.statements.some(
-    (statement) => ts.isVariableStatement(statement) && statement.declarationList.declarations.some(
-      (declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === AUTO_TRACE_TRANSFORM_MARKER
-    )
-  );
-}
-function isBitfabMemberCall(node, memberName) {
-  return ts.isCallExpression(node) && ts.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 (ts.isIdentifier(fn)) {
-    return fn.text;
+  if ((types.isClassMethod(node) || types.isObjectMethod(node)) && !node.computed && types.isIdentifier(node.key)) {
+    return node.key.name;
   }
-  if (ts.isPropertyAccessExpression(fn)) {
-    return fn.name.text;
+  const parent = path.parentPath?.node;
+  if (types.isVariableDeclarator(parent)) {
+    return propertyName(parent.id, types) ?? "anonymous";
   }
-  if (ts.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 (!ts.canHaveDecorators(node)) {
-    return [];
+function isInstrumentableFunction(node, types) {
+  if (node.generator || types.isClassPrivateMethod(node)) {
+    return false;
   }
-  return ts.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 && (ts.isArrowFunction(fn) || ts.isFunctionExpression(fn))) {
-        inlineRoots.add(fn);
-      } else if (fn && ts.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);
+        }
       }
     }
-    ts.forEachChild(node, visit);
+    ancestor = ancestor.parentPath;
   }
-  visit(sourceFile);
-  return { inlineRoots, referencedRoots };
+  return [...scopes, ownName].join(".");
 }
-function declaredFunctionName(node) {
-  if (node.name && ts.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 ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && ts.isVariableDeclaration(node.parent) && ts.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 ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && ts.isPropertyAssignment(node.parent) && (ts.isIdentifier(node.parent.name) || ts.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 (ts.isVariableDeclaration(node.parent) && ts.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 (ts.isPropertyAssignment(node.parent) && (ts.isIdentifier(node.parent.name) || ts.isStringLiteral(node.parent.name))) {
-    return node.parent.name.text;
+  if (types.isMemberExpression(fn) && !fn.computed) {
+    return propertyName(fn.property, types);
+  }
+  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 ((ts.isClassDeclaration(ancestor) || ts.isClassExpression(ancestor)) && ancestor.name) {
-        scopes.unshift(ancestor.name.text);
-      } else if (ts.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 (!ts.isFunctionDeclaration(node) && !ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isMethodDeclaration(node)) {
+  const bindingName = functionBindingName(path, types);
+  if (!bindingName) {
     return false;
   }
-  return node.body !== void 0 && node.asteriskToken === void 0 && (!node.name || !ts.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 (!ts.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 (ts.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 ts.isArrowFunction(node) && node.parameters.some(
-    (parameter) => !ts.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) => !(ts.isExpressionStatement(statement) && ts.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 (ts.isFunctionDeclaration(node)) {
-    return factory.updateFunctionDeclaration(
-      node,
-      node.modifiers,
-      node.asteriskToken,
-      node.name,
-      node.typeParameters,
-      node.parameters,
-      node.type,
-      body
-    );
-  }
-  if (ts.isFunctionExpression(node)) {
-    return factory.updateFunctionExpression(
-      node,
-      node.modifiers,
-      node.asteriskToken,
-      node.name,
-      node.typeParameters,
-      node.parameters,
-      node.type,
-      body
-    );
-  }
-  if (ts.isArrowFunction(node)) {
-    return factory.updateArrowFunction(
-      node,
-      node.modifiers,
-      node.typeParameters,
-      node.parameters,
-      node.type,
-      node.equalsGreaterThanToken,
-      body
-    );
-  }
-  if (ts.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 = ts.visitEachChild(node, visitor, context);
-      if (ts.isCallExpression(node) && ts.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 === ts.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
-              )
-            ],
-            ts.NodeFlags.Const
-          )
-        )
-      );
-      if (needsArgumentWrapper(visited)) {
-        usedRuntime = true;
-        usedWrapper = true;
-        return factory.createCallExpression(wrapperIdentifier, void 0, [
-          definitionIdentifier,
-          visited
-        ]);
-      }
-      const visitedBody = visited.body;
-      const originalBody = ts.isBlock(visitedBody) ? visitedBody : factory.createBlock(
-        [factory.createReturnStatement(visitedBody)],
-        true
-      );
-      const { directives, statements } = splitDirectivePrologue(originalBody);
-      const invoke = factory.createArrowFunction(
-        hasAsyncModifier(node) ? [factory.createModifier(ts.SyntaxKind.AsyncKeyword)] : void 0,
-        void 0,
-        [],
-        void 0,
-        factory.createToken(ts.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 = ts.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()
-            )
-          )
-        ],
-        ts.NodeFlags.Const
-      )
-    );
-    return factory.updateSourceFile(transformed, [
-      context.getCompilerOptions().module === ts.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"
               )
-            )
-          ],
-          ts.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 ts.canHaveModifiers(node) ? ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ?? false : false;
+
+// ../bitfab-typescript-transform/src/transform.ts
+import { transformSync } from "@babel/core";
+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"
+  ];
 }
 
 // ../bitfab-typescript-transform/src/loaderRuntime.ts
-var OPTIONS_THAT_ONLY_APPLY_TO_A_WHOLE_PROGRAM = [
-  "composite",
-  "declarationDir",
-  "incremental",
-  "outDir",
-  "rootDir",
-  "rootDirs",
-  "tsBuildInfoFile"
-];
 function readCompilerOptions(filename, configuredPath) {
-  const configPath = configuredPath ?? ts2.findConfigFile(dirname(filename), ts2.sys.fileExists, "tsconfig.json");
-  if (!configPath) {
-    return {};
-  }
-  const config = ts2.readConfigFile(configPath, ts2.sys.readFile);
-  if (config.error) {
-    throw new Error(
-      ts2.flattenDiagnosticMessageText(config.error.messageText, "\n")
-    );
-  }
-  const { options } = ts2.parseJsonConfigFileContent(
-    config.config,
-    ts2.sys,
-    dirname(configPath)
-  );
-  for (const option of OPTIONS_THAT_ONLY_APPLY_TO_A_WHOLE_PROGRAM) {
-    delete options[option];
-  }
-  return options;
+  const config = configuredPath ? parseTsconfig(configuredPath) : getTsconfig(dirname(filename))?.config;
+  return config?.compilerOptions ?? {};
 }
-function moduleKindForFormat(filename, format) {
-  if (format === "commonjs" || filename.endsWith(".cts")) {
-    return ts2.ModuleKind.CommonJS;
+function reactJsxOptions(compilerOptions) {
+  if (compilerOptions.jsx === "react") {
+    return [
+      reactJsxPlugin,
+      {
+        runtime: "classic",
+        ...compilerOptions.jsxFactory && {
+          pragma: compilerOptions.jsxFactory
+        },
+        ...compilerOptions.jsxFragmentFactory && {
+          pragmaFrag: compilerOptions.jsxFragmentFactory
+        }
+      }
+    ];
   }
-  return ts2.ModuleKind.ESNext;
+  return [
+    reactJsxPlugin,
+    {
+      runtime: "automatic",
+      importSource: compilerOptions.jsxImportSource ?? "react"
+    }
+  ];
+}
+function compilePlugins(filename, compilerOptions, format) {
+  const path = sourceFilename(filename);
+  const isTypeScript = /\.[cm]?tsx?$/.test(path);
+  const hasJsx = /\.[jt]sx$/.test(path);
+  const isCommonJs = format === "commonjs" || path.endsWith(".cts");
+  return [
+    ...isTypeScript ? [
+      [
+        typeScriptPlugin,
+        {
+          onlyRemoveTypeImports: compilerOptions.verbatimModuleSyntax === true
+        }
+      ]
+    ] : [],
+    [
+      decoratorsPlugin,
+      {
+        version: compilerOptions.experimentalDecorators ? "legacy" : "2023-11"
+      }
+    ],
+    ...hasJsx ? [reactJsxOptions(compilerOptions)] : [],
+    ...isCommonJs ? [commonJsPlugin] : []
+  ];
 }
 function transformBitfabModuleToJavaScript(source, filename, options = {}, format, sourceMapMode = "external") {
   const { tsconfig, ...transformOptions } = options;
   if (!shouldTransformBitfabFile(filename, transformOptions)) {
     return { code: source };
   }
-  const compilerOptions = readCompilerOptions(filename, tsconfig);
-  const result = ts2.transpileModule(source, {
-    compilerOptions: {
-      ...compilerOptions,
-      allowJs: true,
-      declaration: false,
-      emitDeclarationOnly: false,
-      inlineSourceMap: sourceMapMode === "inline",
-      inlineSources: sourceMapMode === "inline",
-      module: moduleKindForFormat(filename, format),
-      moduleResolution: format === "commonjs" ? ts2.ModuleResolutionKind.Node10 : ts2.ModuleResolutionKind.Bundler,
-      noEmit: false,
-      noEmitOnError: false,
-      sourceMap: sourceMapMode === "external"
-    },
-    fileName: filename,
-    reportDiagnostics: true,
-    transformers: {
-      before: [createBitfabTypeScriptTransformer(transformOptions)]
-    }
+  const sourceFile = sourceFilename(filename);
+  const instrumented = transformSync2(source, {
+    ast: true,
+    babelrc: false,
+    code: false,
+    configFile: false,
+    filename: sourceFile,
+    parserOpts: { plugins: parserPlugins(filename), sourceType: "module" },
+    plugins: [[bitfabBabelPlugin, transformOptions]]
   });
-  const errors = result.diagnostics?.filter(
-    (diagnostic) => diagnostic.category === ts2.DiagnosticCategory.Error
-  );
-  if (errors && errors.length > 0) {
-    throw new Error(
-      ts2.formatDiagnostics(errors, {
-        getCanonicalFileName: (file) => file,
-        getCurrentDirectory: () => process.cwd(),
-        getNewLine: () => "\n"
-      })
-    );
+  if (!instrumented?.ast) {
+    throw new Error(`Bitfab could not parse ${sourceFile}`);
+  }
+  const compiled = transformFromAstSync(instrumented.ast, source, {
+    babelrc: false,
+    cloneInputAst: false,
+    configFile: false,
+    filename: sourceFile,
+    plugins: compilePlugins(
+      filename,
+      readCompilerOptions(filename, tsconfig),
+      format
+    ),
+    sourceMaps: sourceMapMode === "inline" ? "inline" : true
+  });
+  if (compiled?.code === void 0 || compiled.code === null) {
+    throw new Error(`Bitfab could not compile ${sourceFile}`);
   }
   return {
-    code: result.outputText,
-    ...result.sourceMapText ? { map: result.sourceMapText } : {}
+    code: compiled.code,
+    ...compiled.map ? { map: JSON.stringify(compiled.map) } : {}
   };
 }