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

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
@@ -389,6 +387,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { runtimeFunctionId as runtimeFunctionId2 } from "@rasputin-ai/core";
 
 // src/execution-recorder/call-aware-event-buffer.ts
+var isSuppressionPlaceholder = (item) => "kind" in item && item.kind === "suppressed";
 var CallAwareEventBuffer = class {
   constructor(capacity) {
     this.capacity = capacity;
@@ -411,12 +410,14 @@ var CallAwareEventBuffer = class {
   dropCall() {
     this.dropped += 2;
   }
-  append(event) {
+  appendSuppressed(group) {
     if (this.items.length + this.openCallIds.size + 1 > this.capacity) {
       this.dropped++;
       return false;
     }
-    this.items.push(event);
+    const placeholder = { kind: "suppressed", group };
+    this.items.push(placeholder);
+    group.retainedSlot = placeholder;
     return true;
   }
   forceCompletedCall(enter, terminal) {
@@ -432,31 +433,27 @@ 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"
-    );
+    const summaryIndex = this.items.findIndex((item) => isSuppressionPlaceholder(item));
     if (summaryIndex >= 0) {
+      const summary = this.items[summaryIndex];
+      if (summary && isSuppressionPlaceholder(summary)) summary.group.retainedSlot = void 0;
       this.items.splice(summaryIndex, 1);
       this.dropped++;
       return true;
     }
     const parentCallIds = /* @__PURE__ */ new Set();
-    for (const event of this.items) {
-      if ((event.type === "function_enter" || event.type === "function_calls_suppressed") && event.parentCallId !== void 0) {
-        parentCallIds.add(event.parentCallId);
-      }
+    for (const item of this.items) {
+      const parentCallId = isSuppressionPlaceholder(item) ? item.group.parentCallId : item.type === "function_enter" ? item.parentCallId : void 0;
+      if (parentCallId !== void 0) parentCallIds.add(parentCallId);
     }
     for (let index = 0; index < this.items.length; index++) {
       const event = this.items[index];
-      if (event?.type !== "function_enter" || this.openCallIds.has(event.callId) || parentCallIds.has(event.callId)) {
+      if (!event || isSuppressionPlaceholder(event) || event.type !== "function_enter" || this.openCallIds.has(event.callId) || parentCallIds.has(event.callId)) {
         continue;
       }
       const terminalIndex = this.items.findIndex(
-        (candidate) => (candidate.type === "function_exit" || candidate.type === "function_throw") && candidate.callId === event.callId
+        (candidate) => !isSuppressionPlaceholder(candidate) && (candidate.type === "function_exit" || candidate.type === "function_throw") && candidate.callId === event.callId
       );
       if (terminalIndex < 0) continue;
       this.items.splice(Math.max(index, terminalIndex), 1);
@@ -469,9 +466,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 +520,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 +584,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 +592,7 @@ var DEFAULT_REDACT_KEYS = /* @__PURE__ */ new Set([
   "secret",
   "apikey",
   "creditcard"
-]);
+];
 var defaults = {
   maxDepth: 3,
   maxObjectKeys: 30,
@@ -606,6 +600,10 @@ var defaults = {
   maxStringLength: 500,
   maxSerializedValueBytes: 8 * 1024
 };
+var TYPE_MARKER_OPEN = '{"__rasputin_type":"';
+var TYPE_MARKER_VALUE_MID = '","value":"';
+var TYPE_MARKER_CLOSE = '"}';
+var UNDEFINED_MARKER_BYTES = TYPE_MARKER_OPEN.length + "undefined".length + TYPE_MARKER_CLOSE.length;
 var truncation = (reason, extra = {}) => ({
   __rasputin_truncated: true,
   __reason: reason,
@@ -615,135 +613,224 @@ 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);
+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 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 isJsonSafeString = (value) => {
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 32 || code === 34 || code === 92) return false;
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (index + 1 >= value.length || next < 56320 || next > 57343) return false;
+      index++;
+      continue;
+    }
+    if (code >= 56320 && code <= 57343) return false;
   }
-  return item;
+  return true;
 };
-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 serializeInner = (value, depth, seen, limits) => {
-  if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+var typeMarkerWithValueBytes = (type, jsonSafeValue) => TYPE_MARKER_OPEN.length + type.length + TYPE_MARKER_VALUE_MID.length + Buffer2.byteLength(jsonSafeValue, "utf8") + TYPE_MARKER_CLOSE.length;
+var primitiveFastPath = (value, maxStringLength) => {
+  if (value === null) return { value: null, bytes: 4, visitedNodes: 1 };
+  if (typeof value === "boolean") return { value, bytes: value ? 4 : 5, visitedNodes: 1 };
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return { value, bytes: 4, visitedNodes: 1 };
+    if (Object.is(value, -0)) return { value, bytes: 1, visitedNodes: 1 };
+    return { value, bytes: String(value).length, visitedNodes: 1 };
+  }
   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.length > maxStringLength || !isJsonSafeString(value)) return void 0;
+    return { value, bytes: 2 + Buffer2.byteLength(value, "utf8"), visitedNodes: 1 };
   }
-  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 } : {}
+  if (typeof value === "undefined") {
+    return {
+      value: { __rasputin_type: "undefined" },
+      bytes: UNDEFINED_MARKER_BYTES,
+      visitedNodes: 1
+    };
+  }
+  if (typeof value === "bigint") {
+    const digits = value.toString();
+    return {
+      value: { __rasputin_type: "bigint", value: digits },
+      bytes: typeMarkerWithValueBytes("bigint", digits),
+      visitedNodes: 1
+    };
+  }
+  if (typeof value === "symbol") {
+    const text = String(value);
+    if (!isJsonSafeString(text)) return void 0;
+    return {
+      value: { __rasputin_type: "symbol", value: text },
+      bytes: typeMarkerWithValueBytes("symbol", text),
+      visitedNodes: 1
+    };
+  }
+  if (typeof value === "function") {
+    const name = value.name || "anonymous";
+    if (!isJsonSafeString(name)) return void 0;
+    return {
+      value: { __rasputin_type: "function", value: name },
+      bytes: typeMarkerWithValueBytes("function", name),
+      visitedNodes: 1
+    };
+  }
+  return void 0;
+};
+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 Set) {
-      const items = [];
-      for (const item of value.values()) {
-        if (items.length >= limits.maxArrayElements) break;
-        items.push(serializeInner(item, depth + 1, 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 } : {}
+        });
       }
-      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 = 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 }));
+      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 }) : {}
+        };
       }
-      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 }));
+      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);
     }
-    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 });
+  const boundedOversize = (bytes, visitedNodes) => {
+    const bounded = truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
     return {
       value: bounded,
-      bytes: bounded === redacted ? bytes : Buffer2.byteLength(JSON.stringify(bounded), "utf8")
+      bytes: Buffer2.byteLength(JSON.stringify(bounded), "utf8"),
+      visitedNodes
     };
-  } catch {
-    const value2 = typeMarker("unserializable");
-    return { value: value2, bytes: Buffer2.byteLength(JSON.stringify(value2), "utf8") };
-  }
+  };
+  const serializeWithBytes = (value) => {
+    const fast = primitiveFastPath(value, limits.maxStringLength);
+    if (fast) {
+      return fast.bytes <= limits.maxSerializedValueBytes ? fast : boundedOversize(fast.bytes, fast.visitedNodes);
+    }
+    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 };
+      }
+      return boundedOversize(bytes, metrics.visitedNodes);
+    } catch {
+      const failed = typeMarker("unserializable");
+      return {
+        value: failed,
+        bytes: Buffer2.byteLength(JSON.stringify(failed), "utf8"),
+        visitedNodes: metrics.visitedNodes
+      };
+    }
+  };
+  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 +983,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,25 +1017,11 @@ var noOpExecution = {
   run: (_metadata, callback) => callback(),
   getErrorState: () => void 0,
   runFunction: (_functionId, _args, callback) => callback(),
+  runFunctionPlans: (_plans, _planIndex, _args, callback) => callback(),
+  prepareFunctionPlans: () => [],
+  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,
-    measuredExecutions: 0,
-    totalInlineWallTimeMs: 0,
-    maxInlineWallTimeMs: 0
-  })
+  getStats: () => ({ ...emptyStats })
 };
 var mergeExecutionMetadata = (target, metadata) => {
   if (metadata.kind) target.kind = metadata.kind;
@@ -947,10 +1044,20 @@ 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,
@@ -968,10 +1075,57 @@ var createExecutionRecorder = (options) => {
     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 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 snapshotSuppressed = (group, startedAtNs) => ({
+    type: "function_calls_suppressed",
+    functionId: group.functionId,
+    timestampMs: elapsedMs(startedAtNs, group.firstTimestampNs),
+    lastTimestampMs: elapsedMs(startedAtNs, group.lastTimestampNs),
+    suppressedCallCount: group.count,
+    totalDurationMs: roundedMilliseconds(group.totalDurationNs),
+    ...group.parentCallId === void 0 ? {} : { parentCallId: group.parentCallId }
+  });
   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 events = recording.events.values().map(
+      (item) => isSuppressionPlaceholder(item) ? snapshotSuppressed(item.group, recording.startedAtNs) : item
+    );
     const referencedFunctionIds = new Set(
       events.flatMap(
         (event) => event.type === "function_enter" || event.type === "function_calls_suppressed" ? [event.functionId] : []
@@ -1020,18 +1174,25 @@ var createExecutionRecorder = (options) => {
   const countDroppedEvents = (recording, droppedBefore) => {
     stats.truncatedEvents += recording.events.dropped - droppedBefore;
   };
-  const appendStandaloneEvent = (recording, event) => {
+  const appendSuppressedPlaceholder = (recording, group) => {
     if (!memoryBudget.reserveStandaloneEvent(recording.memory)) return;
     const droppedBefore = recording.events.dropped;
-    recording.events.append(event);
+    recording.events.appendSuppressed(group);
     countDroppedEvents(recording, droppedBefore);
   };
-  const repeatedCallGroup = (recording, functionId, parentCallId) => {
-    let byParent = recording.repeatedCalls.get(functionId);
-    if (!byParent) {
-      byParent = /* @__PURE__ */ new Map();
-      recording.repeatedCalls.set(functionId, byParent);
+  const repeatedCallGroup = (recording, runtimePlanId, parentCallId) => {
+    const slots = recording.repeatedCalls;
+    let slot = slots[runtimePlanId];
+    if (!slot) {
+      slot = {};
+      slots[runtimePlanId] = slot;
+    }
+    if (parentCallId === void 0) {
+      if (!slot.root) slot.root = { observedCalls: 0 };
+      return slot.root;
     }
+    if (!slot.byParent) slot.byParent = /* @__PURE__ */ new Map();
+    const byParent = slot.byParent;
     let group = byParent.get(parentCallId);
     if (!group) {
       group = { observedCalls: 0 };
@@ -1052,14 +1213,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, error) => {
+    if (!memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes)) {
       rememberError(error, recording);
       return;
     }
@@ -1068,8 +1229,8 @@ var createExecutionRecorder = (options) => {
     const enter = {
       type: "function_enter",
       callId,
-      functionId,
-      timestampMs: startedAtMs,
+      functionId: plan.functionId,
+      timestampMs: elapsedMs(recording.startedAtNs, startedAtNs),
       args: Array.from(args, (argument) => captureValue(recording, argument)),
       ...parentCallId === void 0 ? {} : { parentCallId }
     };
@@ -1082,30 +1243,35 @@ 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, startedAtNs, endedAtNs) => {
     stats.repeatedCallsSuppressed++;
-    const endedAtMs = startedAtMs + durationMs;
-    if (!group.summary) {
-      group.summary = {
-        type: "function_calls_suppressed",
+    const durationNs = endedAtNs - startedAtNs;
+    if (!group.suppressed) {
+      group.suppressed = {
+        count: 1,
+        firstTimestampNs: startedAtNs,
+        lastTimestampNs: endedAtNs,
+        totalDurationNs: durationNs,
         functionId,
-        timestampMs: startedAtMs,
-        lastTimestampMs: endedAtMs,
-        suppressedCallCount: 1,
-        totalDurationMs: durationMs,
         ...parentCallId === void 0 ? {} : { parentCallId }
       };
-      appendStandaloneEvent(recording, group.summary);
+      appendSuppressedPlaceholder(recording, group.suppressed);
       return;
     }
-    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);
+    const suppressed = group.suppressed;
+    suppressed.count++;
+    suppressed.lastTimestampNs = endedAtNs;
+    suppressed.totalDurationNs += durationNs;
+    if (!suppressed.retainedSlot) {
+      appendSuppressedPlaceholder(recording, suppressed);
+    }
   };
   const finish = (store, metadata) => {
     const { recording } = store;
@@ -1134,7 +1300,7 @@ var createExecutionRecorder = (options) => {
         },
         events: new CallAwareEventBuffer(maxEventsPerExecution),
         functions: /* @__PURE__ */ new Map(),
-        repeatedCalls: /* @__PURE__ */ new Map(),
+        repeatedCalls: [],
         capturedErrors: /* @__PURE__ */ new WeakMap(),
         nextCallId: 0,
         finished: false,
@@ -1202,52 +1368,74 @@ 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,
+                startedAtNs2,
+                callbackEndedAtNs2
+              );
+              addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              return value;
+            },
+            (error) => {
+              const callbackEndedAtNs2 = process.hrtime.bigint();
+              captureCompletedThrow(store.recording, plan, args, parentCallId, startedAtNs2, error);
+              addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              throw error;
+            }
+          );
+        }
+        const callbackEndedAtNs = process.hrtime.bigint();
+        recordSuppressedCall(
           store.recording,
-          functionId,
-          args,
+          group,
+          plan.functionId,
           parentCallId,
           startedAtNs2,
-          startedAtMs,
-          error
-        )
-      );
+          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, plan, args, parentCallId, startedAtNs2, 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()) {
-      const startedAtMs = elapsedMs(store.recording.startedAtNs, startedAtNs);
       const captureSuccess = () => {
         const droppedBefore = store.recording.events.dropped;
         store.recording.events.dropCall();
@@ -1260,19 +1448,11 @@ var createExecutionRecorder = (options) => {
           recorderStartedAtNs,
           callback,
           captureSuccess,
-          (error) => captureCompletedThrow(
-            store.recording,
-            functionId,
-            args,
-            parentCallId,
-            startedAtNs,
-            startedAtMs,
-            error
-          )
+          (error) => captureCompletedThrow(store.recording, plan, args, parentCallId, startedAtNs, error)
         )
       );
     }
-    if (!memoryBudget.reserveCall(store.recording.memory, functionId)) {
+    if (!memoryBudget.reserveCall(store.recording.memory, plan.estimatedCallBytes)) {
       return observeRecordedCallback(
         store.recording,
         recorderStartedAtNs,
@@ -1286,7 +1466,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 }
@@ -1307,6 +1487,7 @@ var createExecutionRecorder = (options) => {
             durationMs: elapsedMs(startedAtNs),
             returnValue: captureValue(store.recording, value)
           });
+          stats.functionCallsCaptured++;
         },
         (error) => {
           const capturedError = serializedError(store.recording, error, callId);
@@ -1317,16 +1498,24 @@ 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();
+  };
+  const prepareFunctionPlans = (plans) => preparedPlansFor(plans);
   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 {
@@ -1334,11 +1523,70 @@ var createExecutionRecorder = (options) => {
     run,
     getErrorState,
     runFunction,
+    runFunctionPlans,
+    prepareFunctionPlans,
+    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 passthrough = (_planIndex, _args, callback) => callback();
+var bindPassthrough = (module) => {
+  module.cell.run = passthrough;
+};
+var isRegistry = (value) => Array.isArray(Reflect.get(value, "runtimes")) && Array.isArray(Reflect.get(value, "modules")) && typeof Reflect.get(value, "register") === "function";
+var registerModule = (registry, plans) => {
+  const cell = { run: passthrough };
+  const module = { plans, cell };
+  registry.modules.push(module);
+  registry.runtimes.at(-1)?.bind(module);
+  return (planIndex, args, callback) => cell.run(planIndex, args, callback);
+};
+var createRegistry = () => {
+  const registry = {
+    runtimes: [],
+    modules: [],
+    register(plans) {
+      return registerModule(registry, plans);
+    }
+  };
+  return registry;
+};
+var getAutomaticRuntimeRegistry = () => {
+  const existing = Reflect.get(globalThis, runtimeSymbol);
+  if (existing && typeof existing === "object" && isRegistry(existing)) return existing;
+  const registry = createRegistry();
+  Reflect.set(globalThis, runtimeSymbol, registry);
+  return registry;
+};
+var installAutomaticExecutionRuntime = (execution) => {
+  const registry = getAutomaticRuntimeRegistry();
+  const runtime = {
+    bind(module) {
+      const prepared = execution.prepareFunctionPlans(module.plans);
+      module.cell.run = (planIndex, args, callback) => {
+        const plan = prepared[planIndex];
+        return plan ? execution.runPreparedFunction(plan, args, callback) : callback();
+      };
+    }
+  };
+  registry.runtimes.push(runtime);
+  for (const module of registry.modules) runtime.bind(module);
+  return () => {
+    const index = registry.runtimes.lastIndexOf(runtime);
+    if (index >= 0) registry.runtimes.splice(index, 1);
+    const current = registry.runtimes.at(-1);
+    for (const module of registry.modules) {
+      if (current) current.bind(module);
+      else bindPassthrough(module);
+    }
+  };
+};
+
 // src/install-global-handlers.ts
 var removeProcessListener = process.off.bind(process);
 var installGlobalHandlers = (client, options = {}) => {
@@ -1388,6 +1636,7 @@ var installGlobalHandlers = (client, options = {}) => {
 };
 
 // src/rasputin-init.ts
+import { join } from "node:path";
 import {
   createClient,
   isClientEnabled
@@ -1395,7 +1644,7 @@ import {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/node";
-var SDK_VERSION = "0.4.1";
+var SDK_VERSION = "0.5.0-alpha.2";
 
 // src/rasputin-init.ts
 var withExecution = (client, execution, installRuntime, manifest) => {
@@ -1436,6 +1685,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,