@rasputin-ai/node 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,3 +1,1331 @@
+// src/auto-instrumentation/schedule-instrumentation-manifest-upload.ts
+import {
+  detectRelease,
+  resolveEndpointUrls,
+  uploadInstrumentationManifest
+} from "@rasputin-ai/core";
+
+// src/auto-instrumentation/format-configuration-report.ts
+var RULE = "-".repeat(64);
+var BANNER = [
+  RULE,
+  " ____       _      ____    ____    _   _   _____   ___   _   _",
+  "|  _ \\     / \\    / ___|  |  _ \\  | | | | |_   _| |_ _| | \\ | |",
+  "| |_) |   / _ \\   \\___ \\  | |_) | | | | |   | |    | |  |  \\| |",
+  "|  _ <   / ___ \\   ___) | |  __/  | |_| |   | |    | |  | |\\  |",
+  "|_| \\_\\ /_/   \\_\\ |____/  |_|      \\___/    |_|   |___| |_| \\_|",
+  "",
+  "",
+  "CONFIGURATION:"
+];
+var counted = (n, singular, plural) => `${n} ${n === 1 ? singular : plural}`;
+var issueHeadline = (issue) => {
+  const target = issue.packageName ? `package ${issue.packageName}` : issue.packageRelativePath;
+  if (issue.reason === "ambiguous") return `Could not uniquely locate ${target}.`;
+  if (issue.reason === "not_found") return `Could not find ${target} in this Git release.`;
+  if (issue.reason === "invalid_mapping") {
+    return `The configured package root for ${target} does not match this Git release.`;
+  }
+  return `GitHub could not be reached while locating ${target}.`;
+};
+var formatIssue = (issue) => {
+  const lines = [
+    `! ${issueHeadline(issue)}`,
+    "",
+    "  Captured:",
+    `    ${issue.packageRelativePath}`
+  ];
+  if (issue.candidates?.length) {
+    lines.push("", "  Possible repository locations:");
+    for (const candidate of issue.candidates) lines.push(`    ${candidate}`);
+  }
+  return lines;
+};
+var formatConfigurationReport = (input) => {
+  const packages = input.verification.packages ?? [];
+  const unresolved = input.verification.unresolved;
+  const mappingIssues = unresolved.filter((issue) => issue.reason !== "github_unavailable");
+  const githubUnavailable = input.verification.status === "unavailable" || unresolved.some((issue) => issue.reason === "github_unavailable");
+  const verified = input.uploaded && input.verification.status === "verified";
+  const lines = [
+    ...BANNER,
+    "",
+    "Release",
+    `\u2713 ${input.release}`,
+    "",
+    "Runtime",
+    `\u2713 ${input.runtime}`,
+    "",
+    "Instrumentation",
+    `\u2713 ${counted(input.modules, "application module", "application modules")} observed`,
+    `\u2713 ${counted(input.functions, "function", "functions")} instrumented`,
+    `\u2713 ${counted(input.packageNames.length, "workspace package", "workspace packages")} detected`
+  ];
+  if (packages.length > 0 || mappingIssues.length > 0) {
+    lines.push("", "Package roots");
+    for (const mapping of packages) {
+      lines.push(
+        mapping.packageName ? `\u2713 ${mapping.packageName} \u2192 ${mapping.repositoryRoot}` : `\u2713 ${mapping.repositoryRoot}`
+      );
+    }
+    for (const [index, issue] of mappingIssues.entries()) {
+      if (packages.length > 0 || index > 0) lines.push("");
+      lines.push(...formatIssue(issue));
+    }
+  }
+  lines.push("", "Manifest");
+  if (!input.uploaded) {
+    lines.push("! upload failed");
+  } else {
+    lines.push("\u2713 uploaded");
+    lines.push(
+      verified ? "\u2713 verified against GitHub" : "! some source files could not be mapped to this Git release"
+    );
+  }
+  lines.push("", "GitHub");
+  if (!input.uploaded) {
+    lines.push("! not verified");
+  } else if (githubUnavailable) {
+    lines.push("! repository is not connected, or this release could not be read");
+  } else {
+    lines.push("\u2713 repository connected");
+  }
+  if (input.uploaded && input.verification.status !== "verified") {
+    lines.push("", "Runtime recording is unaffected.");
+  }
+  lines.push(RULE);
+  return lines.join("\n");
+};
+var runtimeLabel = () => {
+  const bun = globalThis.Bun;
+  if (typeof bun?.version === "string" && bun.version) return `Bun ${bun.version}`;
+  return `Node ${process.versions.node}`;
+};
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+import { createHash } from "node:crypto";
+import {
+  INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+  sourceLocatorFromFile as sourceLocatorFromFile2
+} from "@rasputin-ai/core";
+
+// src/execution-recorder/automatic-runtime.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);
+  };
+};
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v2";
+var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
+var getRegistry2 = () => {
+  const existing = Reflect.get(globalThis, registrySymbol);
+  if (existing?.__rasputinManifestRegistry && existing.files instanceof Map && typeof existing.generation === "number" && typeof existing.uploadedGeneration === "number") {
+    return existing;
+  }
+  const registry = {
+    __rasputinManifestRegistry: true,
+    files: /* @__PURE__ */ new Map(),
+    generation: 0,
+    uploadedGeneration: 0
+  };
+  Reflect.set(globalThis, registrySymbol, registry);
+  return registry;
+};
+var sourceAt = (filePath, line, column) => {
+  const source = sourceLocatorFromFile2(filePath);
+  return source ? { ...source, line, column } : void 0;
+};
+var stableId = (kind, ...parts) => `${kind}_${createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 24)}`;
+var isInstrumentationManifestDirty = () => {
+  const registry = getRegistry2();
+  return registry.generation !== registry.uploadedGeneration && registry.files.size > 0;
+};
+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 fn of delta.functions) {
+      const definition = decodeAutomaticFunctionSource(fn.sourceToken);
+      if (!definition?.source) continue;
+      functions.push({
+        functionId: definition.functionId,
+        source: definition.source,
+        name: fn.name,
+        startLine: fn.startLine,
+        startColumn: fn.startColumn,
+        endLine: fn.endLine,
+        endColumn: fn.endColumn,
+        params: fn.params
+      });
+    }
+    for (const site of delta.callSites) {
+      const caller = decodeAutomaticFunctionSource(site.callerSourceToken);
+      const source = sourceAt(site.filePath, site.line, site.column);
+      if (!caller || !source) continue;
+      callSites.push({
+        id: stableId(
+          "cs",
+          caller.functionId,
+          source.packageName ?? "",
+          source.packageRelativePath,
+          site.line,
+          site.column
+        ),
+        callerFunctionId: caller.functionId,
+        calleeName: site.calleeName,
+        calleeText: site.calleeText,
+        source,
+        line: site.line,
+        column: site.column,
+        endLine: site.endLine,
+        endColumn: site.endColumn,
+        resultBinding: site.resultBinding,
+        argIdentifiers: site.argIdentifiers
+      });
+    }
+    for (const destructure of delta.destructures) {
+      const caller = decodeAutomaticFunctionSource(destructure.callerSourceToken);
+      const source = sourceAt(destructure.filePath, destructure.line, destructure.column);
+      if (!caller || !source) continue;
+      destructures.push({
+        callerFunctionId: caller.functionId,
+        sourceParam: destructure.sourceParam,
+        source,
+        line: destructure.line,
+        column: destructure.column,
+        binding: destructure.binding
+      });
+    }
+  }
+  if (functions.length === 0 && callSites.length === 0 && destructures.length === 0) {
+    return void 0;
+  }
+  const packages = { ...options.sourceRoots ?? {} };
+  return {
+    schema_version: INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+    ...options.sourceRoot || Object.keys(packages).length > 0 ? {
+      sourceRoots: {
+        ...options.sourceRoot ? { default: options.sourceRoot } : {},
+        packages
+      }
+    } : {},
+    functions,
+    callSites,
+    destructures
+  };
+};
+var markInstrumentationManifestUploaded = (generation) => {
+  const registry = getRegistry2();
+  if (registry.generation === generation) registry.uploadedGeneration = generation;
+};
+var setInstrumentationManifestOnDirty = (onDirty) => {
+  getRegistry2().onDirty = onDirty;
+};
+
+// src/auto-instrumentation/schedule-instrumentation-manifest-upload.ts
+var unavailable = () => ({
+  status: "unavailable",
+  verified: 0,
+  unresolved: [],
+  packages: []
+});
+var noopHandle = {
+  flushSoon() {
+  },
+  async wait() {
+  },
+  disconnect() {
+  },
+  async verify() {
+    return unavailable();
+  }
+};
+var scheduleInstrumentationManifestUpload = (options) => {
+  const release = detectRelease({ release: options.release });
+  if (!options.enabled || !release || !options.projectApiKey.trim()) {
+    return noopHandle;
+  }
+  const { instrumentationManifestUrl } = resolveEndpointUrls(options.apiUrl);
+  let inflight;
+  let verification = unavailable();
+  let loggedSuccess = false;
+  let loggedFailure = false;
+  const packageNamesOf = (manifest) => [
+    ...new Set(
+      manifest.functions.map((fn) => fn.source.packageName).filter((name) => Boolean(name))
+    )
+  ].sort();
+  const report = (manifest, uploaded, next) => {
+    return formatConfigurationReport({
+      release,
+      runtime: runtimeLabel(),
+      modules: instrumentationManifestModuleCount(),
+      functions: manifest.functions.length,
+      packageNames: packageNamesOf(manifest),
+      verification: next,
+      uploaded
+    });
+  };
+  const flushSoon = () => {
+    if (!isInstrumentationManifestDirty()) return;
+    const generation = instrumentationManifestGeneration();
+    const manifest = snapshotInstrumentationManifest({
+      sourceRoot: options.sourceRoot,
+      sourceRoots: options.sourceRoots
+    });
+    if (!manifest) {
+      markInstrumentationManifestUploaded(generation);
+      return;
+    }
+    const work = uploadInstrumentationManifest({
+      url: instrumentationManifestUrl,
+      projectApiKey: options.projectApiKey,
+      release,
+      manifest,
+      fetch: options.fetch
+    }).then((result) => {
+      if (result.ok) {
+        verification = result.verification;
+        markInstrumentationManifestUploaded(generation);
+        if (verification.status === "verified") {
+          if (!loggedSuccess && options.logSuccess !== false) {
+            loggedSuccess = true;
+            console.info(report(manifest, true, verification));
+          }
+          return;
+        }
+        if (!loggedFailure) {
+          loggedFailure = true;
+          console.warn(report(manifest, true, verification));
+        }
+        return;
+      }
+      if (!loggedFailure) {
+        loggedFailure = true;
+        console.warn(report(manifest, false, unavailable()));
+      }
+    });
+    inflight = inflight ? inflight.then(() => work) : work;
+  };
+  setInstrumentationManifestOnDirty(flushSoon);
+  flushSoon();
+  return {
+    flushSoon,
+    wait: async () => {
+      await inflight;
+    },
+    disconnect: () => {
+      setInstrumentationManifestOnDirty(void 0);
+    },
+    verify: async () => {
+      flushSoon();
+      await inflight;
+      return verification;
+    }
+  };
+};
+
+// src/execution-recorder/execution-recorder.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { runtimeFunctionId as runtimeFunctionId2 } from "@rasputin-ai/core";
+
+// src/execution-recorder/call-aware-event-buffer.ts
+var CallAwareEventBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  items = [];
+  openCallIds = /* @__PURE__ */ new Set();
+  dropped = 0;
+  canStartCall() {
+    return this.items.length + this.openCallIds.size + 2 <= this.capacity;
+  }
+  startCall(event) {
+    this.items.push(event);
+    this.openCallIds.add(event.callId);
+  }
+  finishCall(event) {
+    if (event.type !== "function_exit" && event.type !== "function_throw") return;
+    if (!this.openCallIds.delete(event.callId)) return;
+    this.items.push(event);
+  }
+  dropCall() {
+    this.dropped += 2;
+  }
+  append(event) {
+    if (this.items.length + this.openCallIds.size + 1 > this.capacity) {
+      this.dropped++;
+      return false;
+    }
+    this.items.push(event);
+    return true;
+  }
+  forceCompletedCall(enter, terminal) {
+    while (this.items.length + this.openCallIds.size + 2 > this.capacity) {
+      if (!this.evictCompletedLeafOrSummary()) {
+        this.dropCall();
+        return false;
+      }
+    }
+    this.items.push(enter, terminal);
+    return true;
+  }
+  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) {
+      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 (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)) {
+        continue;
+      }
+      const terminalIndex = this.items.findIndex(
+        (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);
+      this.items.splice(Math.min(index, terminalIndex), 1);
+      this.dropped += 2;
+      return true;
+    }
+    return false;
+  }
+};
+
+// 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 = {
+  __rasputin_type: "omitted",
+  __reason: "process_memory_budget"
+};
+var RecorderMemoryBudget = class {
+  constructor(maximumBytes, maximumSerializedValueBytes) {
+    this.maximumBytes = maximumBytes;
+    this.maximumSerializedValueBytes = maximumSerializedValueBytes;
+  }
+  activeEstimatedBytes = 0;
+  stats = {
+    activeEstimatedBytes: 0,
+    peakActiveEstimatedBytes: 0,
+    memoryPressureExecutions: 0,
+    memoryPressureDegradations: 0,
+    valuesDroppedByMemoryBudget: 0,
+    eventsDroppedByMemoryBudget: 0
+  };
+  startExecution() {
+    const allocation = {
+      mode: "full",
+      estimatedBytes: 0,
+      released: false,
+      underPressure: false,
+      valuesDropped: 0,
+      eventsDropped: 0
+    };
+    if (!this.reserve(allocation, EXECUTION_BASE_ESTIMATED_BYTES)) {
+      this.markPressure(allocation, "metadata-only");
+    }
+    return allocation;
+  }
+  captureValue(allocation, serialize) {
+    if (allocation.mode !== "full") {
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    const maximumEstimate = this.maximumSerializedValueBytes * VALUE_HEAP_ESTIMATE_MULTIPLIER;
+    if (this.activeEstimatedBytes + maximumEstimate > this.maximumBytes) {
+      this.markPressure(allocation, "structure-only");
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    const serialized = serialize();
+    if (!this.reserve(allocation, serialized.bytes * VALUE_HEAP_ESTIMATE_MULTIPLIER)) {
+      this.markPressure(allocation, "structure-only");
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    return serialized.value;
+  }
+  reserveCall(allocation, functionId) {
+    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);
+    return false;
+  }
+  reserveStandaloneEvent(allocation) {
+    if (allocation.mode === "metadata-only") {
+      this.dropEvents(allocation, 1);
+      return false;
+    }
+    if (this.reserve(allocation, SUMMARY_EVENT_BASE_ESTIMATED_BYTES)) return true;
+    this.markPressure(allocation, "metadata-only");
+    this.dropEvents(allocation, 1);
+    return false;
+  }
+  release(allocation) {
+    if (allocation.released) return;
+    allocation.released = true;
+    this.activeEstimatedBytes = Math.max(0, this.activeEstimatedBytes - allocation.estimatedBytes);
+    this.stats.activeEstimatedBytes = this.activeEstimatedBytes;
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  reserve(allocation, bytes) {
+    const boundedBytes = Math.max(0, Math.ceil(bytes));
+    if (this.activeEstimatedBytes + boundedBytes > this.maximumBytes) return false;
+    this.activeEstimatedBytes += boundedBytes;
+    allocation.estimatedBytes += boundedBytes;
+    this.stats.activeEstimatedBytes = this.activeEstimatedBytes;
+    this.stats.peakActiveEstimatedBytes = Math.max(
+      this.stats.peakActiveEstimatedBytes,
+      this.activeEstimatedBytes
+    );
+    return true;
+  }
+  markPressure(allocation, mode) {
+    if (!allocation.underPressure) {
+      allocation.underPressure = true;
+      this.stats.memoryPressureExecutions++;
+    }
+    if (allocation.mode === mode || allocation.mode === "metadata-only" && mode === "structure-only") {
+      return;
+    }
+    allocation.mode = mode;
+    this.stats.memoryPressureDegradations++;
+  }
+  dropValues(allocation, count) {
+    allocation.valuesDropped += count;
+    this.stats.valuesDroppedByMemoryBudget += count;
+  }
+  dropEvents(allocation, count) {
+    allocation.eventsDropped += count;
+    this.stats.eventsDroppedByMemoryBudget += count;
+  }
+};
+
+// src/execution-recorder/safe-serialize.ts
+import { Buffer as Buffer2 } from "node:buffer";
+var DEFAULT_REDACT_KEYS = /* @__PURE__ */ new Set([
+  "password",
+  "token",
+  "authorization",
+  "cookie",
+  "secret",
+  "apikey",
+  "creditcard"
+]);
+var defaults = {
+  maxDepth: 3,
+  maxObjectKeys: 30,
+  maxArrayElements: 20,
+  maxStringLength: 500,
+  maxSerializedValueBytes: 8 * 1024
+};
+var truncation = (reason, extra = {}) => ({
+  __rasputin_truncated: true,
+  __reason: reason,
+  ...extra
+});
+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 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 } : {}
+      });
+    }
+    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)
+        ]);
+      }
+      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));
+      }
+      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 }));
+      }
+      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") };
+  }
+};
+var safeSerialize = (value, options = {}) => safeSerializeWithBytes(value, options).value;
+
+// src/execution-recorder/source-exclusions.ts
+var sourcePathFrom = (definition) => definition.source?.packageRelativePath.replaceAll("\\", "/") ?? definition.name;
+var searchableIdentity = (definition) => {
+  const source = definition.source;
+  return source ? `${source.packageName ? `${source.packageName}:` : ""}${source.packageRelativePath}:${definition.name}@${source.line ?? ""}:${source.column ?? ""}` : definition.name;
+};
+var normalizePattern = (pattern) => pattern.trim().replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+var globRegex = (pattern) => {
+  let expression = "";
+  for (let index = 0; index < pattern.length; index++) {
+    const character = pattern[index];
+    const next = pattern[index + 1];
+    if (character === "*" && next === "*") {
+      if (pattern[index + 2] === "/") {
+        expression += "(?:.*/)?";
+        index += 2;
+      } else {
+        expression += ".*";
+        index++;
+      }
+      continue;
+    }
+    if (character === "*") {
+      expression += "[^/]*";
+      continue;
+    }
+    if (character === "?") {
+      expression += "[^/]";
+      continue;
+    }
+    expression += character?.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") ?? "";
+  }
+  return new RegExp(`^${expression}$`);
+};
+var createSourceExclusionMatcher = (exclusions) => {
+  const matchers = (exclusions ?? []).flatMap(
+    (exclusion) => {
+      if (exclusion instanceof RegExp) {
+        return [
+          (definition) => {
+            exclusion.lastIndex = 0;
+            const matched = exclusion.test(searchableIdentity(definition));
+            exclusion.lastIndex = 0;
+            return matched;
+          }
+        ];
+      }
+      const pattern = normalizePattern(exclusion);
+      if (!pattern) return [];
+      if (pattern.includes("*") || pattern.includes("?")) {
+        const regex = globRegex(pattern);
+        return [(definition) => regex.test(sourcePathFrom(definition))];
+      }
+      return [
+        (definition) => {
+          const sourcePath = sourcePathFrom(definition);
+          return sourcePath === pattern || sourcePath.startsWith(`${pattern}/`);
+        }
+      ];
+    }
+  );
+  return matchers.length === 0 ? () => false : (definition) => matchers.some((matcher) => matcher(definition));
+};
+
+// src/execution-recorder/execution-recorder.ts
+var DEFAULT_MAX_ACTIVE_MEMORY_BYTES = 64 * 1024 * 1024;
+var manualFunctionDefinition = (value) => {
+  const located = /^(.+):([^:@]+)@(\d+):(\d+)$/.exec(value);
+  const named = located ? void 0 : /^(.+):([^:@]+)$/.exec(value);
+  const path = located?.[1] ?? named?.[1];
+  const name = located?.[2] ?? named?.[2] ?? value;
+  const source = path ? {
+    packageRelativePath: path.replaceAll("\\", "/").replace(/^\.\//, ""),
+    ...located?.[3] ? { line: Number(located[3]) } : {},
+    ...located?.[4] ? { column: Number(located[4]) } : {}
+  } : void 0;
+  const definition = { name, ...source ? { source } : {} };
+  return { ...definition, functionId: runtimeFunctionId2(definition) };
+};
+var normalizeFunctionDefinition = (value) => typeof value === "string" ? manualFunctionDefinition(value) : value;
+var elapsedMs = (startedAtNs, endedAtNs = process.hrtime.bigint()) => Number(endedAtNs - startedAtNs) / 1e6;
+var roundedMilliseconds = (nanoseconds) => Math.round(Number(nanoseconds) / 1e6 * 1e4) / 1e4;
+var addRecorderTime = (recording, nanoseconds) => {
+  if (nanoseconds > 0n) recording.inlineRecorderTimeNs += nanoseconds;
+};
+var isPromiseLike = (value) => Boolean(value) && typeof value.then === "function";
+var notifyObserver = (observer, value) => {
+  try {
+    observer(value);
+  } catch {
+  }
+};
+var observeCallback = (callback, onReturn, onThrow) => {
+  let result;
+  try {
+    result = callback();
+  } catch (error) {
+    notifyObserver(onThrow, error);
+    throw error;
+  }
+  if (isPromiseLike(result)) {
+    return result.then(
+      (value) => {
+        notifyObserver(onReturn, value);
+        return value;
+      },
+      (error) => {
+        notifyObserver(onThrow, error);
+        throw error;
+      }
+    );
+  }
+  notifyObserver(onReturn, result);
+  return result;
+};
+var observeRecordedCallback = (recording, recorderStartedAtNs, callback, onReturn, onThrow) => {
+  const callbackStartedAtNs = process.hrtime.bigint();
+  const recordExitWork = (callbackEndedAtNs2) => {
+    addRecorderTime(recording, callbackStartedAtNs - recorderStartedAtNs);
+    addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs2);
+  };
+  let result;
+  try {
+    result = callback();
+  } catch (error) {
+    const callbackEndedAtNs2 = process.hrtime.bigint();
+    notifyObserver(onThrow, error);
+    recordExitWork(callbackEndedAtNs2);
+    throw error;
+  }
+  if (isPromiseLike(result)) {
+    return result.then(
+      (value) => {
+        const callbackEndedAtNs2 = process.hrtime.bigint();
+        notifyObserver(onReturn, value);
+        recordExitWork(callbackEndedAtNs2);
+        return value;
+      },
+      (error) => {
+        const callbackEndedAtNs2 = process.hrtime.bigint();
+        notifyObserver(onThrow, error);
+        recordExitWork(callbackEndedAtNs2);
+        throw error;
+      }
+    );
+  }
+  const callbackEndedAtNs = process.hrtime.bigint();
+  notifyObserver(onReturn, result);
+  recordExitWork(callbackEndedAtNs);
+  return result;
+};
+var noOpExecution = {
+  createScope: () => ({
+    run: (callback) => callback(),
+    getErrorState: () => void 0,
+    finish: () => {
+    }
+  }),
+  run: (_metadata, callback) => callback(),
+  getErrorState: () => void 0,
+  runFunction: (_functionId, _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
+  })
+};
+var mergeExecutionMetadata = (target, metadata) => {
+  if (metadata.kind) target.kind = metadata.kind;
+  if (metadata.name !== void 0) target.name = metadata.name;
+  if (metadata.request) target.request = { ...target.request, ...metadata.request };
+};
+var createExecutionRecorder = (options) => {
+  if (!options?.enabled) return noOpExecution;
+  const storage = new AsyncLocalStorage();
+  const maxEventsPerExecution = Math.max(2, Math.floor(options.maxEventsPerExecution ?? 500));
+  const maxCapturedCallsPerFunction = Math.max(
+    1,
+    Math.floor(options.maxCapturedCallsPerFunction ?? 3)
+  );
+  const maxActiveMemoryBytes = Math.max(
+    0,
+    Math.floor(options.maxActiveMemoryBytes ?? DEFAULT_MAX_ACTIVE_MEMORY_BYTES)
+  );
+  const memoryBudget = new RecorderMemoryBudget(
+    maxActiveMemoryBytes,
+    options.maxSerializedValueBytes ?? 8 * 1024
+  );
+  const excludesSource = createSourceExclusionMatcher(options.excludeSources);
+  let executionCounter = 0;
+  const errorExecutions = /* @__PURE__ */ new WeakMap();
+  const stats = {
+    errorSnapshots: 0,
+    successfulExecutionsDiscarded: 0,
+    truncatedEvents: 0,
+    repeatedCallsSuppressed: 0,
+    activeExecutions: 0,
+    peakActiveExecutions: 0,
+    partialErrorSnapshots: 0
+  };
+  const captureValue = (recording, value) => memoryBudget.captureValue(recording.memory, () => safeSerializeWithBytes(value, options));
+  const stateFrom = (recording, endedAtNs = process.hrtime.bigint()) => {
+    const recorderStartedAtNs = process.hrtime.bigint();
+    const events = recording.events.values().map((event) => event.type === "function_calls_suppressed" ? { ...event } : event);
+    const referencedFunctionIds = new Set(
+      events.flatMap(
+        (event) => event.type === "function_enter" || event.type === "function_calls_suppressed" ? [event.functionId] : []
+      )
+    );
+    const state = {
+      version: 2,
+      executionId: recording.executionId,
+      startedAt: recording.startedAt,
+      durationMs: elapsedMs(recording.startedAtNs, endedAtNs),
+      recorder: { inlineWallTimeMs: 0 },
+      execution: {
+        ...recording.execution,
+        ...recording.execution.request ? { request: { ...recording.execution.request } } : {}
+      },
+      functions: [...recording.functions.values()].filter(
+        (definition) => referencedFunctionIds.has(definition.functionId)
+      ),
+      events,
+      ...recording.events.dropped > 0 ? { truncated: { eventsDropped: recording.events.dropped } } : {},
+      ...recording.memory.underPressure ? {
+        capture: {
+          completeness: "partial",
+          reason: "process_memory_budget",
+          valuesDropped: recording.memory.valuesDropped,
+          eventsDropped: recording.memory.eventsDropped
+        }
+      } : {}
+    };
+    addRecorderTime(recording, process.hrtime.bigint() - recorderStartedAtNs);
+    state.recorder = { inlineWallTimeMs: roundedMilliseconds(recording.inlineRecorderTimeNs) };
+    return state;
+  };
+  const rememberError = (error, recording) => {
+    recording.hasError = true;
+    if (typeof error !== "object" && typeof error !== "function" || error === null) return;
+    if (!errorExecutions.has(error)) {
+      stats.errorSnapshots++;
+      if (recording.memory.underPressure && !recording.partialSnapshotCounted) {
+        recording.partialSnapshotCounted = true;
+        stats.partialErrorSnapshots++;
+      }
+    }
+    errorExecutions.set(error, recording);
+  };
+  const countDroppedEvents = (recording, droppedBefore) => {
+    stats.truncatedEvents += recording.events.dropped - droppedBefore;
+  };
+  const appendStandaloneEvent = (recording, event) => {
+    if (!memoryBudget.reserveStandaloneEvent(recording.memory)) return;
+    const droppedBefore = recording.events.dropped;
+    recording.events.append(event);
+    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);
+    }
+    let group = byParent.get(parentCallId);
+    if (!group) {
+      group = { observedCalls: 0 };
+      byParent.set(parentCallId, group);
+    }
+    return group;
+  };
+  const serializedError = (recording, error, callId) => {
+    const key = (typeof error === "object" || typeof error === "function") && error !== null ? error : void 0;
+    const referencedCallId = key ? recording.capturedErrors.get(key) : void 0;
+    if (referencedCallId !== void 0) {
+      return {
+        value: { __rasputin_type: "ErrorReference", callId: referencedCallId },
+        commit: () => {
+        }
+      };
+    }
+    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),
+      commit: () => {
+        if (key) recording.capturedErrors.set(key, callId);
+      }
+    };
+  };
+  const captureCompletedThrow = (recording, functionId, args, parentCallId, startedAtNs, startedAtMs, error) => {
+    if (!memoryBudget.reserveCall(recording.memory, functionId)) {
+      rememberError(error, recording);
+      return;
+    }
+    const callId = ++recording.nextCallId;
+    const capturedError = serializedError(recording, error, callId);
+    const enter = {
+      type: "function_enter",
+      callId,
+      functionId,
+      timestampMs: startedAtMs,
+      args: Array.from(args, (argument) => captureValue(recording, argument)),
+      ...parentCallId === void 0 ? {} : { parentCallId }
+    };
+    const terminal = {
+      type: "function_throw",
+      callId,
+      timestampMs: elapsedMs(recording.startedAtNs),
+      durationMs: elapsedMs(startedAtNs),
+      error: capturedError.value
+    };
+    const droppedBefore = recording.events.dropped;
+    const retained = recording.events.forceCompletedCall(enter, terminal);
+    if (retained) capturedError.commit();
+    countDroppedEvents(recording, droppedBefore);
+    rememberError(error, recording);
+  };
+  const recordSuppressedCall = (recording, group, functionId, parentCallId, startedAtMs, durationMs) => {
+    stats.repeatedCallsSuppressed++;
+    const endedAtMs = startedAtMs + durationMs;
+    if (!group.summary) {
+      group.summary = {
+        type: "function_calls_suppressed",
+        functionId,
+        timestampMs: startedAtMs,
+        lastTimestampMs: endedAtMs,
+        suppressedCallCount: 1,
+        totalDurationMs: durationMs,
+        ...parentCallId === void 0 ? {} : { parentCallId }
+      };
+      appendStandaloneEvent(recording, group.summary);
+      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 finish = (store, metadata) => {
+    const { recording } = store;
+    if (recording.finished) return;
+    const recorderStartedAtNs = process.hrtime.bigint();
+    recording.finished = true;
+    if (metadata) mergeExecutionMetadata(recording.execution, metadata);
+    memoryBudget.release(recording.memory);
+    stats.activeExecutions = Math.max(0, stats.activeExecutions - 1);
+    if (!recording.hasError) stats.successfulExecutionsDiscarded++;
+    recording.finishedAtNs = process.hrtime.bigint();
+    addRecorderTime(recording, recording.finishedAtNs - recorderStartedAtNs);
+  };
+  const createScope = (metadata) => {
+    const recorderStartedAtNs = process.hrtime.bigint();
+    try {
+      const recording = {
+        executionId: `${Date.now()}-${process.pid}-${++executionCounter}`,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        startedAtNs: recorderStartedAtNs,
+        inlineRecorderTimeNs: 0n,
+        execution: {
+          ...metadata,
+          ...metadata.request ? { request: { ...metadata.request } } : {}
+        },
+        events: new CallAwareEventBuffer(maxEventsPerExecution),
+        functions: /* @__PURE__ */ new Map(),
+        repeatedCalls: /* @__PURE__ */ new Map(),
+        capturedErrors: /* @__PURE__ */ new WeakMap(),
+        nextCallId: 0,
+        finished: false,
+        hasError: false,
+        memory: memoryBudget.startExecution(),
+        partialSnapshotCounted: false
+      };
+      stats.activeExecutions++;
+      stats.peakActiveExecutions = Math.max(stats.peakActiveExecutions, stats.activeExecutions);
+      addRecorderTime(recording, process.hrtime.bigint() - recorderStartedAtNs);
+      const store = { recording };
+      return {
+        run: (callback) => {
+          const runStartedAtNs = process.hrtime.bigint();
+          return storage.run(store, () => {
+            addRecorderTime(recording, process.hrtime.bigint() - runStartedAtNs);
+            return callback();
+          });
+        },
+        getErrorState: (error, errorMetadata) => {
+          const getStateStartedAtNs = process.hrtime.bigint();
+          if (errorMetadata) mergeExecutionMetadata(recording.execution, errorMetadata);
+          rememberError(error, recording);
+          addRecorderTime(recording, process.hrtime.bigint() - getStateStartedAtNs);
+          return stateFrom(recording, recording.finishedAtNs);
+        },
+        finish: (finishMetadata) => finish(store, finishMetadata)
+      };
+    } catch {
+      return noOpExecution.createScope(metadata);
+    }
+  };
+  const run = (metadata, callback) => {
+    const scope = createScope(metadata);
+    return scope.run(
+      () => observeCallback(
+        callback,
+        () => scope.finish(),
+        (error) => {
+          try {
+            const store = storage.getStore();
+            if (store) {
+              const recorderStartedAtNs = process.hrtime.bigint();
+              rememberError(error, store.recording);
+              addRecorderTime(store.recording, process.hrtime.bigint() - recorderStartedAtNs);
+            }
+          } finally {
+            scope.finish();
+          }
+        }
+      )
+    );
+  };
+  const getErrorState = (error, metadata) => {
+    const getStateStartedAtNs = process.hrtime.bigint();
+    try {
+      const weakKey = (typeof error === "object" || typeof error === "function") && error !== null ? error : void 0;
+      const recording = (weakKey ? errorExecutions.get(weakKey) : void 0) ?? storage.getStore()?.recording;
+      if (!recording) return void 0;
+      if (metadata) mergeExecutionMetadata(recording.execution, metadata);
+      rememberError(error, recording);
+      addRecorderTime(recording, process.hrtime.bigint() - getStateStartedAtNs);
+      return stateFrom(recording, recording.finishedAtNs);
+    } catch {
+      return void 0;
+    }
+  };
+  const runFunction = (input, args, callback) => {
+    const store = storage.getStore();
+    if (!store || store.recording.finished) return callback();
+    const definition = normalizeFunctionDefinition(input);
+    const functionId = definition.functionId;
+    const recorderStartedAtNs = process.hrtime.bigint();
+    if (store.suppressCapture || excludesSource(definition)) {
+      return storage.run({ ...store, suppressCapture: true }, () => {
+        addRecorderTime(store.recording, process.hrtime.bigint() - recorderStartedAtNs);
+        return callback();
+      });
+    }
+    store.recording.functions.set(functionId, definition);
+    const parentCallId = store.currentCallId;
+    const group = repeatedCallGroup(store.recording, functionId, parentCallId);
+    group.observedCalls++;
+    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(
+          store.recording,
+          functionId,
+          args,
+          parentCallId,
+          startedAtNs2,
+          startedAtMs,
+          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();
+        countDroppedEvents(store.recording, droppedBefore);
+      };
+      return storage.run(
+        store,
+        () => observeRecordedCallback(
+          store.recording,
+          recorderStartedAtNs,
+          callback,
+          captureSuccess,
+          (error) => captureCompletedThrow(
+            store.recording,
+            functionId,
+            args,
+            parentCallId,
+            startedAtNs,
+            startedAtMs,
+            error
+          )
+        )
+      );
+    }
+    if (!memoryBudget.reserveCall(store.recording.memory, functionId)) {
+      return observeRecordedCallback(
+        store.recording,
+        recorderStartedAtNs,
+        callback,
+        () => {
+        },
+        (error) => rememberError(error, store.recording)
+      );
+    }
+    const callId = ++store.recording.nextCallId;
+    const enter = {
+      type: "function_enter",
+      callId,
+      functionId,
+      timestampMs: elapsedMs(store.recording.startedAtNs),
+      args: Array.from(args, (argument) => captureValue(store.recording, argument)),
+      ...parentCallId === void 0 ? {} : { parentCallId }
+    };
+    store.recording.events.startCall(enter);
+    const callStore = { recording: store.recording, currentCallId: callId };
+    return storage.run(
+      callStore,
+      () => observeRecordedCallback(
+        store.recording,
+        recorderStartedAtNs,
+        callback,
+        (value) => {
+          store.recording.events.finishCall({
+            type: "function_exit",
+            callId,
+            timestampMs: elapsedMs(store.recording.startedAtNs),
+            durationMs: elapsedMs(startedAtNs),
+            returnValue: captureValue(store.recording, value)
+          });
+        },
+        (error) => {
+          const capturedError = serializedError(store.recording, error, callId);
+          store.recording.events.finishCall({
+            type: "function_throw",
+            callId,
+            timestampMs: elapsedMs(store.recording.startedAtNs),
+            durationMs: elapsedMs(startedAtNs),
+            error: capturedError.value
+          });
+          capturedError.commit();
+          rememberError(error, store.recording);
+        }
+      )
+    );
+  };
+  function trace(input, fn) {
+    const definition = typeof input === "string" ? manualFunctionDefinition(input) : { ...input, functionId: runtimeFunctionId2(input) };
+    return function traced(...args) {
+      return runFunction(definition, args, () => fn.apply(this, args));
+    };
+  }
+  return {
+    createScope,
+    run,
+    getErrorState,
+    runFunction,
+    trace,
+    getStats: () => ({ ...stats, ...memoryBudget.getStats() })
+  };
+};
+
 // src/install-global-handlers.ts
 var removeProcessListener = process.off.bind(process);
 var installGlobalHandlers = (client, options = {}) => {
@@ -54,21 +1382,81 @@ import {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/node";
-var SDK_VERSION = "0.2.0";
+var SDK_VERSION = "0.4.0";
 
 // src/rasputin-init.ts
+var withExecution = (client, execution, installRuntime, manifest) => {
+  const uninstallRuntime = installRuntime ? installAutomaticExecutionRuntime(execution) : () => {
+  };
+  const manifestUpload = scheduleInstrumentationManifestUpload(manifest);
+  return {
+    ...client,
+    execution,
+    getStats: () => ({ ...client.getStats(), recorder: execution.getStats() }),
+    verifyConfiguration: manifestUpload.verify,
+    captureException: (error, context) => {
+      const runtimeState = context?.runtimeState ?? execution.getErrorState(
+        error,
+        context?.request ? { kind: "http", request: context.request } : void 0
+      );
+      const result = client.captureException(error, { ...context, runtimeState });
+      manifestUpload.flushSoon();
+      return result;
+    },
+    flush: async (timeoutMs) => {
+      await client.flush(timeoutMs);
+      await manifestUpload.wait();
+    },
+    close: async () => {
+      uninstallRuntime();
+      manifestUpload.disconnect();
+      await client.close();
+      await manifestUpload.wait();
+    }
+  };
+};
 var RasputinInit = (options) => {
   try {
     const client = createClient(options, { sdkVersion: SDK_VERSION, sdkName: SDK_NAME });
+    const recorderEnabled = isClientEnabled(options) && options.executionRecorder?.enabled !== false;
+    const execution = createExecutionRecorder({
+      ...options.executionRecorder,
+      enabled: recorderEnabled
+    });
+    const wrappedClient = withExecution(client, execution, recorderEnabled, {
+      projectApiKey: options.projectApiKey,
+      release: options.release,
+      apiUrl: options.apiUrl,
+      enabled: isClientEnabled(options),
+      sourceRoot: options.sourceRoot,
+      sourceRoots: options.sourceRoots,
+      logSuccess: options.logSuccess
+    });
     if (isClientEnabled(options)) {
-      installGlobalHandlers(client);
+      installGlobalHandlers(wrappedClient);
     }
-    return client;
+    return wrappedClient;
   } catch {
-    return createClient({ ...options, enabled: false });
+    return withExecution(
+      createClient({ ...options, enabled: false }),
+      createExecutionRecorder({ enabled: false }),
+      false,
+      {
+        projectApiKey: options.projectApiKey,
+        release: options.release,
+        apiUrl: options.apiUrl,
+        enabled: false,
+        sourceRoot: options.sourceRoot,
+        sourceRoots: options.sourceRoots,
+        logSuccess: options.logSuccess
+      }
+    );
   }
 };
 export {
   RasputinInit,
-  installGlobalHandlers
+  createExecutionRecorder,
+  installAutomaticExecutionRuntime,
+  installGlobalHandlers,
+  scheduleInstrumentationManifestUpload
 };