@rasputin-ai/node 0.3.0 → 0.4.1

package/dist/index.js

@@ -5,23 +5,133 @@ import {
   uploadInstrumentationManifest
 } from "@rasputin-ai/core";
 
+// src/auto-instrumentation/format-configuration-report.ts
+var RULE = "-".repeat(64);
+var BANNER = [
+  RULE,
+  " ____       _      ____    ____    _   _   _____   ___   _   _",
+  "|  _ \\     / \\    / ___|  |  _ \\  | | | | |_   _| |_ _| | \\ | |",
+  "| |_) |   / _ \\   \\___ \\  | |_) | | | | |   | |    | |  |  \\| |",
+  "|  _ <   / ___ \\   ___) | |  __/  | |_| |   | |    | |  | |\\  |",
+  "|_| \\_\\ /_/   \\_\\ |____/  |_|      \\___/    |_|   |___| |_| \\_|",
+  "",
+  "",
+  "CONFIGURATION:"
+];
+var counted = (n, singular, plural) => `${n} ${n === 1 ? singular : plural}`;
+var issueHeadline = (issue) => {
+  const target = issue.packageName ? `package ${issue.packageName}` : issue.packageRelativePath;
+  if (issue.reason === "ambiguous") return `Could not uniquely locate ${target}.`;
+  if (issue.reason === "not_found") return `Could not find ${target} in this Git release.`;
+  if (issue.reason === "invalid_mapping") {
+    return `The configured package root for ${target} does not match this Git release.`;
+  }
+  return `GitHub could not be reached while locating ${target}.`;
+};
+var formatIssue = (issue) => {
+  const lines = [
+    `! ${issueHeadline(issue)}`,
+    "",
+    "  Captured:",
+    `    ${issue.packageRelativePath}`
+  ];
+  if (issue.candidates?.length) {
+    lines.push("", "  Possible repository locations:");
+    for (const candidate of issue.candidates) lines.push(`    ${candidate}`);
+  }
+  return lines;
+};
+var formatConfigurationReport = (input) => {
+  const packages = input.verification.packages ?? [];
+  const unresolved = input.verification.unresolved;
+  const mappingIssues = unresolved.filter((issue) => issue.reason !== "github_unavailable");
+  const githubUnavailable = input.verification.status === "unavailable" || unresolved.some((issue) => issue.reason === "github_unavailable");
+  const verified = input.uploaded && input.verification.status === "verified";
+  const lines = [
+    ...BANNER,
+    "",
+    "Release",
+    `\u2713 ${input.release}`,
+    "",
+    "Runtime",
+    `\u2713 ${input.runtime}`,
+    "",
+    "Instrumentation",
+    `\u2713 ${counted(input.modules, "application module", "application modules")} observed`,
+    `\u2713 ${counted(input.functions, "function", "functions")} instrumented`,
+    `\u2713 ${counted(input.packageNames.length, "workspace package", "workspace packages")} detected`
+  ];
+  if (packages.length > 0 || mappingIssues.length > 0) {
+    lines.push("", "Package roots");
+    for (const mapping of packages) {
+      lines.push(
+        mapping.packageName ? `\u2713 ${mapping.packageName} \u2192 ${mapping.repositoryRoot}` : `\u2713 ${mapping.repositoryRoot}`
+      );
+    }
+    for (const [index, issue] of mappingIssues.entries()) {
+      if (packages.length > 0 || index > 0) lines.push("");
+      lines.push(...formatIssue(issue));
+    }
+  }
+  lines.push("", "Manifest");
+  if (!input.uploaded) {
+    lines.push("! upload failed");
+  } else {
+    lines.push("\u2713 uploaded");
+    lines.push(
+      verified ? "\u2713 verified against GitHub" : "! some source files could not be mapped to this Git release"
+    );
+  }
+  lines.push("", "GitHub");
+  if (!input.uploaded) {
+    lines.push("! not verified");
+  } else if (githubUnavailable) {
+    lines.push("! repository is not connected, or this release could not be read");
+  } else {
+    lines.push("\u2713 repository connected");
+  }
+  if (input.uploaded && input.verification.status !== "verified") {
+    lines.push("", "Runtime recording is unaffected.");
+  }
+  lines.push(RULE);
+  return lines.join("\n");
+};
+var runtimeLabel = () => {
+  const bun = globalThis.Bun;
+  if (typeof bun?.version === "string" && bun.version) return `Bun ${bun.version}`;
+  return `Node ${process.versions.node}`;
+};
+
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
-import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { createHash } from "node:crypto";
+import {
+  INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+  sourceLocatorFromFile as sourceLocatorFromFile2
+} from "@rasputin-ai/core";
 
 // src/execution-recorder/automatic-runtime.ts
-import { isAbsolute, relative, resolve, sep } from "node:path";
-var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v1";
-var AUTOMATIC_SOURCE_SEPARATOR = "\0";
+import {
+  runtimeFunctionId,
+  sourceLocatorFromFile
+} from "@rasputin-ai/core";
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
+var AUTOMATIC_SOURCE_PREFIX = "rasputin-source-v2:";
 var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
-var normalizeAutomaticFunctionId = (sourceToken, repoRoot) => {
-  if (!sourceToken.includes(AUTOMATIC_SOURCE_SEPARATOR)) return sourceToken;
-  const [filePath, name, line, column] = sourceToken.split(AUTOMATIC_SOURCE_SEPARATOR);
-  if (!filePath || !name || !line || !column) return void 0;
-  const fromRoot = relative(repoRoot, resolve(filePath));
-  if (!fromRoot || fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) {
+var decodeAutomaticFunctionSource = (sourceToken) => {
+  if (!sourceToken.startsWith(AUTOMATIC_SOURCE_PREFIX)) return void 0;
+  try {
+    const parsed = JSON.parse(
+      sourceToken.slice(AUTOMATIC_SOURCE_PREFIX.length)
+    );
+    if (typeof parsed.name !== "string" || !parsed.name) return void 0;
+    const definition = {
+      name: parsed.name,
+      ...parsed.source ? { source: parsed.source } : {}
+    };
+    return { ...definition, functionId: runtimeFunctionId(definition) };
+  } catch {
     return void 0;
   }
-  return `${fromRoot.replaceAll("\\", "/")}:${name}@${line}:${column}`;
 };
 var getRegistry = () => {
   const existing = Reflect.get(globalThis, runtimeSymbol);
@@ -32,30 +142,25 @@ var getRegistry = () => {
   const registry = {
     __rasputinRuntimeRegistry: true,
     runtimes,
-    run: (functionId, args, callback) => {
+    run: (sourceToken, args, callback) => {
       const runtime = runtimes.at(-1);
-      return runtime ? runtime.run(functionId, args, callback) : callback();
+      return runtime ? runtime.run(sourceToken, args, callback) : callback();
     }
   };
   Reflect.set(globalThis, runtimeSymbol, registry);
   return registry;
 };
-var installAutomaticExecutionRuntime = (execution, options = {}) => {
+var installAutomaticExecutionRuntime = (execution) => {
   const registry = getRegistry();
-  const repoRoot = options.repoRoot ? resolve(options.repoRoot) : void 0;
-  const normalizedIds = /* @__PURE__ */ new Map();
+  const definitions = /* @__PURE__ */ new Map();
   const runtime = {
     run: (sourceToken, args, callback) => {
-      if (!sourceToken.includes(AUTOMATIC_SOURCE_SEPARATOR)) {
-        return execution.runFunction(sourceToken, args, callback);
+      let definition = definitions.get(sourceToken);
+      if (!definitions.has(sourceToken)) {
+        definition = decodeAutomaticFunctionSource(sourceToken);
+        definitions.set(sourceToken, definition);
       }
-      if (!repoRoot) return callback();
-      let functionId = normalizedIds.get(sourceToken);
-      if (!normalizedIds.has(sourceToken)) {
-        functionId = normalizeAutomaticFunctionId(sourceToken, repoRoot);
-        normalizedIds.set(sourceToken, functionId);
-      }
-      return functionId ? execution.runFunction(functionId, args, callback) : callback();
+      return definition ? execution.runFunction(definition, args, callback) : callback();
     }
   };
   registry.runtimes.push(runtime);
@@ -66,7 +171,7 @@ var installAutomaticExecutionRuntime = (execution, options = {}) => {
 };
 
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
-var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v1";
+var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v2";
 var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
 var getRegistry2 = () => {
   const existing = Reflect.get(globalThis, registrySymbol);
@@ -82,31 +187,28 @@ var getRegistry2 = () => {
   Reflect.set(globalThis, registrySymbol, registry);
   return registry;
 };
-var repoRelativePath = (filePath, repoRoot) => {
-  const fromRoot = relative2(repoRoot, resolve2(filePath));
-  if (!fromRoot || fromRoot === ".." || fromRoot.startsWith(`..${sep2}`) || isAbsolute2(fromRoot)) {
-    return void 0;
-  }
-  return fromRoot.replaceAll("\\", "/");
+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 isInstrumentationManifestDirty = () => {
   const registry = getRegistry2();
   return registry.generation !== registry.uploadedGeneration && registry.files.size > 0;
 };
 var instrumentationManifestGeneration = () => getRegistry2().generation;
-var snapshotInstrumentationManifest = (repoRoot) => {
+var instrumentationManifestModuleCount = () => getRegistry2().files.size;
+var snapshotInstrumentationManifest = (options = {}) => {
   const functions = [];
   const callSites = [];
   const destructures = [];
-  const root = resolve2(repoRoot);
   for (const delta of getRegistry2().files.values()) {
     for (const fn of delta.functions) {
-      const functionId = normalizeAutomaticFunctionId(fn.sourceToken, root);
-      const path = repoRelativePath(fn.filePath, root);
-      if (!functionId || !path) continue;
+      const definition = decodeAutomaticFunctionSource(fn.sourceToken);
+      if (!definition?.source) continue;
       functions.push({
-        functionId,
-        path,
+        functionId: definition.functionId,
+        source: definition.source,
         name: fn.name,
         startLine: fn.startLine,
         startColumn: fn.startColumn,
@@ -116,15 +218,22 @@ var snapshotInstrumentationManifest = (repoRoot) => {
       });
     }
     for (const site of delta.callSites) {
-      const callerFunctionId = normalizeAutomaticFunctionId(site.callerSourceToken, root);
-      const path = repoRelativePath(site.filePath, root);
-      if (!callerFunctionId || !path) continue;
+      const caller = decodeAutomaticFunctionSource(site.callerSourceToken);
+      const source = sourceAt(site.filePath, site.line, site.column);
+      if (!caller || !source) continue;
       callSites.push({
-        id: `${path}:${site.line}:${site.column}`,
-        callerFunctionId,
+        id: stableId(
+          "cs",
+          caller.functionId,
+          source.packageName ?? "",
+          source.packageRelativePath,
+          site.line,
+          site.column
+        ),
+        callerFunctionId: caller.functionId,
         calleeName: site.calleeName,
         calleeText: site.calleeText,
-        path,
+        source,
         line: site.line,
         column: site.column,
         endLine: site.endLine,
@@ -134,13 +243,13 @@ var snapshotInstrumentationManifest = (repoRoot) => {
       });
     }
     for (const destructure of delta.destructures) {
-      const callerFunctionId = normalizeAutomaticFunctionId(destructure.callerSourceToken, root);
-      const path = repoRelativePath(destructure.filePath, root);
-      if (!callerFunctionId || !path) continue;
+      const caller = decodeAutomaticFunctionSource(destructure.callerSourceToken);
+      const source = sourceAt(destructure.filePath, destructure.line, destructure.column);
+      if (!caller || !source) continue;
       destructures.push({
-        callerFunctionId,
+        callerFunctionId: caller.functionId,
         sourceParam: destructure.sourceParam,
-        path,
+        source,
         line: destructure.line,
         column: destructure.column,
         binding: destructure.binding
@@ -150,8 +259,15 @@ var snapshotInstrumentationManifest = (repoRoot) => {
   if (functions.length === 0 && callSites.length === 0 && destructures.length === 0) {
     return void 0;
   }
+  const packages = { ...options.sourceRoots ?? {} };
   return {
-    schema_version: 1,
+    schema_version: INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+    ...options.sourceRoot || Object.keys(packages).length > 0 ? {
+      sourceRoots: {
+        ...options.sourceRoot ? { default: options.sourceRoot } : {},
+        packages
+      }
+    } : {},
     functions,
     callSites,
     destructures
@@ -159,35 +275,63 @@ var snapshotInstrumentationManifest = (repoRoot) => {
 };
 var markInstrumentationManifestUploaded = (generation) => {
   const registry = getRegistry2();
-  if (registry.generation === generation) {
-    registry.uploadedGeneration = generation;
-  }
+  if (registry.generation === generation) registry.uploadedGeneration = generation;
 };
 var setInstrumentationManifestOnDirty = (onDirty) => {
   getRegistry2().onDirty = onDirty;
 };
 
 // src/auto-instrumentation/schedule-instrumentation-manifest-upload.ts
+var unavailable = () => ({
+  status: "unavailable",
+  verified: 0,
+  unresolved: [],
+  packages: []
+});
 var noopHandle = {
   flushSoon() {
   },
   async wait() {
   },
   disconnect() {
+  },
+  async verify() {
+    return unavailable();
   }
 };
 var scheduleInstrumentationManifestUpload = (options) => {
   const release = detectRelease({ release: options.release });
-  const repoRoot = options.repoRoot;
-  if (!options.enabled || !release || !repoRoot || !options.projectApiKey.trim()) {
+  if (!options.enabled || !release || !options.projectApiKey.trim()) {
     return noopHandle;
   }
   const { instrumentationManifestUrl } = resolveEndpointUrls(options.apiUrl);
   let inflight;
+  let verification = unavailable();
+  let loggedSuccess = false;
+  let loggedFailure = false;
+  const packageNamesOf = (manifest) => [
+    ...new Set(
+      manifest.functions.map((fn) => fn.source.packageName).filter((name) => Boolean(name))
+    )
+  ].sort();
+  const report = (manifest, uploaded, next) => {
+    return formatConfigurationReport({
+      release,
+      runtime: runtimeLabel(),
+      modules: instrumentationManifestModuleCount(),
+      functions: manifest.functions.length,
+      packageNames: packageNamesOf(manifest),
+      verification: next,
+      uploaded
+    });
+  };
   const flushSoon = () => {
     if (!isInstrumentationManifestDirty()) return;
     const generation = instrumentationManifestGeneration();
-    const manifest = snapshotInstrumentationManifest(repoRoot);
+    const manifest = snapshotInstrumentationManifest({
+      sourceRoot: options.sourceRoot,
+      sourceRoots: options.sourceRoots
+    });
     if (!manifest) {
       markInstrumentationManifestUploaded(generation);
       return;
@@ -199,7 +343,26 @@ var scheduleInstrumentationManifestUpload = (options) => {
       manifest,
       fetch: options.fetch
     }).then((result) => {
-      if (result === "ok") markInstrumentationManifestUploaded(generation);
+      if (result.ok) {
+        verification = result.verification;
+        markInstrumentationManifestUploaded(generation);
+        if (verification.status === "verified") {
+          if (!loggedSuccess && options.logSuccess !== false) {
+            loggedSuccess = true;
+            console.info(report(manifest, true, verification));
+          }
+          return;
+        }
+        if (!loggedFailure) {
+          loggedFailure = true;
+          console.warn(report(manifest, true, verification));
+        }
+        return;
+      }
+      if (!loggedFailure) {
+        loggedFailure = true;
+        console.warn(report(manifest, false, unavailable()));
+      }
     });
     inflight = inflight ? inflight.then(() => work) : work;
   };
@@ -212,12 +375,18 @@ var scheduleInstrumentationManifestUpload = (options) => {
     },
     disconnect: () => {
       setInstrumentationManifestOnDirty(void 0);
+    },
+    verify: async () => {
+      flushSoon();
+      await inflight;
+      return verification;
     }
   };
 };
 
 // src/execution-recorder/execution-recorder.ts
 import { AsyncLocalStorage } from "node:async_hooks";
+import { runtimeFunctionId as runtimeFunctionId2 } from "@rasputin-ai/core";
 
 // src/execution-recorder/call-aware-event-buffer.ts
 var CallAwareEventBuffer = class {
@@ -577,9 +746,10 @@ var safeSerializeWithBytes = (value, options = {}) => {
 var safeSerialize = (value, options = {}) => safeSerializeWithBytes(value, options).value;
 
 // src/execution-recorder/source-exclusions.ts
-var sourcePathFrom = (functionId) => {
-  const separator = functionId.indexOf(":");
-  return (separator < 0 ? functionId : functionId.slice(0, separator)).replaceAll("\\", "/");
+var sourcePathFrom = (definition) => definition.source?.packageRelativePath.replaceAll("\\", "/") ?? definition.name;
+var searchableIdentity = (definition) => {
+  const source = definition.source;
+  return source ? `${source.packageName ? `${source.packageName}:` : ""}${source.packageRelativePath}:${definition.name}@${source.line ?? ""}:${source.column ?? ""}` : definition.name;
 };
 var normalizePattern = (pattern) => pattern.trim().replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
 var globRegex = (pattern) => {
@@ -610,35 +780,51 @@ var globRegex = (pattern) => {
   return new RegExp(`^${expression}$`);
 };
 var createSourceExclusionMatcher = (exclusions) => {
-  const matchers = (exclusions ?? []).flatMap((exclusion) => {
-    if (exclusion instanceof RegExp) {
+  const matchers = (exclusions ?? []).flatMap(
+    (exclusion) => {
+      if (exclusion instanceof RegExp) {
+        return [
+          (definition) => {
+            exclusion.lastIndex = 0;
+            const matched = exclusion.test(searchableIdentity(definition));
+            exclusion.lastIndex = 0;
+            return matched;
+          }
+        ];
+      }
+      const pattern = normalizePattern(exclusion);
+      if (!pattern) return [];
+      if (pattern.includes("*") || pattern.includes("?")) {
+        const regex = globRegex(pattern);
+        return [(definition) => regex.test(sourcePathFrom(definition))];
+      }
       return [
-        (functionId) => {
-          exclusion.lastIndex = 0;
-          const matched = exclusion.test(functionId);
-          exclusion.lastIndex = 0;
-          return matched;
+        (definition) => {
+          const sourcePath = sourcePathFrom(definition);
+          return sourcePath === pattern || sourcePath.startsWith(`${pattern}/`);
         }
       ];
     }
-    const pattern = normalizePattern(exclusion);
-    if (!pattern) return [];
-    if (pattern.includes("*") || pattern.includes("?")) {
-      const regex = globRegex(pattern);
-      return [(functionId) => regex.test(sourcePathFrom(functionId))];
-    }
-    return [
-      (functionId) => {
-        const sourcePath = sourcePathFrom(functionId);
-        return sourcePath === pattern || sourcePath.startsWith(`${pattern}/`);
-      }
-    ];
-  });
-  return matchers.length === 0 ? () => false : (functionId) => matchers.some((matcher) => matcher(functionId));
+  );
+  return matchers.length === 0 ? () => false : (definition) => matchers.some((matcher) => matcher(definition));
 };
 
 // src/execution-recorder/execution-recorder.ts
 var DEFAULT_MAX_ACTIVE_MEMORY_BYTES = 64 * 1024 * 1024;
+var manualFunctionDefinition = (value) => {
+  const located = /^(.+):([^:@]+)@(\d+):(\d+)$/.exec(value);
+  const named = located ? void 0 : /^(.+):([^:@]+)$/.exec(value);
+  const path = located?.[1] ?? named?.[1];
+  const name = located?.[2] ?? named?.[2] ?? value;
+  const source = path ? {
+    packageRelativePath: path.replaceAll("\\", "/").replace(/^\.\//, ""),
+    ...located?.[3] ? { line: Number(located[3]) } : {},
+    ...located?.[4] ? { column: Number(located[4]) } : {}
+  } : void 0;
+  const definition = { name, ...source ? { source } : {} };
+  return { ...definition, functionId: runtimeFunctionId2(definition) };
+};
+var normalizeFunctionDefinition = (value) => typeof value === "string" ? manualFunctionDefinition(value) : value;
 var elapsedMs = (startedAtNs, endedAtNs = process.hrtime.bigint()) => Number(endedAtNs - startedAtNs) / 1e6;
 var roundedMilliseconds = (nanoseconds) => Math.round(Number(nanoseconds) / 1e6 * 1e4) / 1e4;
 var addRecorderTime = (recording, nanoseconds) => {
@@ -734,7 +920,10 @@ var noOpExecution = {
     memoryPressureDegradations: 0,
     valuesDroppedByMemoryBudget: 0,
     eventsDroppedByMemoryBudget: 0,
-    partialErrorSnapshots: 0
+    partialErrorSnapshots: 0,
+    measuredExecutions: 0,
+    totalInlineWallTimeMs: 0,
+    maxInlineWallTimeMs: 0
   })
 };
 var mergeExecutionMetadata = (target, metadata) => {
@@ -768,13 +957,28 @@ var createExecutionRecorder = (options) => {
     repeatedCallsSuppressed: 0,
     activeExecutions: 0,
     peakActiveExecutions: 0,
-    partialErrorSnapshots: 0
+    partialErrorSnapshots: 0,
+    measuredExecutions: 0,
+    totalInlineWallTimeMs: 0,
+    maxInlineWallTimeMs: 0
+  };
+  const recordInlineTiming = (recording) => {
+    const inlineWallTimeMs = roundedMilliseconds(recording.inlineRecorderTimeNs);
+    stats.measuredExecutions++;
+    stats.totalInlineWallTimeMs = Math.round((stats.totalInlineWallTimeMs + inlineWallTimeMs) * 1e4) / 1e4;
+    stats.maxInlineWallTimeMs = Math.max(stats.maxInlineWallTimeMs, inlineWallTimeMs);
   };
   const captureValue = (recording, value) => memoryBudget.captureValue(recording.memory, () => safeSerializeWithBytes(value, options));
   const stateFrom = (recording, endedAtNs = process.hrtime.bigint()) => {
     const recorderStartedAtNs = process.hrtime.bigint();
+    const events = recording.events.values().map((event) => event.type === "function_calls_suppressed" ? { ...event } : event);
+    const referencedFunctionIds = new Set(
+      events.flatMap(
+        (event) => event.type === "function_enter" || event.type === "function_calls_suppressed" ? [event.functionId] : []
+      )
+    );
     const state = {
-      version: 1,
+      version: 2,
       executionId: recording.executionId,
       startedAt: recording.startedAt,
       durationMs: elapsedMs(recording.startedAtNs, endedAtNs),
@@ -783,7 +987,10 @@ var createExecutionRecorder = (options) => {
         ...recording.execution,
         ...recording.execution.request ? { request: { ...recording.execution.request } } : {}
       },
-      events: recording.events.values().map((event) => event.type === "function_calls_suppressed" ? { ...event } : event),
+      functions: [...recording.functions.values()].filter(
+        (definition) => referencedFunctionIds.has(definition.functionId)
+      ),
+      events,
       ...recording.events.dropped > 0 ? { truncated: { eventsDropped: recording.events.dropped } } : {},
       ...recording.memory.underPressure ? {
         capture: {
@@ -911,6 +1118,7 @@ var createExecutionRecorder = (options) => {
     if (!recording.hasError) stats.successfulExecutionsDiscarded++;
     recording.finishedAtNs = process.hrtime.bigint();
     addRecorderTime(recording, recording.finishedAtNs - recorderStartedAtNs);
+    recordInlineTiming(recording);
   };
   const createScope = (metadata) => {
     const recorderStartedAtNs = process.hrtime.bigint();
@@ -925,6 +1133,7 @@ var createExecutionRecorder = (options) => {
           ...metadata.request ? { request: { ...metadata.request } } : {}
         },
         events: new CallAwareEventBuffer(maxEventsPerExecution),
+        functions: /* @__PURE__ */ new Map(),
         repeatedCalls: /* @__PURE__ */ new Map(),
         capturedErrors: /* @__PURE__ */ new WeakMap(),
         nextCallId: 0,
@@ -993,16 +1202,19 @@ var createExecutionRecorder = (options) => {
       return void 0;
     }
   };
-  const runFunction = (functionId, args, callback) => {
+  const runFunction = (input, args, callback) => {
     const store = storage.getStore();
     if (!store || store.recording.finished) return callback();
+    const definition = normalizeFunctionDefinition(input);
+    const functionId = definition.functionId;
     const recorderStartedAtNs = process.hrtime.bigint();
-    if (store.suppressCapture || excludesSource(functionId)) {
+    if (store.suppressCapture || excludesSource(definition)) {
       return storage.run({ ...store, suppressCapture: true }, () => {
         addRecorderTime(store.recording, process.hrtime.bigint() - recorderStartedAtNs);
         return callback();
       });
     }
+    store.recording.functions.set(functionId, definition);
     const parentCallId = store.currentCallId;
     const group = repeatedCallGroup(store.recording, functionId, parentCallId);
     group.observedCalls++;
@@ -1111,9 +1323,10 @@ var createExecutionRecorder = (options) => {
       )
     );
   };
-  function trace(functionId, fn) {
+  function trace(input, fn) {
+    const definition = typeof input === "string" ? manualFunctionDefinition(input) : { ...input, functionId: runtimeFunctionId2(input) };
     return function traced(...args) {
-      return runFunction(functionId, args, () => fn.apply(this, args));
+      return runFunction(definition, args, () => fn.apply(this, args));
     };
   }
   return {
@@ -1177,26 +1390,23 @@ var installGlobalHandlers = (client, options = {}) => {
 // src/rasputin-init.ts
 import {
   createClient,
-  isClientEnabled,
-  resolveRepoRoot
+  isClientEnabled
 } from "@rasputin-ai/core";
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/node";
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.4.1";
 
 // src/rasputin-init.ts
-var withExecution = (client, execution, installRuntime, repoRoot, manifest) => {
-  const uninstallRuntime = installRuntime ? installAutomaticExecutionRuntime(execution, { repoRoot }) : () => {
+var withExecution = (client, execution, installRuntime, manifest) => {
+  const uninstallRuntime = installRuntime ? installAutomaticExecutionRuntime(execution) : () => {
   };
-  const manifestUpload = scheduleInstrumentationManifestUpload({
-    ...manifest,
-    repoRoot
-  });
+  const manifestUpload = scheduleInstrumentationManifestUpload(manifest);
   return {
     ...client,
     execution,
     getStats: () => ({ ...client.getStats(), recorder: execution.getStats() }),
+    verifyConfiguration: manifestUpload.verify,
     captureException: (error, context) => {
       const runtimeState = context?.runtimeState ?? execution.getErrorState(
         error,
@@ -1226,18 +1436,15 @@ var RasputinInit = (options) => {
       ...options.executionRecorder,
       enabled: recorderEnabled
     });
-    const wrappedClient = withExecution(
-      client,
-      execution,
-      recorderEnabled,
-      resolveRepoRoot(options),
-      {
-        projectApiKey: options.projectApiKey,
-        release: options.release,
-        apiUrl: options.apiUrl,
-        enabled: isClientEnabled(options)
-      }
-    );
+    const wrappedClient = withExecution(client, execution, recorderEnabled, {
+      projectApiKey: options.projectApiKey,
+      release: options.release,
+      apiUrl: options.apiUrl,
+      enabled: isClientEnabled(options),
+      sourceRoot: options.sourceRoot,
+      sourceRoots: options.sourceRoots,
+      logSuccess: options.logSuccess
+    });
     if (isClientEnabled(options)) {
       installGlobalHandlers(wrappedClient);
     }
@@ -1247,12 +1454,14 @@ var RasputinInit = (options) => {
       createClient({ ...options, enabled: false }),
       createExecutionRecorder({ enabled: false }),
       false,
-      void 0,
       {
         projectApiKey: options.projectApiKey,
         release: options.release,
         apiUrl: options.apiUrl,
-        enabled: false
+        enabled: false,
+        sourceRoot: options.sourceRoot,
+        sourceRoots: options.sourceRoots,
+        logSuccess: options.logSuccess
       }
     );
   }