bitfab 0.60.1 → 0.61.1

package/dist/chunk-OXFZJP4E.js

@@ -0,0 +1,30 @@
+import {
+  transformBitfabTypeScriptSource
+} from "./chunk-PACLPKDH.js";
+import {
+  shouldTransformBitfabFile
+} from "./chunk-6R33XLNY.js";
+
+// ../bitfab-typescript-transform/src/unplugin.ts
+import { createUnplugin } from "unplugin";
+var bitfabTraceUnplugin = createUnplugin((options) => {
+  const resolvedOptions = options ?? {};
+  return {
+    name: "bitfab-auto-trace",
+    enforce: "pre",
+    transform(source, filename) {
+      if (!shouldTransformBitfabFile(filename, resolvedOptions)) {
+        return null;
+      }
+      return {
+        ...transformBitfabTypeScriptSource(source, filename, resolvedOptions),
+        map: null
+      };
+    }
+  };
+});
+
+export {
+  bitfabTraceUnplugin
+};
+//# sourceMappingURL=chunk-OXFZJP4E.js.map

package/dist/chunk-OXFZJP4E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../bitfab-typescript-transform/src/unplugin.ts"],"sourcesContent":["import { createUnplugin } from \"unplugin\"\nimport type { BitfabTransformOptions } from \"./transformOptions.js\"\nimport { shouldTransformBitfabFile } from \"./transformOptions.js\"\nimport { transformBitfabTypeScriptSource } from \"./typescriptTransformer.js\"\n\nexport const bitfabTraceUnplugin = createUnplugin<\n  BitfabTransformOptions | undefined,\n  false\n>((options) => {\n  const resolvedOptions = options ?? {}\n\n  return {\n    name: \"bitfab-auto-trace\",\n    enforce: \"pre\",\n    transform(source, filename) {\n      if (!shouldTransformBitfabFile(filename, resolvedOptions)) {\n        return null\n      }\n\n      return {\n        ...transformBitfabTypeScriptSource(source, filename, resolvedOptions),\n        map: null,\n      }\n    },\n  }\n})\n"],"mappings":";;;;;;;;AAAA,SAAS,sBAAsB;AAKxB,IAAM,sBAAsB,eAGjC,CAAC,YAAY;AACb,QAAM,kBAAkB,WAAW,CAAC;AAEpC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IACT,UAAU,QAAQ,UAAU;AAC1B,UAAI,CAAC,0BAA0B,UAAU,eAAe,GAAG;AACzD,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,QACL,GAAG,gCAAgC,QAAQ,UAAU,eAAe;AAAA,QACpE,KAAK;AAAA,MACP;AAAA,IACF;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/chunk-PACLPKDH.js

@@ -0,0 +1,513 @@
+import {
+  AUTO_TRACE_TRANSFORM_MARKER,
+  autoTraceFunctionId,
+  shouldTransformBitfabFile
+} from "./chunk-6R33XLNY.js";
+
+// ../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;
+}
+function withNodeFunctionName(node) {
+  if (!isBitfabMemberCall(node, "withNode") || node.arguments.length > 2) {
+    return null;
+  }
+  const fn = node.arguments[node.arguments.length - 1];
+  if (ts.isIdentifier(fn)) {
+    return fn.text;
+  }
+  if (ts.isPropertyAccessExpression(fn)) {
+    return fn.name.text;
+  }
+  if (ts.isFunctionExpression(fn) && fn.name) {
+    return fn.name.text;
+  }
+  return null;
+}
+function traceDecorators(node) {
+  if (!ts.canHaveDecorators(node)) {
+    return [];
+  }
+  return ts.getDecorators(node) ?? [];
+}
+function isTraceDecoratorRoot(node) {
+  return traceDecorators(node).some(
+    (decorator) => isBitfabMemberCall(decorator.expression, "trace")
+  );
+}
+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);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return { inlineRoots, referencedRoots };
+}
+function declaredFunctionName(node) {
+  if (node.name && ts.isIdentifier(node.name)) {
+    return node.name.text;
+  }
+  if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+    return node.parent.name.text;
+  }
+  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;
+  }
+  return null;
+}
+function objectContainerName(node) {
+  if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+    return node.parent.name.text;
+  }
+  if (ts.isPropertyAssignment(node.parent) && (ts.isIdentifier(node.parent.name) || ts.isStringLiteral(node.parent.name))) {
+    return node.parent.name.text;
+  }
+  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(".");
+  }
+  const sourceFile = node.getSourceFile();
+  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+  return `anonymous-${position.line + 1}-${position.character}`;
+}
+function isBitfabWrappedFunction(node, inlineRoots, referencedRoots) {
+  if (inlineRoots.has(node)) {
+    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)) {
+    return false;
+  }
+  return node.body !== void 0 && node.asteriskToken === void 0 && (!node.name || !ts.isPrivateIdentifier(node.name));
+}
+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 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")
+                  )
+                ]),
+                "slice"
+              ),
+              void 0,
+              [factory.createNumericLiteral(index)]
+            )
+          );
+        }
+        return factory.createElementAccessExpression(
+          factory.createIdentifier("arguments"),
+          factory.createNumericLiteral(index)
+        );
+      }
+      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"
+      );
+    })
+  );
+}
+function needsArgumentWrapper(node) {
+  return ts.isArrowFunction(node) && node.parameters.some(
+    (parameter) => !ts.isIdentifier(parameter.name) || parameter.initializer !== void 0
+  );
+}
+function isRestWrapper(node) {
+  return node.parameters.length === 1 && node.parameters[0]?.dotDotDotToken !== void 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: [] };
+  }
+  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
+          );
+        }
+      }
+      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(
+              [
+                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
+                ),
+                factory.createBindingElement(
+                  void 0,
+                  "__bitfabAutoTraceActive",
+                  activeIdentifier
+                ),
+                ...usedWrapper ? [
+                  factory.createBindingElement(
+                    void 0,
+                    "__bitfabAutoWrap",
+                    wrapperIdentifier
+                  )
+                ] : []
+              ]),
+              void 0,
+              void 0,
+              factory.createCallExpression(
+                factory.createIdentifier("require"),
+                void 0,
+                [
+                  factory.createStringLiteral(
+                    options.runtimeModule ?? "@bitfab/sdk/auto"
+                  )
+                ]
+              )
+            )
+          ],
+          ts.NodeFlags.Const
+        )
+      ) : runtimeImport,
+      transformMarker,
+      ...definitions,
+      ...transformed.statements
+    ]);
+  };
+}
+function hasAsyncModifier(node) {
+  return ts.canHaveModifiers(node) ? ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ?? false : false;
+}
+function transformBitfabTypeScriptSource(source, filename, options = {}) {
+  const sourceFilename = filename.replace(/\\/g, "/").split(/[?#]/, 1)[0] ?? filename;
+  const sourceFile = ts.createSourceFile(
+    sourceFilename,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    sourceFilename.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const result = ts.transform(sourceFile, [
+    createBitfabTypeScriptTransformer(options)
+  ]);
+  try {
+    return {
+      code: ts.createPrinter().printFile(result.transformed[0])
+    };
+  } finally {
+    result.dispose();
+  }
+}
+
+export {
+  createBitfabTypeScriptTransformer,
+  transformBitfabTypeScriptSource
+};
+//# sourceMappingURL=chunk-PACLPKDH.js.map

package/dist/chunk-PACLPKDH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../bitfab-typescript-transform/src/typescriptTransformer.ts"],"sourcesContent":["import ts from \"typescript\"\nimport type { BitfabTransformOptions } from \"./transformOptions.js\"\nimport {\n  AUTO_TRACE_TRANSFORM_MARKER,\n  autoTraceFunctionId,\n  shouldTransformBitfabFile,\n} from \"./transformOptions.js\"\n\nexport type { BitfabTransformOptions } from \"./transformOptions.js\"\n\nfunction hasUseClientDirective(sourceFile: ts.SourceFile): boolean {\n  return sourceFile.statements.some(\n    (statement) =>\n      ts.isExpressionStatement(statement) &&\n      ts.isStringLiteral(statement.expression) &&\n      statement.expression.text === \"use client\",\n  )\n}\n\nfunction hasTransformMarker(sourceFile: ts.SourceFile): boolean {\n  return sourceFile.statements.some(\n    (statement) =>\n      ts.isVariableStatement(statement) &&\n      statement.declarationList.declarations.some(\n        (declaration) =>\n          ts.isIdentifier(declaration.name) &&\n          declaration.name.text === AUTO_TRACE_TRANSFORM_MARKER,\n      ),\n  )\n}\n\nfunction isBitfabMemberCall(\n  node: ts.Node,\n  memberName: \"trace\" | \"withNode\" | \"withSpan\" | \"withTrace\",\n): node is ts.CallExpression {\n  return (\n    ts.isCallExpression(node) &&\n    ts.isPropertyAccessExpression(node.expression) &&\n    node.expression.name.text === memberName\n  )\n}\n\nfunction withNodeFunctionName(node: ts.CallExpression): string | null {\n  if (!isBitfabMemberCall(node, \"withNode\") || node.arguments.length > 2) {\n    return null\n  }\n  const fn = node.arguments[node.arguments.length - 1]\n  if (ts.isIdentifier(fn)) {\n    return fn.text\n  }\n  if (ts.isPropertyAccessExpression(fn)) {\n    return fn.name.text\n  }\n  if (ts.isFunctionExpression(fn) && fn.name) {\n    return fn.name.text\n  }\n  return null\n}\n\nfunction traceDecorators(node: ts.Node): readonly ts.Decorator[] {\n  if (!ts.canHaveDecorators(node)) {\n    return []\n  }\n  return ts.getDecorators(node) ?? []\n}\n\nfunction isTraceDecoratorRoot(node: ts.Node): boolean {\n  return traceDecorators(node).some((decorator) =>\n    isBitfabMemberCall(decorator.expression, \"trace\"),\n  )\n}\n\nfunction collectBitfabWrappedFunctions(sourceFile: ts.SourceFile): {\n  inlineRoots: ReadonlySet<ts.Node>\n  referencedRoots: ReadonlySet<string>\n} {\n  const inlineRoots = new Set<ts.Node>()\n  const referencedRoots = new Set<string>()\n\n  function visit(node: ts.Node): void {\n    if (\n      isBitfabMemberCall(node, \"withTrace\") ||\n      isBitfabMemberCall(node, \"withSpan\")\n    ) {\n      const fn = node.arguments[node.arguments.length - 1]\n      if (fn && (ts.isArrowFunction(fn) || ts.isFunctionExpression(fn))) {\n        inlineRoots.add(fn)\n      } else if (fn && ts.isIdentifier(fn)) {\n        referencedRoots.add(fn.text)\n      }\n    }\n    ts.forEachChild(node, visit)\n  }\n\n  visit(sourceFile)\n  return { inlineRoots, referencedRoots }\n}\n\nfunction declaredFunctionName(node: ts.FunctionLikeDeclaration): string | null {\n  if (node.name && ts.isIdentifier(node.name)) {\n    return node.name.text\n  }\n  if (\n    (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&\n    ts.isVariableDeclaration(node.parent) &&\n    ts.isIdentifier(node.parent.name)\n  ) {\n    return node.parent.name.text\n  }\n  if (\n    (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&\n    ts.isPropertyAssignment(node.parent) &&\n    (ts.isIdentifier(node.parent.name) || ts.isStringLiteral(node.parent.name))\n  ) {\n    return node.parent.name.text\n  }\n  return null\n}\n\nfunction objectContainerName(node: ts.ObjectLiteralExpression): string | null {\n  if (\n    ts.isVariableDeclaration(node.parent) &&\n    ts.isIdentifier(node.parent.name)\n  ) {\n    return node.parent.name.text\n  }\n  if (\n    ts.isPropertyAssignment(node.parent) &&\n    (ts.isIdentifier(node.parent.name) || ts.isStringLiteral(node.parent.name))\n  ) {\n    return node.parent.name.text\n  }\n  return null\n}\n\nfunction functionName(node: ts.FunctionLikeDeclaration): string {\n  const ownName = declaredFunctionName(node)\n  if (ownName) {\n    const scopes: string[] = []\n    let ancestor: ts.Node | undefined = node.parent\n    while (ancestor) {\n      if (isInstrumentableFunction(ancestor)) {\n        const name = declaredFunctionName(ancestor)\n        if (name) {\n          scopes.unshift(name)\n        }\n      } else if (\n        (ts.isClassDeclaration(ancestor) || ts.isClassExpression(ancestor)) &&\n        ancestor.name\n      ) {\n        scopes.unshift(ancestor.name.text)\n      } else if (ts.isObjectLiteralExpression(ancestor)) {\n        const name = objectContainerName(ancestor)\n        if (name) {\n          scopes.unshift(name)\n        }\n      }\n      ancestor = ancestor.parent\n    }\n    return [...scopes, ownName].join(\".\")\n  }\n\n  const sourceFile = node.getSourceFile()\n  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart())\n  return `anonymous-${position.line + 1}-${position.character}`\n}\n\nfunction isBitfabWrappedFunction(\n  node: ts.FunctionLikeDeclaration,\n  inlineRoots: ReadonlySet<ts.Node>,\n  referencedRoots: ReadonlySet<string>,\n): boolean {\n  if (inlineRoots.has(node)) {\n    return true\n  }\n  const name = declaredFunctionName(node)\n  return name !== null && referencedRoots.has(name)\n}\n\nfunction isInstrumentableFunction(\n  node: ts.Node,\n): node is\n  | ts.FunctionDeclaration\n  | ts.FunctionExpression\n  | ts.ArrowFunction\n  | ts.MethodDeclaration {\n  if (\n    !ts.isFunctionDeclaration(node) &&\n    !ts.isFunctionExpression(node) &&\n    !ts.isArrowFunction(node) &&\n    !ts.isMethodDeclaration(node)\n  ) {\n    return false\n  }\n\n  return (\n    node.body !== undefined &&\n    node.asteriskToken === undefined &&\n    (!node.name || !ts.isPrivateIdentifier(node.name))\n  )\n}\n\nfunction normalizedFilename(filename: string, cwd: string): string {\n  const normalized = filename.replace(/\\\\/g, \"/\").split(/[?#]/, 1)[0] ?? \"\"\n  const normalizedCwd = cwd.replace(/\\\\/g, \"/\").replace(/\\/$/, \"\")\n  return normalized.startsWith(`${normalizedCwd}/`)\n    ? normalized.slice(normalizedCwd.length + 1)\n    : normalized\n}\n\nfunction parameterInputs(\n  factory: ts.NodeFactory,\n  node: ts.FunctionLikeDeclaration,\n): ts.ArrayLiteralExpression {\n  return factory.createArrayLiteralExpression(\n    node.parameters.map((parameter, index) => {\n      if (!ts.isArrowFunction(node)) {\n        if (parameter.dotDotDotToken) {\n          return factory.createSpreadElement(\n            factory.createCallExpression(\n              factory.createPropertyAccessExpression(\n                factory.createArrayLiteralExpression([\n                  factory.createSpreadElement(\n                    factory.createIdentifier(\"arguments\"),\n                  ),\n                ]),\n                \"slice\",\n              ),\n              undefined,\n              [factory.createNumericLiteral(index)],\n            ),\n          )\n        }\n        return factory.createElementAccessExpression(\n          factory.createIdentifier(\"arguments\"),\n          factory.createNumericLiteral(index),\n        )\n      }\n\n      if (ts.isIdentifier(parameter.name)) {\n        const identifier = factory.createIdentifier(parameter.name.text)\n        return parameter.dotDotDotToken\n          ? factory.createSpreadElement(identifier)\n          : identifier\n      }\n      throw new Error(\n        \"Bitfab transform invariant: arrow parameter requires argument wrapper\",\n      )\n    }),\n  )\n}\n\nfunction needsArgumentWrapper(node: ts.FunctionLikeDeclaration): boolean {\n  return (\n    ts.isArrowFunction(node) &&\n    node.parameters.some(\n      (parameter) =>\n        !ts.isIdentifier(parameter.name) || parameter.initializer !== undefined,\n    )\n  )\n}\n\nfunction isRestWrapper(node: ts.FunctionLikeDeclaration): boolean {\n  return (\n    node.parameters.length === 1 &&\n    node.parameters[0]?.dotDotDotToken !== undefined\n  )\n}\n\nfunction splitDirectivePrologue(body: ts.Block): {\n  directives: readonly ts.Statement[]\n  statements: readonly ts.Statement[]\n} {\n  const firstNonDirective = body.statements.findIndex(\n    (statement) =>\n      !(\n        ts.isExpressionStatement(statement) &&\n        ts.isStringLiteral(statement.expression)\n      ),\n  )\n  if (firstNonDirective === -1) {\n    return { directives: body.statements, statements: [] }\n  }\n  return {\n    directives: body.statements.slice(0, firstNonDirective),\n    statements: body.statements.slice(firstNonDirective),\n  }\n}\n\nfunction updateFunctionBody(\n  factory: ts.NodeFactory,\n  node: ts.FunctionLikeDeclaration,\n  body: ts.Block,\n): ts.FunctionLikeDeclaration {\n  if (ts.isFunctionDeclaration(node)) {\n    return factory.updateFunctionDeclaration(\n      node,\n      node.modifiers,\n      node.asteriskToken,\n      node.name,\n      node.typeParameters,\n      node.parameters,\n      node.type,\n      body,\n    )\n  }\n  if (ts.isFunctionExpression(node)) {\n    return factory.updateFunctionExpression(\n      node,\n      node.modifiers,\n      node.asteriskToken,\n      node.name,\n      node.typeParameters,\n      node.parameters,\n      node.type,\n      body,\n    )\n  }\n  if (ts.isArrowFunction(node)) {\n    return factory.updateArrowFunction(\n      node,\n      node.modifiers,\n      node.typeParameters,\n      node.parameters,\n      node.type,\n      node.equalsGreaterThanToken,\n      body,\n    )\n  }\n  if (ts.isMethodDeclaration(node)) {\n    return factory.updateMethodDeclaration(\n      node,\n      node.modifiers,\n      node.asteriskToken,\n      node.name,\n      node.questionToken,\n      node.typeParameters,\n      node.parameters,\n      node.type,\n      body,\n    )\n  }\n  return node\n}\n\n/**\n * Create Bitfab's experimental TypeScript compiler transform.\n *\n * The same transform powers the Vite, Rollup, esbuild, and programmatic SWC\n * adapters so generated function IDs remain consistent between build tools.\n *\n * @experimental The generated function identity protocol may change.\n */\nexport function createBitfabTypeScriptTransformer(\n  options: BitfabTransformOptions = {},\n): ts.TransformerFactory<ts.SourceFile> {\n  return (context) => (sourceFile) => {\n    if (\n      hasUseClientDirective(sourceFile) ||\n      hasTransformMarker(sourceFile) ||\n      !shouldTransformBitfabFile(sourceFile.fileName, options)\n    ) {\n      return sourceFile\n    }\n\n    const { factory } = context\n    const { inlineRoots, referencedRoots } =\n      collectBitfabWrappedFunctions(sourceFile)\n    const runtimeIdentifier = factory.createUniqueName(\"bitfabAutoSpan\")\n    const activeIdentifier = factory.createUniqueName(\"bitfabAutoTraceActive\")\n    const wrapperIdentifier = factory.createUniqueName(\"bitfabAutoWrap\")\n    const transformedNodes = new Set<ts.Node>()\n    const definitions: ts.Statement[] = []\n    let usedRuntime = false\n    let usedWrapper = false\n    const cwd = options.cwd ?? process.cwd()\n    const file = normalizedFilename(sourceFile.fileName, cwd)\n\n    const visitor: ts.Visitor = (node) => {\n      const visited = ts.visitEachChild(node, visitor, context)\n      if (ts.isCallExpression(node) && ts.isCallExpression(visited)) {\n        const configuredName = withNodeFunctionName(node)\n        if (configuredName !== null) {\n          const args = [...visited.arguments]\n          if (args.length === 1) {\n            args.push(factory.createIdentifier(\"undefined\"))\n          }\n          args.push(factory.createStringLiteral(configuredName))\n          return factory.updateCallExpression(\n            visited,\n            visited.expression,\n            visited.typeArguments,\n            args,\n          )\n        }\n      }\n      if (!isInstrumentableFunction(node)) {\n        return visited\n      }\n      if (\n        !isInstrumentableFunction(visited) ||\n        transformedNodes.has(visited) ||\n        isTraceDecoratorRoot(node) ||\n        isBitfabWrappedFunction(node, inlineRoots, referencedRoots)\n      ) {\n        return visited\n      }\n\n      const name = functionName(node)\n      if (name.startsWith(\"anonymous-\")) {\n        return visited\n      }\n      const position = sourceFile.getLineAndCharacterOfPosition(node.getStart())\n      const definition = factory.createObjectLiteralExpression(\n        [\n          factory.createPropertyAssignment(\n            \"id\",\n            factory.createStringLiteral(autoTraceFunctionId(file, name)),\n          ),\n          factory.createPropertyAssignment(\n            \"name\",\n            factory.createStringLiteral(name),\n          ),\n          factory.createPropertyAssignment(\n            \"file\",\n            factory.createStringLiteral(file),\n          ),\n          factory.createPropertyAssignment(\n            \"line\",\n            factory.createNumericLiteral(position.line + 1),\n          ),\n          factory.createPropertyAssignment(\n            \"column\",\n            factory.createNumericLiteral(position.character),\n          ),\n          ...(node.modifiers?.some(\n            (modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword,\n          )\n            ? [factory.createPropertyAssignment(\"async\", factory.createTrue())]\n            : []),\n          ...(isRestWrapper(node)\n            ? [\n                factory.createPropertyAssignment(\n                  \"wrapper\",\n                  factory.createTrue(),\n                ),\n              ]\n            : []),\n        ],\n        false,\n      )\n      const definitionIdentifier = factory.createUniqueName(\n        \"bitfabAutoDefinition\",\n      )\n      definitions.push(\n        factory.createVariableStatement(\n          undefined,\n          factory.createVariableDeclarationList(\n            [\n              factory.createVariableDeclaration(\n                definitionIdentifier,\n                undefined,\n                undefined,\n                definition,\n              ),\n            ],\n            ts.NodeFlags.Const,\n          ),\n        ),\n      )\n      if (needsArgumentWrapper(visited)) {\n        usedRuntime = true\n        usedWrapper = true\n        return factory.createCallExpression(wrapperIdentifier, undefined, [\n          definitionIdentifier,\n          visited as ts.ArrowFunction,\n        ])\n      }\n\n      const visitedBody = visited.body as ts.ConciseBody\n      const originalBody = ts.isBlock(visitedBody)\n        ? visitedBody\n        : factory.createBlock(\n            [factory.createReturnStatement(visitedBody)],\n            true,\n          )\n      const { directives, statements } = splitDirectivePrologue(originalBody)\n      const invoke = factory.createArrowFunction(\n        hasAsyncModifier(node)\n          ? [factory.createModifier(ts.SyntaxKind.AsyncKeyword)]\n          : undefined,\n        undefined,\n        [],\n        undefined,\n        factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),\n        factory.updateBlock(originalBody, statements),\n      )\n      const body = factory.createBlock(\n        [\n          ...directives,\n          factory.createIfStatement(\n            factory.createCallExpression(activeIdentifier, undefined, []),\n            factory.createBlock(\n              [\n                factory.createReturnStatement(\n                  factory.createCallExpression(runtimeIdentifier, undefined, [\n                    definitionIdentifier,\n                    parameterInputs(factory, visited),\n                    invoke,\n                  ]),\n                ),\n              ],\n              true,\n            ),\n          ),\n          ...statements,\n        ],\n        true,\n      )\n      const updated = updateFunctionBody(factory, visited, body)\n      transformedNodes.add(updated)\n      usedRuntime = true\n      return updated\n    }\n\n    const transformed = ts.visitEachChild(sourceFile, visitor, context)\n    if (!usedRuntime) {\n      return transformed\n    }\n\n    const runtimeImport = factory.createImportDeclaration(\n      undefined,\n      factory.createImportClause(\n        false,\n        undefined,\n        factory.createNamedImports([\n          factory.createImportSpecifier(\n            false,\n            factory.createIdentifier(\"__bitfabAutoSpan\"),\n            runtimeIdentifier,\n          ),\n          factory.createImportSpecifier(\n            false,\n            factory.createIdentifier(\"__bitfabAutoTraceActive\"),\n            activeIdentifier,\n          ),\n          ...(usedWrapper\n            ? [\n                factory.createImportSpecifier(\n                  false,\n                  factory.createIdentifier(\"__bitfabAutoWrap\"),\n                  wrapperIdentifier,\n                ),\n              ]\n            : []),\n        ]),\n      ),\n      factory.createStringLiteral(options.runtimeModule ?? \"@bitfab/sdk/auto\"),\n    )\n    const transformMarker = factory.createVariableStatement(\n      undefined,\n      factory.createVariableDeclarationList(\n        [\n          factory.createVariableDeclaration(\n            factory.createIdentifier(AUTO_TRACE_TRANSFORM_MARKER),\n            undefined,\n            undefined,\n            factory.createAssignment(\n              factory.createPropertyAccessExpression(\n                factory.createIdentifier(\"globalThis\"),\n                factory.createIdentifier(AUTO_TRACE_TRANSFORM_MARKER),\n              ),\n              factory.createTrue(),\n            ),\n          ),\n        ],\n        ts.NodeFlags.Const,\n      ),\n    )\n    return factory.updateSourceFile(transformed, [\n      context.getCompilerOptions().module === ts.ModuleKind.CommonJS\n        ? factory.createVariableStatement(\n            undefined,\n            factory.createVariableDeclarationList(\n              [\n                factory.createVariableDeclaration(\n                  factory.createObjectBindingPattern([\n                    factory.createBindingElement(\n                      undefined,\n                      \"__bitfabAutoSpan\",\n                      runtimeIdentifier,\n                    ),\n                    factory.createBindingElement(\n                      undefined,\n                      \"__bitfabAutoTraceActive\",\n                      activeIdentifier,\n                    ),\n                    ...(usedWrapper\n                      ? [\n                          factory.createBindingElement(\n                            undefined,\n                            \"__bitfabAutoWrap\",\n                            wrapperIdentifier,\n                          ),\n                        ]\n                      : []),\n                  ]),\n                  undefined,\n                  undefined,\n                  factory.createCallExpression(\n                    factory.createIdentifier(\"require\"),\n                    undefined,\n                    [\n                      factory.createStringLiteral(\n                        options.runtimeModule ?? \"@bitfab/sdk/auto\",\n                      ),\n                    ],\n                  ),\n                ),\n              ],\n              ts.NodeFlags.Const,\n            ),\n          )\n        : runtimeImport,\n      transformMarker,\n      ...definitions,\n      ...transformed.statements,\n    ])\n  }\n}\n\nfunction hasAsyncModifier(node: ts.Node): boolean {\n  return ts.canHaveModifiers(node)\n    ? (ts\n        .getModifiers(node)\n        ?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ??\n        false)\n    : false\n}\n\n/**\n * Transform one TypeScript or JavaScript module with Bitfab call tracing.\n *\n * @experimental The generated function identity protocol may change.\n */\nexport function transformBitfabTypeScriptSource(\n  source: string,\n  filename: string,\n  options: BitfabTransformOptions = {},\n): { code: string } {\n  const sourceFilename =\n    filename.replace(/\\\\/g, \"/\").split(/[?#]/, 1)[0] ?? filename\n  const sourceFile = ts.createSourceFile(\n    sourceFilename,\n    source,\n    ts.ScriptTarget.Latest,\n    true,\n    sourceFilename.endsWith(\"x\") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,\n  )\n  const result = ts.transform(sourceFile, [\n    createBitfabTypeScriptTransformer(options),\n  ])\n  try {\n    return {\n      code: ts\n        .createPrinter()\n        .printFile(result.transformed[0] as ts.SourceFile),\n    }\n  } finally {\n    result.dispose()\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-3UITH7F7.js → chunk-S4WE6U2Y.js}

@@ -1,6 +1,6 @@
 import {
   BitfabError
-} from "./chunk-RTPESK63.js";
+} from "./chunk-I5J2FDKH.js";
 
 // src/codeChange.ts
 var NUL = String.fromCharCode(0);
@@ -236,7 +236,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
       sessionId: seedCase.sessionId
     })
   );
-  const { flushTraces: flushTraces2 } = await import("./http-7DMH2R6R.js");
+  const { flushTraces: flushTraces2 } = await import("./http-NY6M2AK3.js");
   await flushTraces2(3e4);
   return { pipeline, traceFunctionKey, traceIds };
 }
@@ -790,4 +790,4 @@ export {
   runRegistryMain,
   runIfEntrypoint
 };
-//# sourceMappingURL=chunk-3UITH7F7.js.map
+//# sourceMappingURL=chunk-S4WE6U2Y.js.map

package/dist/{chunk-GXLULQMK.js → chunk-VKGLQL7V.js}

@@ -5,7 +5,7 @@ import {
   gitRunner,
   replayContextReady,
   runWithReplayContext
-} from "./chunk-BIDUQ6J7.js";
+} from "./chunk-HKUHPLAM.js";
 import {
   runWithCaptureSuppressed,
   warnOnce
@@ -1280,4 +1280,4 @@ export {
   sleepForReplayPersistence,
   replay
 };
-//# sourceMappingURL=chunk-GXLULQMK.js.map
+//# sourceMappingURL=chunk-VKGLQL7V.js.map

package/dist/{http-DLZLN7UU.js → http-5DA23DKC.js}

@@ -7,7 +7,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-BIDUQ6J7.js";
+} from "./chunk-HKUHPLAM.js";
 import "./chunk-BAOIRE5T.js";
 export {
   BitfabError,
@@ -19,4 +19,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-DLZLN7UU.js.map
+//# sourceMappingURL=http-5DA23DKC.js.map