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

package/dist/index.js

@@ -104,76 +104,38 @@ var runtimeLabel = () => {
 
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
 import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
 import {
   INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
   sourceLocatorFromFile as sourceLocatorFromFile2
 } from "@rasputin-ai/core";
 
-// src/execution-recorder/automatic-runtime.ts
+// src/execution-recorder/function-plan.ts
 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 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;
-  }
-};
-var getRegistry = () => {
-  const existing = Reflect.get(globalThis, runtimeSymbol);
-  if (existing?.__rasputinRuntimeRegistry && Array.isArray(existing.runtimes)) {
-    return existing;
-  }
-  const runtimes = [];
-  const registry = {
-    __rasputinRuntimeRegistry: true,
-    runtimes,
-    run: (sourceToken, args, callback) => {
-      const runtime = runtimes.at(-1);
-      return runtime ? runtime.run(sourceToken, args, callback) : callback();
-    }
-  };
-  Reflect.set(globalThis, runtimeSymbol, registry);
-  return registry;
-};
-var installAutomaticExecutionRuntime = (execution) => {
-  const registry = getRegistry();
-  const definitions = /* @__PURE__ */ new Map();
-  const runtime = {
-    run: (sourceToken, args, callback) => {
-      let definition = definitions.get(sourceToken);
-      if (!definitions.has(sourceToken)) {
-        definition = decodeAutomaticFunctionSource(sourceToken);
-        definitions.set(sourceToken, definition);
-      }
-      return definition ? execution.runFunction(definition, args, callback) : callback();
-    }
-  };
-  registry.runtimes.push(runtime);
-  return () => {
-    const index = registry.runtimes.lastIndexOf(runtime);
-    if (index >= 0) registry.runtimes.splice(index, 1);
+var EVENT_PAIR_BASE_ESTIMATED_BYTES = 512;
+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 } : {}
   };
 };
+var estimatedCallBytesFor = (functionId) => EVENT_PAIR_BASE_ESTIMATED_BYTES + Buffer.byteLength(functionId, "utf8") * 2;
 
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
 var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v2";
 var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
-var getRegistry2 = () => {
+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;
@@ -192,20 +154,46 @@ var sourceAt = (filePath, line, column) => {
   return source ? { ...source, line, column } : void 0;
 };
 var stableId = (kind, ...parts) => `${kind}_${createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 24)}`;
+var recordPrebuiltInstrumentationManifest = (manifest) => {
+  const registry = getRegistry();
+  registry.prebuilt = manifest;
+  registry.generation += 1;
+  registry.onDirty?.();
+};
+var loadInstrumentationManifestFile = (path) => {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.schema_version !== INSTRUMENTATION_MANIFEST_SCHEMA_VERSION) return false;
+    if (!Array.isArray(parsed.functions)) return false;
+    recordPrebuiltInstrumentationManifest(parsed);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var loadInstrumentationManifestIfPresent = (path) => {
+  if (!path || !existsSync(path)) return;
+  loadInstrumentationManifestFile(path);
+};
 var isInstrumentationManifestDirty = () => {
-  const registry = getRegistry2();
-  return registry.generation !== registry.uploadedGeneration && registry.files.size > 0;
+  const registry = getRegistry();
+  return registry.generation !== registry.uploadedGeneration && (registry.files.size > 0 || registry.prebuilt !== void 0);
+};
+var instrumentationManifestGeneration = () => getRegistry().generation;
+var instrumentationManifestModuleCount = () => {
+  const registry = getRegistry();
+  if (registry.files.size > 0) return registry.files.size;
+  if (!registry.prebuilt) return 0;
+  return new Set(registry.prebuilt.functions.map((fn) => fn.source.packageRelativePath)).size;
 };
-var instrumentationManifestGeneration = () => getRegistry2().generation;
-var instrumentationManifestModuleCount = () => getRegistry2().files.size;
 var snapshotInstrumentationManifest = (options = {}) => {
   const functions = [];
   const callSites = [];
   const destructures = [];
-  for (const delta of getRegistry2().files.values()) {
+  for (const delta of getRegistry().files.values()) {
     for (const fn of delta.functions) {
-      const definition = decodeAutomaticFunctionSource(fn.sourceToken);
-      if (!definition?.source) continue;
+      const definition = definitionFromEncodedPlan(fn.plan);
+      if (!definition.source) continue;
       functions.push({
         functionId: definition.functionId,
         source: definition.source,
@@ -218,19 +206,18 @@ var snapshotInstrumentationManifest = (options = {}) => {
       });
     }
     for (const site of delta.callSites) {
-      const caller = decodeAutomaticFunctionSource(site.callerSourceToken);
       const source = sourceAt(site.filePath, site.line, site.column);
-      if (!caller || !source) continue;
+      if (!source) continue;
       callSites.push({
         id: stableId(
           "cs",
-          caller.functionId,
+          site.callerFunctionId,
           source.packageName ?? "",
           source.packageRelativePath,
           site.line,
           site.column
         ),
-        callerFunctionId: caller.functionId,
+        callerFunctionId: site.callerFunctionId,
         calleeName: site.calleeName,
         calleeText: site.calleeText,
         source,
@@ -243,11 +230,10 @@ var snapshotInstrumentationManifest = (options = {}) => {
       });
     }
     for (const destructure of delta.destructures) {
-      const caller = decodeAutomaticFunctionSource(destructure.callerSourceToken);
       const source = sourceAt(destructure.filePath, destructure.line, destructure.column);
-      if (!caller || !source) continue;
+      if (!source) continue;
       destructures.push({
-        callerFunctionId: caller.functionId,
+        callerFunctionId: destructure.callerFunctionId,
         sourceParam: destructure.sourceParam,
         source,
         line: destructure.line,
@@ -256,6 +242,18 @@ var snapshotInstrumentationManifest = (options = {}) => {
       });
     }
   }
+  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;
   }
@@ -274,11 +272,11 @@ var snapshotInstrumentationManifest = (options = {}) => {
   };
 };
 var markInstrumentationManifestUploaded = (generation) => {
-  const registry = getRegistry2();
+  const registry = getRegistry();
   if (registry.generation === generation) registry.uploadedGeneration = generation;
 };
 var setInstrumentationManifestOnDirty = (onDirty) => {
-  getRegistry2().onDirty = onDirty;
+  getRegistry().onDirty = onDirty;
 };
 
 // src/auto-instrumentation/schedule-instrumentation-manifest-upload.ts
@@ -395,6 +393,7 @@ var CallAwareEventBuffer = class {
   }
   items = [];
   openCallIds = /* @__PURE__ */ new Set();
+  retainedSummaries = /* @__PURE__ */ new WeakSet();
   dropped = 0;
   canStartCall() {
     return this.items.length + this.openCallIds.size + 2 <= this.capacity;
@@ -417,8 +416,12 @@ var CallAwareEventBuffer = class {
       return false;
     }
     this.items.push(event);
+    if (event.type === "function_calls_suppressed") this.retainedSummaries.add(event);
     return true;
   }
+  hasSummary(event) {
+    return this.retainedSummaries.has(event);
+  }
   forceCompletedCall(enter, terminal) {
     while (this.items.length + this.openCallIds.size + 2 > this.capacity) {
       if (!this.evictCompletedLeafOrSummary()) {
@@ -432,14 +435,13 @@ var CallAwareEventBuffer = class {
   values() {
     return [...this.items];
   }
-  contains(target) {
-    return this.items.includes(target);
-  }
   evictCompletedLeafOrSummary() {
     const summaryIndex = this.items.findIndex(
       (event) => event.type === "function_calls_suppressed"
     );
     if (summaryIndex >= 0) {
+      const summary = this.items[summaryIndex];
+      if (summary) this.retainedSummaries.delete(summary);
       this.items.splice(summaryIndex, 1);
       this.dropped++;
       return true;
@@ -469,9 +471,7 @@ var CallAwareEventBuffer = class {
 };
 
 // src/execution-recorder/recorder-memory-budget.ts
-import { Buffer } from "node:buffer";
 var EXECUTION_BASE_ESTIMATED_BYTES = 1024;
-var EVENT_PAIR_BASE_ESTIMATED_BYTES = 512;
 var SUMMARY_EVENT_BASE_ESTIMATED_BYTES = 256;
 var VALUE_HEAP_ESTIMATE_MULTIPLIER = 2;
 var MEMORY_BUDGET_VALUE_MARKER = {
@@ -525,12 +525,11 @@ var RecorderMemoryBudget = class {
     }
     return serialized.value;
   }
-  reserveCall(allocation, functionId) {
+  reserveCall(allocation, estimatedBytes) {
     if (allocation.mode === "metadata-only") {
       this.dropEvents(allocation, 2);
       return false;
     }
-    const estimatedBytes = EVENT_PAIR_BASE_ESTIMATED_BYTES + Buffer.byteLength(functionId, "utf8") * 2;
     if (this.reserve(allocation, estimatedBytes)) return true;
     this.markPressure(allocation, "metadata-only");
     this.dropEvents(allocation, 2);
@@ -590,7 +589,7 @@ var RecorderMemoryBudget = class {
 
 // src/execution-recorder/safe-serialize.ts
 import { Buffer as Buffer2 } from "node:buffer";
-var DEFAULT_REDACT_KEYS = /* @__PURE__ */ new Set([
+var DEFAULT_REDACT_KEYS = [
   "password",
   "token",
   "authorization",
@@ -598,7 +597,7 @@ var DEFAULT_REDACT_KEYS = /* @__PURE__ */ new Set([
   "secret",
   "apikey",
   "creditcard"
-]);
+];
 var defaults = {
   maxDepth: 3,
   maxObjectKeys: 30,
@@ -615,135 +614,155 @@ var typeMarker = (type, value) => ({
   __rasputin_type: type,
   ...value === void 0 ? {} : { value }
 });
-var redact = (item, redactKeys, seen) => {
-  if (!item || typeof item !== "object") return item;
-  if (seen.has(item)) return item;
-  seen.add(item);
-  if (Array.isArray(item)) {
-    return item.map((entry) => redact(entry, redactKeys, seen));
-  }
-  for (const [key, child] of Object.entries(item)) {
-    item[key] = redactKeys.has(key.toLowerCase()) ? "[RASPUTIN_REDACTED]" : redact(child, redactKeys, seen);
-  }
-  return item;
-};
-var errorValue = (error, depth, seen, limits) => ({
-  __rasputin_type: "Error",
-  name: error.name,
-  message: serializeInner(error.message, depth + 1, seen, limits),
-  ...error.stack ? { stack: serializeInner(error.stack, depth + 1, seen, limits) } : {}
+var REDACTED = "[RASPUTIN_REDACTED]";
+var compileLimits = (options) => ({
+  maxDepth: options.maxDepth ?? defaults.maxDepth,
+  maxObjectKeys: options.maxObjectKeys ?? defaults.maxObjectKeys,
+  maxArrayElements: options.maxArrayElements ?? defaults.maxArrayElements,
+  maxStringLength: options.maxStringLength ?? defaults.maxStringLength,
+  maxSerializedValueBytes: options.maxSerializedValueBytes ?? defaults.maxSerializedValueBytes
 });
-var serializeInner = (value, depth, seen, limits) => {
-  if (value === null || typeof value === "boolean" || typeof value === "number") return value;
-  if (typeof value === "string") {
-    if (value.length <= limits.maxStringLength) return value;
-    return truncation("max_string_length", {
-      __original_length: value.length,
-      value: value.slice(0, limits.maxStringLength)
-    });
-  }
-  if (typeof value === "undefined") return typeMarker("undefined");
-  if (typeof value === "bigint") return typeMarker("bigint", value.toString());
-  if (typeof value === "symbol") return typeMarker("symbol", String(value));
-  if (typeof value === "function") return typeMarker("function", value.name || "anonymous");
-  if (depth >= limits.maxDepth) return truncation("max_depth");
-  if (typeof value !== "object") return typeMarker(typeof value);
-  if (seen.has(value)) return typeMarker("circular");
-  seen.add(value);
-  try {
-    if (value instanceof Error) return errorValue(value, depth, seen, limits);
-    if (value instanceof Date) return typeMarker("Date", value.toISOString());
-    if (Buffer2.isBuffer(value)) {
-      return typeMarker("Buffer", {
-        byteLength: value.byteLength,
-        base64: value.subarray(0, limits.maxStringLength).toString("base64"),
-        ...value.byteLength > limits.maxStringLength ? { __rasputin_truncated: true } : {}
+var compileRedactKeys = (options) => {
+  if (!options.redactKeys?.length) return new Set(DEFAULT_REDACT_KEYS);
+  return /* @__PURE__ */ new Set([...DEFAULT_REDACT_KEYS, ...options.redactKeys.map((key) => key.toLowerCase())]);
+};
+var createSafeSerializer = (options = {}) => {
+  const limits = compileLimits(options);
+  const redactKeys = compileRedactKeys(options);
+  const serializeInner = (value, depth, seen, metrics) => {
+    metrics.visitedNodes++;
+    if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+    if (typeof value === "string") {
+      if (value.length <= limits.maxStringLength) return value;
+      return truncation("max_string_length", {
+        __original_length: value.length,
+        value: value.slice(0, limits.maxStringLength)
       });
     }
-    if (value instanceof Promise) return typeMarker("Promise");
-    if (value instanceof Map) {
-      const entries = [];
-      for (const entry of value.entries()) {
-        if (entries.length >= limits.maxArrayElements) break;
-        entries.push([
-          serializeInner(entry[0], depth + 1, seen, limits),
-          serializeInner(entry[1], depth + 1, seen, limits)
-        ]);
+    if (typeof value === "undefined") return typeMarker("undefined");
+    if (typeof value === "bigint") return typeMarker("bigint", value.toString());
+    if (typeof value === "symbol") return typeMarker("symbol", String(value));
+    if (typeof value === "function") return typeMarker("function", value.name || "anonymous");
+    if (depth >= limits.maxDepth) return truncation("max_depth");
+    if (typeof value !== "object") return typeMarker(typeof value);
+    const tracking = seen ?? /* @__PURE__ */ new WeakSet();
+    if (tracking.has(value)) return typeMarker("circular");
+    tracking.add(value);
+    try {
+      if (value instanceof Error) {
+        return {
+          __rasputin_type: "Error",
+          name: value.name,
+          message: serializeInner(value.message, depth + 1, tracking, metrics),
+          ...value.stack ? { stack: serializeInner(value.stack, depth + 1, tracking, metrics) } : {}
+        };
       }
-      return {
-        __rasputin_type: "Map",
-        entries,
-        ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __original_length: value.size }) : {}
-      };
+      if (value instanceof Date) return typeMarker("Date", value.toISOString());
+      if (Buffer2.isBuffer(value)) {
+        return typeMarker("Buffer", {
+          byteLength: value.byteLength,
+          base64: value.subarray(0, limits.maxStringLength).toString("base64"),
+          ...value.byteLength > limits.maxStringLength ? { __rasputin_truncated: true } : {}
+        });
+      }
+      if (value instanceof Promise) return typeMarker("Promise");
+      if (value instanceof Map) {
+        const entries = [];
+        for (const entry of value.entries()) {
+          if (entries.length >= limits.maxArrayElements) break;
+          entries.push([
+            serializeInner(entry[0], depth + 1, tracking, metrics),
+            serializeInner(entry[1], depth + 1, tracking, metrics)
+          ]);
+        }
+        return {
+          __rasputin_type: "Map",
+          entries,
+          ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __original_length: value.size }) : {}
+        };
+      }
+      if (value instanceof Set) {
+        const items = [];
+        for (const item of value.values()) {
+          if (items.length >= limits.maxArrayElements) break;
+          items.push(serializeInner(item, depth + 1, tracking, metrics));
+        }
+        return {
+          __rasputin_type: "Set",
+          values: items,
+          ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __original_length: value.size }) : {}
+        };
+      }
+      if (Array.isArray(value)) {
+        const maxItems = value.length > limits.maxArrayElements ? limits.maxArrayElements - 1 : value.length;
+        const items = [];
+        for (let index = 0; index < maxItems; index++) {
+          items.push(serializeInner(value[index], depth + 1, tracking, metrics));
+        }
+        if (value.length > limits.maxArrayElements) {
+          items.push(truncation("max_array_elements", { __original_length: value.length }));
+        }
+        return items;
+      }
+      const prototype = Object.getPrototypeOf(value);
+      const serialized = {};
+      if (prototype && prototype !== Object.prototype) {
+        serialized.__rasputin_type = prototype.constructor?.name ?? "instance";
+      }
+      const keys = Object.keys(value);
+      const maxKeys = keys.length > limits.maxObjectKeys ? limits.maxObjectKeys - 1 : keys.length;
+      for (let index = 0; index < maxKeys; index++) {
+        const key = keys[index];
+        if (key === void 0) continue;
+        if (redactKeys.has(key.toLowerCase())) {
+          serialized[key] = REDACTED;
+          continue;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        serialized[key] = descriptor && "value" in descriptor ? serializeInner(descriptor.value, depth + 1, tracking, metrics) : typeMarker("accessor");
+      }
+      if (keys.length > limits.maxObjectKeys) {
+        Object.assign(
+          serialized,
+          truncation("max_object_keys", { __original_length: keys.length })
+        );
+      }
+      return serialized;
+    } catch (error) {
+      return typeMarker("unserializable", error instanceof Error ? error.message : void 0);
+    } finally {
+      tracking.delete(value);
     }
-    if (value instanceof Set) {
-      const items = [];
-      for (const item of value.values()) {
-        if (items.length >= limits.maxArrayElements) break;
-        items.push(serializeInner(item, depth + 1, seen, limits));
+  };
+  const serializeWithBytes = (value) => {
+    const metrics = { visitedNodes: 0 };
+    try {
+      const serialized = serializeInner(value, 0, void 0, metrics);
+      const bytes = Buffer2.byteLength(JSON.stringify(serialized), "utf8");
+      if (bytes <= limits.maxSerializedValueBytes) {
+        return { value: serialized, bytes, visitedNodes: metrics.visitedNodes };
       }
+      const bounded = truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
       return {
-        __rasputin_type: "Set",
-        values: items,
-        ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __original_length: value.size }) : {}
+        value: bounded,
+        bytes: Buffer2.byteLength(JSON.stringify(bounded), "utf8"),
+        visitedNodes: metrics.visitedNodes
+      };
+    } catch {
+      const failed = typeMarker("unserializable");
+      return {
+        value: failed,
+        bytes: Buffer2.byteLength(JSON.stringify(failed), "utf8"),
+        visitedNodes: metrics.visitedNodes
       };
     }
-    if (Array.isArray(value)) {
-      const maxItems = value.length > limits.maxArrayElements ? limits.maxArrayElements - 1 : value.length;
-      const items = value.slice(0, maxItems).map((item) => serializeInner(item, depth + 1, seen, limits));
-      if (value.length > limits.maxArrayElements) {
-        items.push(truncation("max_array_elements", { __original_length: value.length }));
-      }
-      return items;
-    }
-    const prototype = Object.getPrototypeOf(value);
-    const serialized = {};
-    if (prototype && prototype !== Object.prototype) {
-      serialized.__rasputin_type = prototype.constructor?.name ?? "instance";
-    }
-    const keys = Object.keys(value);
-    const maxKeys = keys.length > limits.maxObjectKeys ? limits.maxObjectKeys - 1 : keys.length;
-    for (const key of keys.slice(0, maxKeys)) {
-      const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      serialized[key] = descriptor && "value" in descriptor ? serializeInner(descriptor.value, depth + 1, seen, limits) : typeMarker("accessor");
-    }
-    if (keys.length > limits.maxObjectKeys) {
-      Object.assign(serialized, truncation("max_object_keys", { __original_length: keys.length }));
-    }
-    return serialized;
-  } catch (error) {
-    return typeMarker("unserializable", error instanceof Error ? error.message : void 0);
-  } finally {
-    seen.delete(value);
-  }
-};
-var safeSerializeWithBytes = (value, options = {}) => {
-  const limits = {
-    maxDepth: options.maxDepth ?? defaults.maxDepth,
-    maxObjectKeys: options.maxObjectKeys ?? defaults.maxObjectKeys,
-    maxArrayElements: options.maxArrayElements ?? defaults.maxArrayElements,
-    maxStringLength: options.maxStringLength ?? defaults.maxStringLength,
-    maxSerializedValueBytes: options.maxSerializedValueBytes ?? defaults.maxSerializedValueBytes
   };
-  try {
-    const redactKeys = /* @__PURE__ */ new Set([
-      ...DEFAULT_REDACT_KEYS,
-      ...(options.redactKeys ?? []).map((key) => key.toLowerCase())
-    ]);
-    const serialized = serializeInner(value, 0, /* @__PURE__ */ new WeakSet(), limits);
-    const redacted = redact(serialized, redactKeys, /* @__PURE__ */ new WeakSet());
-    const bytes = Buffer2.byteLength(JSON.stringify(redacted), "utf8");
-    const bounded = bytes <= limits.maxSerializedValueBytes ? redacted : truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
-    return {
-      value: bounded,
-      bytes: bounded === redacted ? bytes : Buffer2.byteLength(JSON.stringify(bounded), "utf8")
-    };
-  } catch {
-    const value2 = typeMarker("unserializable");
-    return { value: value2, bytes: Buffer2.byteLength(JSON.stringify(value2), "utf8") };
-  }
+  return {
+    serialize: (value) => serializeWithBytes(value).value,
+    serializeWithBytes
+  };
 };
-var safeSerialize = (value, options = {}) => safeSerializeWithBytes(value, options).value;
+var defaultSerializer = createSafeSerializer();
 
 // src/execution-recorder/source-exclusions.ts
 var sourcePathFrom = (definition) => definition.source?.packageRelativePath.replaceAll("\\", "/") ?? definition.name;
@@ -896,6 +915,30 @@ var observeRecordedCallback = (recording, recorderStartedAtNs, callback, onRetur
   recordExitWork(callbackEndedAtNs);
   return result;
 };
+var emptyStats = {
+  functionCallsObserved: 0,
+  functionCallsCaptured: 0,
+  functionCallsExcluded: 0,
+  serializedValues: 0,
+  serializedValueNodes: 0,
+  serializedValueBytes: 0,
+  errorSnapshots: 0,
+  successfulExecutionsDiscarded: 0,
+  truncatedEvents: 0,
+  repeatedCallsSuppressed: 0,
+  activeExecutions: 0,
+  peakActiveExecutions: 0,
+  memoryPressureExecutions: 0,
+  memoryPressureDegradations: 0,
+  valuesDroppedByMemoryBudget: 0,
+  eventsDroppedByMemoryBudget: 0,
+  partialErrorSnapshots: 0,
+  measuredExecutions: 0,
+  totalInlineWallTimeMs: 0,
+  maxInlineWallTimeMs: 0,
+  activeEstimatedBytes: 0,
+  peakActiveEstimatedBytes: 0
+};
 var noOpExecution = {
   createScope: () => ({
     run: (callback) => callback(),
@@ -906,22 +949,10 @@ var noOpExecution = {
   run: (_metadata, callback) => callback(),
   getErrorState: () => void 0,
   runFunction: (_functionId, _args, callback) => callback(),
+  runFunctionPlans: (_plans, _planIndex, _args, callback) => callback(),
+  runPreparedFunction: (_plan, _args, callback) => callback(),
   trace: (_functionId, fn) => fn,
-  getStats: () => ({
-    errorSnapshots: 0,
-    successfulExecutionsDiscarded: 0,
-    truncatedEvents: 0,
-    repeatedCallsSuppressed: 0,
-    activeExecutions: 0,
-    peakActiveExecutions: 0,
-    activeEstimatedBytes: 0,
-    peakActiveEstimatedBytes: 0,
-    memoryPressureExecutions: 0,
-    memoryPressureDegradations: 0,
-    valuesDroppedByMemoryBudget: 0,
-    eventsDroppedByMemoryBudget: 0,
-    partialErrorSnapshots: 0
-  })
+  getStats: () => ({ ...emptyStats })
 };
 var mergeExecutionMetadata = (target, metadata) => {
   if (metadata.kind) target.kind = metadata.kind;
@@ -944,21 +975,83 @@ var createExecutionRecorder = (options) => {
     maxActiveMemoryBytes,
     options.maxSerializedValueBytes ?? 8 * 1024
   );
+  const serializer = createSafeSerializer(options);
   const excludesSource = createSourceExclusionMatcher(options.excludeSources);
   let executionCounter = 0;
+  let nextRuntimePlanId = 1;
+  const internedPlans = /* @__PURE__ */ new Map();
+  const preparedModules = /* @__PURE__ */ new WeakMap();
   const errorExecutions = /* @__PURE__ */ new WeakMap();
   const stats = {
+    functionCallsObserved: 0,
+    functionCallsCaptured: 0,
+    functionCallsExcluded: 0,
+    serializedValues: 0,
+    serializedValueNodes: 0,
+    serializedValueBytes: 0,
     errorSnapshots: 0,
     successfulExecutionsDiscarded: 0,
     truncatedEvents: 0,
     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 serializeAndCount = (value) => {
+    const serialized = serializer.serializeWithBytes(value);
+    stats.serializedValues++;
+    stats.serializedValueNodes += serialized.visitedNodes;
+    stats.serializedValueBytes += serialized.bytes;
+    return serialized;
+  };
+  const captureValue = (recording, value) => memoryBudget.captureValue(recording.memory, () => serializeAndCount(value));
+  const preparePlan = (definition) => {
+    const existing = internedPlans.get(definition.functionId);
+    if (existing) return existing;
+    const plan = {
+      runtimePlanId: nextRuntimePlanId++,
+      definition,
+      functionId: definition.functionId,
+      excluded: excludesSource(definition),
+      estimatedCallBytes: estimatedCallBytesFor(definition.functionId)
+    };
+    internedPlans.set(definition.functionId, plan);
+    return plan;
+  };
+  const preparedPlansFor = (plans) => {
+    const cached = preparedModules.get(plans);
+    if (cached) return cached;
+    const prepared = plans.map((encoded) => {
+      const definition = definitionFromEncodedPlan(encoded);
+      return {
+        runtimePlanId: nextRuntimePlanId++,
+        definition,
+        functionId: definition.functionId,
+        excluded: excludesSource(definition),
+        estimatedCallBytes: estimatedCallBytesFor(definition.functionId)
+      };
+    });
+    preparedModules.set(plans, prepared);
+    return prepared;
   };
-  const captureValue = (recording, value) => memoryBudget.captureValue(recording.memory, () => safeSerializeWithBytes(value, options));
   const stateFrom = (recording, endedAtNs = process.hrtime.bigint()) => {
     const recorderStartedAtNs = process.hrtime.bigint();
+    for (const byParent of recording.repeatedCalls.values()) {
+      for (const group of byParent.values()) {
+        if (group.summary) {
+          group.summary.totalDurationMs = roundedMilliseconds(group.totalDurationNs);
+        }
+      }
+    }
     const events = recording.events.values().map((event) => event.type === "function_calls_suppressed" ? { ...event } : event);
     const referencedFunctionIds = new Set(
       events.flatMap(
@@ -1014,15 +1107,15 @@ var createExecutionRecorder = (options) => {
     recording.events.append(event);
     countDroppedEvents(recording, droppedBefore);
   };
-  const repeatedCallGroup = (recording, functionId, parentCallId) => {
-    let byParent = recording.repeatedCalls.get(functionId);
+  const repeatedCallGroup = (recording, runtimePlanId, parentCallId) => {
+    let byParent = recording.repeatedCalls.get(runtimePlanId);
     if (!byParent) {
       byParent = /* @__PURE__ */ new Map();
-      recording.repeatedCalls.set(functionId, byParent);
+      recording.repeatedCalls.set(runtimePlanId, byParent);
     }
     let group = byParent.get(parentCallId);
     if (!group) {
-      group = { observedCalls: 0 };
+      group = { observedCalls: 0, totalDurationNs: 0n };
       byParent.set(parentCallId, group);
     }
     return group;
@@ -1040,14 +1133,14 @@ var createExecutionRecorder = (options) => {
     return {
       // Keep the bounded thrown value even after surrounding capture degrades. A partial
       // snapshot without the exception itself would not be useful for investigation.
-      value: safeSerialize(error, options),
+      value: serializeAndCount(error).value,
       commit: () => {
         if (key) recording.capturedErrors.set(key, callId);
       }
     };
   };
-  const captureCompletedThrow = (recording, functionId, args, parentCallId, startedAtNs, startedAtMs, error) => {
-    if (!memoryBudget.reserveCall(recording.memory, functionId)) {
+  const captureCompletedThrow = (recording, plan, args, parentCallId, startedAtNs, startedAtMs, error) => {
+    if (!memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes)) {
       rememberError(error, recording);
       return;
     }
@@ -1056,7 +1149,7 @@ var createExecutionRecorder = (options) => {
     const enter = {
       type: "function_enter",
       callId,
-      functionId,
+      functionId: plan.functionId,
       timestampMs: startedAtMs,
       args: Array.from(args, (argument) => captureValue(recording, argument)),
       ...parentCallId === void 0 ? {} : { parentCallId }
@@ -1070,13 +1163,17 @@ var createExecutionRecorder = (options) => {
     };
     const droppedBefore = recording.events.dropped;
     const retained = recording.events.forceCompletedCall(enter, terminal);
-    if (retained) capturedError.commit();
+    if (retained) {
+      stats.functionCallsCaptured++;
+      capturedError.commit();
+    }
     countDroppedEvents(recording, droppedBefore);
     rememberError(error, recording);
   };
-  const recordSuppressedCall = (recording, group, functionId, parentCallId, startedAtMs, durationMs) => {
+  const recordSuppressedCall = (recording, group, functionId, parentCallId, startedAtMs, startedAtNs, endedAtNs) => {
     stats.repeatedCallsSuppressed++;
-    const endedAtMs = startedAtMs + durationMs;
+    group.totalDurationNs += endedAtNs - startedAtNs;
+    const endedAtMs = elapsedMs(recording.startedAtNs, endedAtNs);
     if (!group.summary) {
       group.summary = {
         type: "function_calls_suppressed",
@@ -1084,7 +1181,7 @@ var createExecutionRecorder = (options) => {
         timestampMs: startedAtMs,
         lastTimestampMs: endedAtMs,
         suppressedCallCount: 1,
-        totalDurationMs: durationMs,
+        totalDurationMs: 0,
         ...parentCallId === void 0 ? {} : { parentCallId }
       };
       appendStandaloneEvent(recording, group.summary);
@@ -1092,8 +1189,9 @@ var createExecutionRecorder = (options) => {
     }
     group.summary.lastTimestampMs = endedAtMs;
     group.summary.suppressedCallCount++;
-    group.summary.totalDurationMs = Math.round((group.summary.totalDurationMs + durationMs) * 1e4) / 1e4;
-    if (!recording.events.contains(group.summary)) appendStandaloneEvent(recording, group.summary);
+    if (!recording.events.hasSummary(group.summary)) {
+      appendStandaloneEvent(recording, group.summary);
+    }
   };
   const finish = (store, metadata) => {
     const { recording } = store;
@@ -1106,6 +1204,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();
@@ -1189,48 +1288,90 @@ var createExecutionRecorder = (options) => {
       return void 0;
     }
   };
-  const runFunction = (input, args, callback) => {
+  const runPreparedFunction = (plan, args, callback) => {
     const store = storage.getStore();
     if (!store || store.recording.finished) return callback();
-    const definition = normalizeFunctionDefinition(input);
-    const functionId = definition.functionId;
+    stats.functionCallsObserved++;
     const recorderStartedAtNs = process.hrtime.bigint();
-    if (store.suppressCapture || excludesSource(definition)) {
+    if (store.suppressCapture || plan.excluded) {
+      stats.functionCallsExcluded++;
       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);
+    const group = repeatedCallGroup(store.recording, plan.runtimePlanId, parentCallId);
     group.observedCalls++;
+    if (group.observedCalls === 1) {
+      store.recording.functions.set(plan.functionId, plan.definition);
+    }
     if (group.observedCalls > maxCapturedCallsPerFunction) {
       const startedAtNs2 = process.hrtime.bigint();
       const startedAtMs = elapsedMs(store.recording.startedAtNs, startedAtNs2);
-      const captureSuccess = () => recordSuppressedCall(
-        store.recording,
-        group,
-        functionId,
-        parentCallId,
-        startedAtMs,
-        elapsedMs(startedAtNs2)
-      );
-      return observeRecordedCallback(
-        store.recording,
-        recorderStartedAtNs,
-        callback,
-        captureSuccess,
-        (error) => captureCompletedThrow(
+      try {
+        const result = callback();
+        if (isPromiseLike(result)) {
+          addRecorderTime(store.recording, startedAtNs2 - recorderStartedAtNs);
+          return result.then(
+            (value) => {
+              const callbackEndedAtNs2 = process.hrtime.bigint();
+              recordSuppressedCall(
+                store.recording,
+                group,
+                plan.functionId,
+                parentCallId,
+                startedAtMs,
+                startedAtNs2,
+                callbackEndedAtNs2
+              );
+              addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              return value;
+            },
+            (error) => {
+              const callbackEndedAtNs2 = process.hrtime.bigint();
+              captureCompletedThrow(
+                store.recording,
+                plan,
+                args,
+                parentCallId,
+                startedAtNs2,
+                startedAtMs,
+                error
+              );
+              addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              throw error;
+            }
+          );
+        }
+        const callbackEndedAtNs = process.hrtime.bigint();
+        recordSuppressedCall(
+          store.recording,
+          group,
+          plan.functionId,
+          parentCallId,
+          startedAtMs,
+          startedAtNs2,
+          callbackEndedAtNs
+        );
+        addRecorderTime(store.recording, startedAtNs2 - recorderStartedAtNs);
+        addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs);
+        return result;
+      } catch (error) {
+        const callbackEndedAtNs = process.hrtime.bigint();
+        captureCompletedThrow(
           store.recording,
-          functionId,
+          plan,
           args,
           parentCallId,
           startedAtNs2,
           startedAtMs,
           error
-        )
-      );
+        );
+        addRecorderTime(store.recording, startedAtNs2 - recorderStartedAtNs);
+        addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs);
+        throw error;
+      }
     }
     const startedAtNs = process.hrtime.bigint();
     if (!store.recording.events.canStartCall()) {
@@ -1249,7 +1390,7 @@ var createExecutionRecorder = (options) => {
           captureSuccess,
           (error) => captureCompletedThrow(
             store.recording,
-            functionId,
+            plan,
             args,
             parentCallId,
             startedAtNs,
@@ -1259,7 +1400,7 @@ var createExecutionRecorder = (options) => {
         )
       );
     }
-    if (!memoryBudget.reserveCall(store.recording.memory, functionId)) {
+    if (!memoryBudget.reserveCall(store.recording.memory, plan.estimatedCallBytes)) {
       return observeRecordedCallback(
         store.recording,
         recorderStartedAtNs,
@@ -1273,7 +1414,7 @@ var createExecutionRecorder = (options) => {
     const enter = {
       type: "function_enter",
       callId,
-      functionId,
+      functionId: plan.functionId,
       timestampMs: elapsedMs(store.recording.startedAtNs),
       args: Array.from(args, (argument) => captureValue(store.recording, argument)),
       ...parentCallId === void 0 ? {} : { parentCallId }
@@ -1294,6 +1435,7 @@ var createExecutionRecorder = (options) => {
             durationMs: elapsedMs(startedAtNs),
             returnValue: captureValue(store.recording, value)
           });
+          stats.functionCallsCaptured++;
         },
         (error) => {
           const capturedError = serializedError(store.recording, error, callId);
@@ -1304,16 +1446,23 @@ var createExecutionRecorder = (options) => {
             durationMs: elapsedMs(startedAtNs),
             error: capturedError.value
           });
+          stats.functionCallsCaptured++;
           capturedError.commit();
           rememberError(error, store.recording);
         }
       )
     );
   };
+  const runFunction = (input, args, callback) => runPreparedFunction(preparePlan(normalizeFunctionDefinition(input)), args, callback);
+  const runFunctionPlans = (plans, planIndex, args, callback) => {
+    const plan = preparedPlansFor(plans)[planIndex];
+    return plan ? runPreparedFunction(plan, args, callback) : callback();
+  };
   function trace(input, fn) {
     const definition = typeof input === "string" ? manualFunctionDefinition(input) : { ...input, functionId: runtimeFunctionId2(input) };
+    const plan = preparePlan(definition);
     return function traced(...args) {
-      return runFunction(definition, args, () => fn.apply(this, args));
+      return runPreparedFunction(plan, args, () => fn.apply(this, args));
     };
   }
   return {
@@ -1321,11 +1470,51 @@ var createExecutionRecorder = (options) => {
     run,
     getErrorState,
     runFunction,
+    runFunctionPlans,
+    runPreparedFunction,
     trace,
     getStats: () => ({ ...stats, ...memoryBudget.getStats() })
   };
 };
 
+// src/execution-recorder/automatic-runtime.ts
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+var createRegistry = () => {
+  const runtimes = [];
+  return {
+    __rasputinRuntimeRegistry: true,
+    runtimes,
+    register(plans) {
+      return (planIndex, args, callback) => {
+        const runtime = runtimes.at(-1);
+        return runtime ? runtime.run(plans, planIndex, args, callback) : callback();
+      };
+    }
+  };
+};
+var getAutomaticRuntimeRegistry = () => {
+  const existing = Reflect.get(globalThis, runtimeSymbol);
+  if (existing && Array.isArray(existing.runtimes) && typeof existing.register === "function") {
+    existing.__rasputinRuntimeRegistry = true;
+    return existing;
+  }
+  const registry = createRegistry();
+  Reflect.set(globalThis, runtimeSymbol, registry);
+  return registry;
+};
+var installAutomaticExecutionRuntime = (execution) => {
+  const registry = getAutomaticRuntimeRegistry();
+  const runtime = {
+    run: (plans, planIndex, args, callback) => execution.runFunctionPlans(plans, planIndex, args, callback)
+  };
+  registry.runtimes.push(runtime);
+  return () => {
+    const index = registry.runtimes.lastIndexOf(runtime);
+    if (index >= 0) registry.runtimes.splice(index, 1);
+  };
+};
+
 // src/install-global-handlers.ts
 var removeProcessListener = process.off.bind(process);
 var installGlobalHandlers = (client, options = {}) => {
@@ -1375,6 +1564,7 @@ var installGlobalHandlers = (client, options = {}) => {
 };
 
 // src/rasputin-init.ts
+import { join } from "node:path";
 import {
   createClient,
   isClientEnabled
@@ -1382,7 +1572,7 @@ import {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/node";
-var SDK_VERSION = "0.4.0";
+var SDK_VERSION = "0.5.0-alpha.1";
 
 // src/rasputin-init.ts
 var withExecution = (client, execution, installRuntime, manifest) => {
@@ -1423,6 +1613,9 @@ var RasputinInit = (options) => {
       ...options.executionRecorder,
       enabled: recorderEnabled
     });
+    loadInstrumentationManifestIfPresent(
+      options.instrumentationManifestPath ?? process.env.RASPUTIN_INSTRUMENTATION_MANIFEST ?? join(process.cwd(), ".rasputin", "instrumentation-manifest.json")
+    );
     const wrappedClient = withExecution(client, execution, recorderEnabled, {
       projectApiKey: options.projectApiKey,
       release: options.release,