@rasputin-ai/node 0.4.1 → 0.5.0-alpha.1

package/dist/instrument/build.js

@@ -0,0 +1,707 @@
+// src/auto-instrumentation/instrument-compiled-esm.ts
+import { mkdirSync, readdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join2, relative as relative2, resolve as resolve5 } from "node:path";
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import {
+  INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+  sourceLocatorFromFile as sourceLocatorFromFile2
+} from "@rasputin-ai/core";
+
+// src/execution-recorder/function-plan.ts
+import {
+  runtimeFunctionId,
+  sourceLocatorFromFile
+} from "@rasputin-ai/core";
+var encodeFunctionPlan = (source) => {
+  const locator = sourceLocatorFromFile(source.filePath);
+  const definition = {
+    name: source.name,
+    ...locator ? { source: { ...locator, line: source.line, column: source.column } } : {}
+  };
+  return [
+    runtimeFunctionId(definition),
+    source.name,
+    locator?.packageName ?? null,
+    locator?.packageRelativePath ?? null,
+    source.line,
+    source.column
+  ];
+};
+var definitionFromEncodedPlan = (plan) => {
+  const [functionId, name, packageName, packageRelativePath, line, column] = plan;
+  const source = packageRelativePath ? {
+    ...packageName ? { packageName } : {},
+    packageRelativePath,
+    ...line == null ? {} : { line },
+    ...column == null ? {} : { column }
+  } : void 0;
+  return {
+    functionId,
+    name,
+    ...source ? { source } : {}
+  };
+};
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v2";
+var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
+var getRegistry = () => {
+  const existing = Reflect.get(globalThis, registrySymbol);
+  if (existing?.__rasputinManifestRegistry && existing.files instanceof Map && typeof existing.generation === "number" && typeof existing.uploadedGeneration === "number") {
+    return existing;
+  }
+  const registry = {
+    __rasputinManifestRegistry: true,
+    files: /* @__PURE__ */ new Map(),
+    generation: 0,
+    uploadedGeneration: 0
+  };
+  Reflect.set(globalThis, registrySymbol, registry);
+  return registry;
+};
+var sourceAt = (filePath, line, column) => {
+  const source = sourceLocatorFromFile2(filePath);
+  return source ? { ...source, line, column } : void 0;
+};
+var stableId = (kind, ...parts) => `${kind}_${createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 24)}`;
+var recordInstrumentationManifestDelta = (filePath, delta) => {
+  const registry = getRegistry();
+  registry.files.set(resolve(filePath), delta);
+  registry.generation += 1;
+  registry.onDirty?.();
+};
+var snapshotInstrumentationManifest = (options = {}) => {
+  const functions = [];
+  const callSites = [];
+  const destructures = [];
+  for (const delta of getRegistry().files.values()) {
+    for (const fn of delta.functions) {
+      const definition = definitionFromEncodedPlan(fn.plan);
+      if (!definition.source) continue;
+      functions.push({
+        functionId: definition.functionId,
+        source: definition.source,
+        name: fn.name,
+        startLine: fn.startLine,
+        startColumn: fn.startColumn,
+        endLine: fn.endLine,
+        endColumn: fn.endColumn,
+        params: fn.params
+      });
+    }
+    for (const site of delta.callSites) {
+      const source = sourceAt(site.filePath, site.line, site.column);
+      if (!source) continue;
+      callSites.push({
+        id: stableId(
+          "cs",
+          site.callerFunctionId,
+          source.packageName ?? "",
+          source.packageRelativePath,
+          site.line,
+          site.column
+        ),
+        callerFunctionId: site.callerFunctionId,
+        calleeName: site.calleeName,
+        calleeText: site.calleeText,
+        source,
+        line: site.line,
+        column: site.column,
+        endLine: site.endLine,
+        endColumn: site.endColumn,
+        resultBinding: site.resultBinding,
+        argIdentifiers: site.argIdentifiers
+      });
+    }
+    for (const destructure of delta.destructures) {
+      const source = sourceAt(destructure.filePath, destructure.line, destructure.column);
+      if (!source) continue;
+      destructures.push({
+        callerFunctionId: destructure.callerFunctionId,
+        sourceParam: destructure.sourceParam,
+        source,
+        line: destructure.line,
+        column: destructure.column,
+        binding: destructure.binding
+      });
+    }
+  }
+  const registry = getRegistry();
+  if (registry.prebuilt && registry.files.size === 0) {
+    const prebuilt = registry.prebuilt;
+    if (!options.sourceRoot && !options.sourceRoots) return prebuilt;
+    return {
+      ...prebuilt,
+      sourceRoots: {
+        ...options.sourceRoot ? { default: options.sourceRoot } : {},
+        packages: { ...options.sourceRoots ?? {} }
+      }
+    };
+  }
+  if (functions.length === 0 && callSites.length === 0 && destructures.length === 0) {
+    return void 0;
+  }
+  const packages = { ...options.sourceRoots ?? {} };
+  return {
+    schema_version: INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+    ...options.sourceRoot || Object.keys(packages).length > 0 ? {
+      sourceRoots: {
+        ...options.sourceRoot ? { default: options.sourceRoot } : {},
+        packages
+      }
+    } : {},
+    functions,
+    callSites,
+    destructures
+  };
+};
+var resetInstrumentationManifestRegistry = () => {
+  Reflect.deleteProperty(globalThis, registrySymbol);
+};
+
+// src/auto-instrumentation/source-classification.ts
+import { isAbsolute, relative, resolve as resolve2, sep } from "node:path";
+var sourceExtension = /\.[cm]?[jt]sx?$/i;
+var alwaysExcludedDirectory = /(^|[\\/])(node_modules|coverage|generated|\.git|\.next|\.svelte-kit|\.output|\.vercel|\.rasputin|\.turbo|\.yarn|\.pnpm|\.bun)([\\/]|$)/;
+var buildOutputDirectory = /(^|[\\/])(dist|build|out)([\\/]|$)/;
+var matches = (pattern, value) => {
+  pattern.lastIndex = 0;
+  const result2 = pattern.test(value);
+  pattern.lastIndex = 0;
+  return result2;
+};
+var isWithinRoot = (filePath, root) => {
+  const fromRoot = relative(resolve2(root), filePath);
+  return fromRoot === "" || !fromRoot.startsWith(`..${sep}`) && fromRoot !== ".." && !isAbsolute(fromRoot);
+};
+var isApplicationSource = (filePath, options = {}) => {
+  const absolutePath = resolve2(filePath);
+  if (!sourceExtension.test(absolutePath) || alwaysExcludedDirectory.test(absolutePath))
+    return false;
+  if (options.includeBuildOutput !== true && buildOutputDirectory.test(absolutePath)) return false;
+  if (options.excludedRoots?.some((root) => isWithinRoot(absolutePath, root))) return false;
+  if (options.exclude && matches(options.exclude, absolutePath)) return false;
+  if (options.include && !matches(options.include, absolutePath)) return false;
+  if (options.rootDir) {
+    if (!isWithinRoot(absolutePath, options.rootDir)) return false;
+  }
+  return true;
+};
+
+// src/auto-instrumentation/source-map-locations.ts
+import { readFileSync } from "node:fs";
+import { dirname, isAbsolute as isAbsolute2, join, resolve as resolve3 } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { LEAST_UPPER_BOUND, originalPositionFor, TraceMap } from "@jridgewell/trace-mapping";
+var sourceMapComment = /(?:\/\/[#@][ \t]*sourceMappingURL=([^\s'"]+)|\/\*[#@][ \t]*sourceMappingURL=([^\s*'"]+)[ \t]*\*\/)\s*$/;
+var decodeDataUrl = (url) => {
+  const base64 = /^data:application\/json(?:;charset=[^;,]+)?;base64,(.+)$/i.exec(url);
+  if (base64?.[1]) return Buffer.from(base64[1], "base64").toString("utf8");
+  const raw = /^data:application\/json(?:;charset=[^;,]+)?,(.+)$/i.exec(url);
+  return raw?.[1] ? decodeURIComponent(raw[1]) : void 0;
+};
+var sourceMapFor = (generatedPath, source) => {
+  const match = sourceMapComment.exec(source);
+  const reference = match?.[1] ?? match?.[2];
+  if (reference?.startsWith("data:")) {
+    const payload = decodeDataUrl(reference);
+    return payload ? { payload, mapUrl: pathToFileURL(generatedPath).href } : void 0;
+  }
+  const mapPath = reference ? resolve3(dirname(generatedPath), reference) : `${generatedPath}.map`;
+  return {
+    payload: readFileSync(mapPath, "utf8"),
+    mapUrl: pathToFileURL(mapPath).href
+  };
+};
+var toFilePath = (source, generatedPath) => {
+  if (source.startsWith("file:")) return fileURLToPath(source);
+  return isAbsolute2(source) ? source : join(dirname(generatedPath), source);
+};
+var createSourceMapLocationMapper = (generatedPath, source) => {
+  try {
+    const sourceMap = sourceMapFor(generatedPath, source);
+    if (!sourceMap) return void 0;
+    const traceMap = new TraceMap(sourceMap.payload, sourceMap.mapUrl);
+    return (generated) => {
+      let original = originalPositionFor(traceMap, {
+        line: generated.line,
+        column: Math.max(0, generated.column - 1)
+      });
+      if (!original.source || original.line == null) {
+        original = originalPositionFor(traceMap, {
+          line: generated.line,
+          column: 0,
+          bias: LEAST_UPPER_BOUND
+        });
+      }
+      if (!original.source || original.line == null) return void 0;
+      return {
+        filePath: toFilePath(original.source, generatedPath),
+        line: original.line,
+        column: (original.column ?? 0) + 1
+      };
+    };
+  } catch {
+    return void 0;
+  }
+};
+
+// src/auto-instrumentation/transform-source.ts
+import { resolve as resolve4 } from "node:path";
+import ts2 from "typescript";
+
+// src/execution-recorder/automatic-runtime.ts
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+
+// src/auto-instrumentation/collect-instrumentation-delta.ts
+import ts from "typescript";
+var paramBindingFromName = (name, sourceFile) => {
+  if (ts.isIdentifier(name)) return { kind: "identifier", name: name.text };
+  if (ts.isArrayBindingPattern(name)) {
+    const elements = name.elements.map(
+      (element) => {
+        if (ts.isOmittedExpression(element)) return { kind: "omitted" };
+        const binding = paramBindingFromName(element.name, sourceFile);
+        if (element.dotDotDotToken) return { kind: "rest", binding };
+        return binding;
+      }
+    );
+    return { kind: "array", elements };
+  }
+  const properties = name.elements.map((element) => {
+    const binding = paramBindingFromName(element.name, sourceFile);
+    const key = element.propertyName ? element.propertyName.getText(sourceFile).replace(/^['"]|['"]$/g, "") : ts.isIdentifier(element.name) ? element.name.text : element.name.getText(sourceFile);
+    if (element.dotDotDotToken) {
+      const rest = { kind: "rest", binding };
+      return { key, binding: rest };
+    }
+    return { key, binding };
+  });
+  return { kind: "object", properties };
+};
+var collectFunctionParams = (node, sourceFile) => {
+  const params = [];
+  for (const parameter of node.parameters) {
+    if (ts.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    const binding = paramBindingFromName(parameter.name, sourceFile);
+    params.push(parameter.dotDotDotToken ? { kind: "rest", binding } : binding);
+  }
+  return { params, paramNames: identifierNames(params) };
+};
+var identifierNames = (bindings) => {
+  const names = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    if (node.kind === "identifier") {
+      names.add(node.name);
+      return;
+    }
+    if (node.kind === "rest") {
+      walk(node.binding);
+      return;
+    }
+    if (node.kind === "object") {
+      for (const property of node.properties) walk(property.binding);
+      return;
+    }
+    if (node.kind === "array") {
+      for (const element of node.elements) {
+        if (element.kind !== "omitted") walk(element);
+      }
+    }
+  };
+  for (const item of bindings) walk(item);
+  return names;
+};
+var mappedLocation = (sourceFile, position, absolutePath, mapLocation) => {
+  const generated = sourceFile.getLineAndCharacterOfPosition(position);
+  const raw = {
+    filePath: absolutePath,
+    line: generated.line + 1,
+    column: generated.character + 1
+  };
+  return mapLocation ? mapLocation(raw) : raw;
+};
+var unwrapExpression = (expression) => {
+  let current = expression;
+  while (ts.isParenthesizedExpression(current) || ts.isNonNullExpression(current)) {
+    current = current.expression;
+  }
+  if (ts.isAwaitExpression(current)) return unwrapExpression(current.expression);
+  return current;
+};
+var calleeFromExpression = (expression, sourceFile) => {
+  const current = unwrapExpression(expression);
+  if (ts.isIdentifier(current)) {
+    return { calleeName: current.text, calleeText: current.text };
+  }
+  if (ts.isPropertyAccessExpression(current) && ts.isIdentifier(current.name)) {
+    return {
+      calleeName: current.name.text,
+      calleeText: current.getText(sourceFile).replace(/\s+/g, "")
+    };
+  }
+  return null;
+};
+var resultBindingForCall = (call) => {
+  let node = call.parent;
+  if (ts.isAwaitExpression(node)) node = node.parent;
+  if (!ts.isVariableDeclaration(node)) return null;
+  if (!ts.isIdentifier(node.name)) return null;
+  const initializer = node.initializer;
+  if (!initializer) return null;
+  const inner = unwrapExpression(initializer);
+  if (inner !== call) return null;
+  return node.name.text;
+};
+var argIdentifiersForCall = (call) => {
+  const identifiers = [];
+  call.arguments?.forEach((argument, index) => {
+    if (ts.isIdentifier(argument)) {
+      identifiers.push({ index, kind: "identifier", name: argument.text });
+      return;
+    }
+    if (!ts.isObjectLiteralExpression(argument)) return;
+    const properties = [];
+    for (const property of argument.properties) {
+      if (ts.isShorthandPropertyAssignment(property)) {
+        properties.push({ key: property.name.text, name: property.name.text });
+        continue;
+      }
+      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && ts.isIdentifier(property.initializer)) {
+        properties.push({ key: property.name.text, name: property.initializer.text });
+      }
+    }
+    if (properties.length > 0) {
+      identifiers.push({ index, kind: "object", properties });
+    }
+  });
+  return identifiers;
+};
+var collectCallSite = (call, caller, context) => {
+  const callee = calleeFromExpression(call.expression, context.sourceFile);
+  if (!callee) return null;
+  const start = mappedLocation(
+    context.sourceFile,
+    call.getStart(context.sourceFile),
+    context.absolutePath,
+    context.mapLocation
+  );
+  const end = mappedLocation(
+    context.sourceFile,
+    call.end,
+    context.absolutePath,
+    context.mapLocation
+  );
+  if (!start || !end) return null;
+  return {
+    callerFunctionId: caller.functionId,
+    calleeName: callee.calleeName,
+    calleeText: callee.calleeText,
+    filePath: start.filePath,
+    line: start.line,
+    column: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+    resultBinding: resultBindingForCall(call),
+    argIdentifiers: argIdentifiersForCall(call)
+  };
+};
+var collectParamDestructure = (declaration, caller, context) => {
+  if (!declaration.initializer || !ts.isIdentifier(declaration.initializer)) return null;
+  if (!ts.isObjectBindingPattern(declaration.name) && !ts.isArrayBindingPattern(declaration.name)) {
+    return null;
+  }
+  const sourceParam = declaration.initializer.text;
+  if (!caller.paramNames.has(sourceParam)) return null;
+  const start = mappedLocation(
+    context.sourceFile,
+    declaration.getStart(context.sourceFile),
+    context.absolutePath,
+    context.mapLocation
+  );
+  if (!start) return null;
+  return {
+    callerFunctionId: caller.functionId,
+    sourceParam,
+    filePath: start.filePath,
+    line: start.line,
+    column: start.column,
+    binding: paramBindingFromName(declaration.name, context.sourceFile)
+  };
+};
+
+// src/auto-instrumentation/transform-source.ts
+var scriptKindFor = (filePath) => {
+  if (/\.tsx$/i.test(filePath)) return ts2.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts2.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts2.ScriptKind.TS;
+  return ts2.ScriptKind.JS;
+};
+var functionName = (node, sourceFile) => {
+  if (node.name) return node.name.getText(sourceFile).replace(/^['"]|['"]$/g, "");
+  const parent = node.parent;
+  if (ts2.isVariableDeclaration(parent) && ts2.isIdentifier(parent.name)) return parent.name.text;
+  if (ts2.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
+  if (ts2.isPropertyDeclaration(parent) && parent.name) return parent.name.getText(sourceFile);
+  const location = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return `anonymous@${location.line + 1}:${location.character + 1}`;
+};
+var functionLocationPosition = (node, sourceFile) => {
+  if (node.name) return node.name.getStart(sourceFile);
+  const parent = node.parent;
+  if ((ts2.isVariableDeclaration(parent) || ts2.isPropertyAssignment(parent)) && parent.name) {
+    return parent.name.getStart(sourceFile);
+  }
+  return node.getStart(sourceFile);
+};
+var bindingValue = (name, sourceFile) => {
+  if (ts2.isIdentifier(name)) return name.text;
+  if (ts2.isArrayBindingPattern(name)) {
+    const values = name.elements.map((element) => {
+      if (ts2.isOmittedExpression(element)) return "";
+      const value = bindingValue(element.name, sourceFile);
+      return element.dotDotDotToken ? `...${value}` : value;
+    });
+    return `[${values.join(",")}]`;
+  }
+  const properties = name.elements.map((element) => {
+    const value = bindingValue(element.name, sourceFile);
+    if (element.dotDotDotToken) return `...${value}`;
+    if (element.propertyName) return `${element.propertyName.getText(sourceFile)}:${value}`;
+    return value;
+  });
+  return `{${properties.join(",")}}`;
+};
+var arrowArguments = (node) => {
+  const values = node.parameters.flatMap((parameter) => {
+    if (ts2.isIdentifier(parameter.name) && parameter.name.text === "this") return [];
+    const value = bindingValue(parameter.name, node.getSourceFile());
+    return [parameter.dotDotDotToken ? `...${value}` : value];
+  });
+  return `[${values.join(",")}]`;
+};
+var isSupportedFunction = (node) => {
+  if (!ts2.isFunctionDeclaration(node) && !ts2.isFunctionExpression(node) && !ts2.isArrowFunction(node) && !ts2.isMethodDeclaration(node) && !ts2.isGetAccessorDeclaration(node) && !ts2.isSetAccessorDeclaration(node)) {
+    return false;
+  }
+  if (!node.body || "asteriskToken" in node && node.asteriskToken) return false;
+  return true;
+};
+var uniqueName = (source, base) => {
+  let name = base;
+  while (source.includes(name)) name += "_";
+  return name;
+};
+var modulePreamble = (runName, plansName, plansJson) => `const ${plansName}=${plansJson};const ${runName}=((g,k)=>{const r=g[k]??(g[k]={runtimes:[],register(p){return(i,a,c)=>{const n=this.runtimes.at(-1);return n?n.run(p,i,a,c):c()}}});return r.register(${plansName})})(globalThis,Symbol.for(${JSON.stringify(AUTOMATIC_RUNTIME_SYMBOL)}));`;
+var collectWrappedFunction = (node, sourceFile, absolutePath, mapLocation) => {
+  const start = mappedLocation(
+    sourceFile,
+    functionLocationPosition(node, sourceFile),
+    absolutePath,
+    mapLocation
+  );
+  if (!start) return void 0;
+  const end = mappedLocation(sourceFile, node.end, absolutePath, mapLocation) ?? start;
+  const name = functionName(node, sourceFile).replace(/@\d+:\d+$/, "");
+  const { params, paramNames } = collectFunctionParams(node, sourceFile);
+  const plan = encodeFunctionPlan({
+    filePath: start.filePath,
+    name,
+    line: start.line,
+    column: start.column
+  });
+  return {
+    plan,
+    functionId: plan[0],
+    filePath: start.filePath,
+    name,
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+    params,
+    paramNames
+  };
+};
+var transformSource = (source, options) => {
+  if (source.includes("@rasputin-ignore-file")) return void 0;
+  const sourceFile = ts2.createSourceFile(
+    options.filePath,
+    source,
+    ts2.ScriptTarget.Latest,
+    true,
+    scriptKindFor(options.filePath)
+  );
+  const runName = uniqueName(source, "__rasputinRun__");
+  const plansName = uniqueName(source, "__rasputinPlans__");
+  const absolutePath = resolve4(options.filePath);
+  const edits = [];
+  let order = 0;
+  const delta = {
+    functions: [],
+    callSites: [],
+    destructures: []
+  };
+  const collectContext = {
+    sourceFile,
+    mapLocation: options.mapLocation,
+    absolutePath
+  };
+  const visit = (node, caller) => {
+    if (isSupportedFunction(node)) {
+      const collected = collectWrappedFunction(node, sourceFile, absolutePath, options.mapLocation);
+      if (!collected) {
+        ts2.forEachChild(node, (child) => visit(child, caller));
+        return;
+      }
+      const planIndex = delta.functions.length;
+      delta.functions.push(collected);
+      const args2 = ts2.isArrowFunction(node) ? arrowArguments(node) : "arguments";
+      const asyncCallback = node.modifiers?.some(
+        (modifier) => modifier.kind === ts2.SyntaxKind.AsyncKeyword
+      ) ? "async " : "";
+      if (ts2.isBlock(node.body)) {
+        edits.push({
+          position: node.body.getStart(sourceFile) + 1,
+          text: `return ${runName}(${planIndex},${args2},${asyncCallback}()=>{`,
+          order: order++
+        });
+        edits.push({ position: node.body.end - 1, text: "});", order: order++ });
+      } else {
+        edits.push({
+          position: node.body.getStart(sourceFile),
+          text: `${runName}(${planIndex},${args2},${asyncCallback}()=>(`,
+          order: order++
+        });
+        edits.push({ position: node.body.end, text: "))", order: order++ });
+      }
+      ts2.forEachChild(node, (child) => visit(child, collected));
+      return;
+    }
+    if (caller && (ts2.isCallExpression(node) || ts2.isNewExpression(node))) {
+      const site = collectCallSite(node, caller, collectContext);
+      if (site) delta.callSites.push(site);
+    }
+    if (caller && ts2.isVariableDeclaration(node)) {
+      const destructure = collectParamDestructure(node, caller, collectContext);
+      if (destructure) delta.destructures.push(destructure);
+    }
+    ts2.forEachChild(node, (child) => visit(child, caller));
+  };
+  visit(sourceFile);
+  if (edits.length === 0) return void 0;
+  const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
+  edits.push({
+    position: shebangEnd,
+    text: modulePreamble(runName, plansName, JSON.stringify(delta.functions.map((fn) => fn.plan))),
+    order: -1
+  });
+  edits.sort((left, right) => right.position - left.position || right.order - left.order);
+  let transformed = source;
+  for (const edit of edits) {
+    transformed = `${transformed.slice(0, edit.position)}${edit.text}${transformed.slice(edit.position)}`;
+  }
+  return { code: transformed, delta };
+};
+
+// src/auto-instrumentation/instrument-compiled-esm.ts
+var compiledJavaScript = /\.[cm]?js$/i;
+var walkCompiledFiles = (directory) => {
+  const files = [];
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".rasputin" || entry.name === ".git") {
+      continue;
+    }
+    const path = join2(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkCompiledFiles(path));
+      continue;
+    }
+    if (compiledJavaScript.test(entry.name)) files.push(path);
+  }
+  return files;
+};
+var writeText = (path, contents) => {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, contents);
+};
+var instrumentCompiledDirectory = (options) => {
+  const inputDir = resolve5(options.inputDir);
+  const outputDir = resolve5(options.outputDir ?? inputDir);
+  const manifestPath = resolve5(
+    options.manifestPath ?? join2(outputDir, ".rasputin", "instrumentation-manifest.json")
+  );
+  const transformedFiles = [];
+  resetInstrumentationManifestRegistry();
+  for (const filePath of walkCompiledFiles(inputDir)) {
+    if (!isApplicationSource(filePath, {
+      includeBuildOutput: true,
+      excludedRoots: options.excludedRoots
+    })) {
+      continue;
+    }
+    const source = readFileSync2(filePath, "utf8");
+    if (source.includes("__rasputinRun__") || source.includes("__rasputinPlans__")) continue;
+    const transformed = transformSource(source, {
+      filePath,
+      mapLocation: createSourceMapLocationMapper(filePath, source)
+    });
+    if (!transformed) continue;
+    const outputPath = join2(outputDir, relative2(inputDir, filePath));
+    writeText(outputPath, transformed.code);
+    recordInstrumentationManifestDelta(filePath, transformed.delta);
+    transformedFiles.push(outputPath);
+  }
+  const manifest = snapshotInstrumentationManifest({
+    sourceRoot: options.sourceRoot,
+    sourceRoots: options.sourceRoots
+  });
+  if (manifest) {
+    writeText(manifestPath, `${JSON.stringify(manifest, null, "	")}
+`);
+  }
+  return { transformedFiles, manifest, manifestPath };
+};
+
+// src/auto-instrumentation/sdk-source-boundary.ts
+import { dirname as dirname3, resolve as resolve6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var sdkPackageScopeRootFrom = (instrumentEntryUrl) => resolve6(dirname3(fileURLToPath2(instrumentEntryUrl)), "../../..");
+
+// src/instrument/build.ts
+var printUsage = () => {
+  console.error("Usage: rasputin-instrument <input-dir> [--out <output-dir>] [--manifest <path>]");
+};
+var parseArgs = (argv) => {
+  const inputDir = argv.find((argument) => !argument.startsWith("--"));
+  const option = (name) => {
+    const index = argv.indexOf(name);
+    return index >= 0 ? argv[index + 1] : void 0;
+  };
+  return {
+    inputDir,
+    outputDir: option("--out"),
+    manifestPath: option("--manifest")
+  };
+};
+var args = parseArgs(process.argv.slice(2));
+if (!args.inputDir) {
+  printUsage();
+  process.exit(1);
+}
+var result = instrumentCompiledDirectory({
+  inputDir: args.inputDir,
+  outputDir: args.outputDir,
+  manifestPath: args.manifestPath,
+  excludedRoots: [sdkPackageScopeRootFrom(import.meta.url)]
+});
+console.info(
+  `[rasputin] instrumented ${result.transformedFiles.length} file${result.transformedFiles.length === 1 ? "" : "s"}`
+);
+if (result.manifest) {
+  console.info(`[rasputin] wrote ${result.manifestPath}`);
+}