@rasputin-ai/node 0.5.0-alpha.8 → 0.5.0

package/dist/index.js

@@ -1,107 +1,10 @@
-// src/auto-instrumentation/schedule-instrumentation-manifest-upload.ts
+// src/rasputin-init.ts
+import { join } from "node:path";
 import {
-  detectRelease,
-  resolveEndpointUrls,
-  uploadInstrumentationManifest
+  createClient,
+  isClientEnabled
 } 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 { existsSync, readFileSync } from "node:fs";
@@ -115,6 +18,8 @@ import {
   runtimeFunctionId,
   sourceLocatorFromFile
 } from "@rasputin-ai/core";
+var encodedPlanOmitsCallValues = (plan) => plan[6] === 1;
+var encodedPlanHasPreBodyParameterEvaluation = (plan) => plan[7] === 1;
 var EVENT_PAIR_BASE_ESTIMATED_BYTES = 512;
 var definitionFromEncodedPlan = (plan) => {
   const [functionId, name, packageName, packageRelativePath, line, column] = plan;
@@ -127,7 +32,8 @@ var definitionFromEncodedPlan = (plan) => {
   return {
     functionId,
     name,
-    ...source ? { source } : {}
+    ...source ? { source } : {},
+    ...encodedPlanHasPreBodyParameterEvaluation(plan) ? { parentAttribution: "pre_body_parameter_evaluation" } : {}
   };
 };
 var estimatedCallBytesFor = (functionId) => EVENT_PAIR_BASE_ESTIMATED_BYTES + Buffer.byteLength(functionId, "utf8") * 2;
@@ -138,13 +44,16 @@ var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
 var getRegistry = () => {
   const existing = Reflect.get(globalThis, registrySymbol);
   if (existing?.__rasputinManifestRegistry && existing.files instanceof Map && typeof existing.generation === "number" && typeof existing.uploadedGeneration === "number") {
-    return existing;
+    const registry2 = existing;
+    if (typeof registry2.alreadyInstrumented !== "number") registry2.alreadyInstrumented = 0;
+    return registry2;
   }
   const registry = {
     __rasputinManifestRegistry: true,
     files: /* @__PURE__ */ new Map(),
     generation: 0,
-    uploadedGeneration: 0
+    uploadedGeneration: 0,
+    alreadyInstrumented: 0
   };
   Reflect.set(globalThis, registrySymbol, registry);
   return registry;
@@ -180,18 +89,60 @@ var isInstrumentationManifestDirty = () => {
   return registry.generation !== registry.uploadedGeneration && (registry.files.size > 0 || registry.prebuilt !== void 0);
 };
 var instrumentationManifestGeneration = () => getRegistry().generation;
+var instrumentationCoverageStats = () => {
+  const registry = getRegistry();
+  let instrumented = 0;
+  let instrumentedAsync = 0;
+  const skippedByReason = {};
+  for (const delta of registry.files.values()) {
+    for (const fn of delta.functions) {
+      if (fn.instrumented === false) {
+        if (!fn.skipReason) continue;
+        skippedByReason[fn.skipReason] = (skippedByReason[fn.skipReason] ?? 0) + 1;
+      } else {
+        instrumented += 1;
+        if (fn.asyncFunction) instrumentedAsync += 1;
+      }
+    }
+  }
+  if (registry.alreadyInstrumented > 0) {
+    skippedByReason.already_instrumented = registry.alreadyInstrumented;
+  }
+  return {
+    instrumented,
+    instrumentedAsync,
+    alreadyInstrumented: registry.alreadyInstrumented,
+    skippedByReason
+  };
+};
 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 snapshotOptionsKey = (options) => JSON.stringify({
+  sourceRoot: options.sourceRoot ?? "",
+  sourceRoots: options.sourceRoots ?? {}
+});
 var snapshotInstrumentationManifest = (options = {}) => {
+  const registry = getRegistry();
+  const optionsKey = snapshotOptionsKey(options);
+  if (registry.snapshotCache && registry.snapshotCache.generation === registry.generation && registry.snapshotCache.optionsKey === optionsKey) {
+    return registry.snapshotCache.manifest;
+  }
   const functions = [];
   const callSites = [];
   const destructures = [];
-  const derivationPlans = [];
-  for (const delta of getRegistry().files.values()) {
+  const remember = (manifest) => {
+    registry.snapshotCache = {
+      generation: registry.generation,
+      optionsKey,
+      manifest
+    };
+    return manifest;
+  };
+  for (const delta of registry.files.values()) {
     for (const fn of delta.functions) {
       const definition = definitionFromEncodedPlan(fn.plan);
       if (!definition.source) continue;
@@ -203,7 +154,8 @@ var snapshotInstrumentationManifest = (options = {}) => {
         startColumn: fn.startColumn,
         endLine: fn.endLine,
         endColumn: fn.endColumn,
-        params: fn.params
+        params: fn.params,
+        ...fn.instrumented === false ? { instrumented: false, skipReason: fn.skipReason } : {}
       });
     }
     for (const site of delta.callSites) {
@@ -242,25 +194,23 @@ var snapshotInstrumentationManifest = (options = {}) => {
         binding: destructure.binding
       });
     }
-    derivationPlans.push(...delta.derivationPlans ?? []);
   }
-  const registry = getRegistry();
   if (registry.prebuilt && registry.files.size === 0) {
     const prebuilt = registry.prebuilt;
-    if (!options.sourceRoot && !options.sourceRoots) return prebuilt;
-    return {
+    if (!options.sourceRoot && !options.sourceRoots) return remember(prebuilt);
+    return remember({
       ...prebuilt,
       sourceRoots: {
         ...options.sourceRoot ? { default: options.sourceRoot } : {},
         packages: { ...options.sourceRoots ?? {} }
       }
-    };
+    });
   }
   if (functions.length === 0 && callSites.length === 0 && destructures.length === 0) {
-    return void 0;
+    return remember(void 0);
   }
   const packages = { ...options.sourceRoots ?? {} };
-  return {
+  return remember({
     schema_version: INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
     ...options.sourceRoot || Object.keys(packages).length > 0 ? {
       sourceRoots: {
@@ -270,9 +220,8 @@ var snapshotInstrumentationManifest = (options = {}) => {
     } : {},
     functions,
     callSites,
-    destructures,
-    derivationPlans
-  };
+    destructures
+  });
 };
 var markInstrumentationManifestUploaded = (generation) => {
   const registry = getRegistry();
@@ -282,6 +231,116 @@ var setInstrumentationManifestOnDirty = (onDirty) => {
   getRegistry().onDirty = onDirty;
 };
 
+// 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`,
+    ...input.instrumentedAsync ? [`\u2713 ${counted(input.instrumentedAsync, "async function", "async functions")} instrumented`] : [],
+    ...input.skippedFunctions ? [`! ${counted(input.skippedFunctions, "function", "functions")} skipped`] : [],
+    ...Object.entries(input.skippedByReason ?? {}).filter(([, count]) => (count ?? 0) > 0).sort(([left], [right]) => left.localeCompare(right)).map(([reason, count]) => `  ${reason}: ${count}`),
+    ...input.attributionDegradations ? [
+      `! ${counted(input.attributionDegradations, "runtime attribution degradation", "runtime attribution degradations")}`
+    ] : [],
+    `\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/schedule-instrumentation-manifest-upload.ts
 var unavailable = () => ({
   status: "unavailable",
@@ -301,81 +360,162 @@ var noopHandle = {
   }
 };
 var scheduleInstrumentationManifestUpload = (options) => {
-  const release = detectRelease({ release: options.release });
-  if (!options.enabled || !release || !options.projectApiKey.trim()) {
+  if (!options.enabled || !(options.projectApiKey ?? "").trim()) {
     return noopHandle;
   }
+  const release = detectRelease({ release: options.release });
+  if (!release) return noopHandle;
   const { instrumentationManifestUrl } = resolveEndpointUrls(options.apiUrl);
-  let inflight;
+  let inflight = Promise.resolve();
   let verification = unavailable();
   let loggedSuccess = false;
   let loggedFailure = false;
+  let stopped = false;
+  let working = false;
+  let debounceTimer;
+  const sessionAbort = new AbortController();
+  const debounceMs = 500;
   const packageNamesOf = (manifest) => [
     ...new Set(
       manifest.functions.map((fn) => fn.source.packageName).filter((name) => Boolean(name))
     )
   ].sort();
   const report = (manifest, uploaded, next) => {
+    const coverage = instrumentationCoverageStats();
     return formatConfigurationReport({
       release,
       runtime: runtimeLabel(),
       modules: instrumentationManifestModuleCount(),
-      functions: manifest.functions.length,
+      functions: manifest.functions.filter((fn) => fn.instrumented !== false).length,
+      skippedFunctions: manifest.functions.filter((fn) => fn.instrumented === false).length,
+      instrumentedAsync: coverage.instrumentedAsync,
+      skippedByReason: coverage.skippedByReason,
       packageNames: packageNamesOf(manifest),
       verification: next,
       uploaded
     });
   };
+  const clearDebounce = () => {
+    if (debounceTimer === void 0) return;
+    clearTimeout(debounceTimer);
+    debounceTimer = void 0;
+  };
   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));
+    clearDebounce();
+    if (stopped || !isInstrumentationManifestDirty() || working) return;
+    working = true;
+    inflight = inflight.catch(() => {
+    }).then(async () => {
+      try {
+        while (!stopped && isInstrumentationManifestDirty()) {
+          const generation = instrumentationManifestGeneration();
+          const manifest = snapshotInstrumentationManifest({
+            sourceRoot: options.sourceRoot,
+            sourceRoots: options.sourceRoots
+          });
+          if (!manifest) {
+            markInstrumentationManifestUploaded(generation);
+            continue;
+          }
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), 2e3);
+          timeout.unref?.();
+          const abortUpload = () => controller.abort();
+          sessionAbort.signal.addEventListener("abort", abortUpload, { once: true });
+          if (sessionAbort.signal.aborted) controller.abort();
+          const aborted = new Promise((_, reject) => {
+            const fail = () => reject(controller.signal.reason ?? new Error("aborted"));
+            if (controller.signal.aborted) {
+              fail();
+              return;
+            }
+            controller.signal.addEventListener("abort", fail, { once: true });
+          });
+          try {
+            const result = await Promise.race([
+              uploadInstrumentationManifest({
+                url: instrumentationManifestUrl,
+                projectApiKey: options.projectApiKey,
+                release,
+                manifest,
+                fetch: options.fetch,
+                signal: controller.signal
+              }),
+              aborted
+            ]);
+            if (stopped) return;
+            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));
+                }
+                continue;
+              }
+              if (!loggedFailure) {
+                loggedFailure = true;
+                console.warn(report(manifest, true, verification));
+              }
+              continue;
+            }
+            if (!loggedFailure) {
+              loggedFailure = true;
+              console.warn(report(manifest, false, unavailable()));
+            }
+            break;
+          } catch {
+            if (stopped) return;
+            break;
+          } finally {
+            clearTimeout(timeout);
+            sessionAbort.signal.removeEventListener("abort", abortUpload);
           }
-          return;
-        }
-        if (!loggedFailure) {
-          loggedFailure = true;
-          console.warn(report(manifest, true, verification));
         }
-        return;
-      }
-      if (!loggedFailure) {
-        loggedFailure = true;
-        console.warn(report(manifest, false, unavailable()));
+      } finally {
+        working = false;
       }
     });
-    inflight = inflight ? inflight.then(() => work) : work;
   };
-  setInstrumentationManifestOnDirty(flushSoon);
-  flushSoon();
+  const armFlush = () => {
+    if (stopped || !isInstrumentationManifestDirty()) return;
+    clearDebounce();
+    debounceTimer = setTimeout(() => {
+      debounceTimer = void 0;
+      flushSoon();
+    }, debounceMs);
+    debounceTimer.unref?.();
+  };
+  setInstrumentationManifestOnDirty(armFlush);
+  if (isInstrumentationManifestDirty()) armFlush();
   return {
     flushSoon,
-    wait: async () => {
-      await inflight;
-    },
-    disconnect: () => {
+    wait: async (timeoutMs) => {
+      flushSoon();
+      if (timeoutMs === void 0) {
+        await inflight;
+        return;
+      }
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, timeoutMs);
+        void inflight.then(
+          () => {
+            clearTimeout(timer);
+            resolve();
+          },
+          () => {
+            clearTimeout(timer);
+            resolve();
+          }
+        );
+      });
+    },
+    disconnect: () => {
+      stopped = true;
+      clearDebounce();
       setInstrumentationManifestOnDirty(void 0);
+      sessionAbort.abort();
     },
     verify: async () => {
       flushSoon();
@@ -388,9 +528,8 @@ var scheduleInstrumentationManifestUpload = (options) => {
 // src/execution-recorder/execution-recorder.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import {
-  capturedValueCompleteness,
-  hashInstrumentationManifest,
   rasputinOmitted,
+  rasputinTagKind,
   runtimeFunctionId as runtimeFunctionId2
 } from "@rasputin-ai/core";
 
@@ -475,13 +614,18 @@ var ExecutionJournal = class {
       args,
       NO_SUPPRESSION
     )) {
+      this.dropped += 2;
       return;
     }
     this.openCallIds.add(callId);
   }
   finishCall(kind, callId, timestampNs, durationNs, payload) {
-    if (!this.openCallIds.delete(callId)) return;
-    this.write(kind, 0, callId, void 0, timestampNs, durationNs, payload, NO_SUPPRESSION);
+    if (!this.openCallIds.has(callId)) return;
+    if (!this.write(kind, 0, callId, void 0, timestampNs, durationNs, payload, NO_SUPPRESSION)) {
+      this.dropped++;
+      return;
+    }
+    this.openCallIds.delete(callId);
   }
   dropCall() {
     this.dropped += 2;
@@ -812,6 +956,10 @@ var RecorderMemoryBudget = class {
     return allocation;
   }
   captureValue(allocation, serialize) {
+    if (allocation.released) {
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
     if (allocation.mode !== "full") {
       this.dropValues(allocation, 1);
       return MEMORY_BUDGET_VALUE_MARKER;
@@ -856,6 +1004,13 @@ var RecorderMemoryBudget = class {
     this.markPressure(allocation, "metadata-only");
     return false;
   }
+  releaseStorage(allocation, bytes) {
+    if (allocation.released) return;
+    const boundedBytes = Math.max(0, Math.ceil(bytes));
+    allocation.estimatedBytes = Math.max(0, allocation.estimatedBytes - boundedBytes);
+    this.activeEstimatedBytes = Math.max(0, this.activeEstimatedBytes - boundedBytes);
+    this.stats.activeEstimatedBytes = this.activeEstimatedBytes;
+  }
   release(allocation) {
     if (allocation.released) return;
     allocation.released = true;
@@ -866,6 +1021,7 @@ var RecorderMemoryBudget = class {
     return { ...this.stats };
   }
   reserve(allocation, bytes) {
+    if (allocation.released) return false;
     const boundedBytes = Math.max(0, Math.ceil(bytes));
     if (this.activeEstimatedBytes + boundedBytes > this.maximumBytes) return false;
     this.activeEstimatedBytes += boundedBytes;
@@ -898,17 +1054,248 @@ var RecorderMemoryBudget = class {
   }
 };
 
-// src/execution-recorder/safe-serialize.ts
+// src/execution-recorder/run-exactly-once.ts
+var runExactlyOnce = function __rasputinHandleRun__(invoke, callback) {
+  let outcome;
+  const wrapped = function __rasputinHandleRun__3() {
+    try {
+      const value = callback();
+      outcome = { kind: "value", value };
+      return value;
+    } catch (caught) {
+      outcome = { kind: "throw", error: caught };
+      throw caught;
+    }
+  };
+  try {
+    invoke(wrapped);
+  } catch {
+  }
+  if (outcome?.kind === "throw") throw outcome.error;
+  if (outcome?.kind === "value") return outcome.value;
+  return callback();
+};
+
+// src/execution-recorder/runtime-state-size-budget.ts
+import {
+  rasputinUnavailable
+} from "@rasputin-ai/core";
+var DEFAULT_RUNTIME_STATE_TARGET_BYTES = 256 * 1024;
+var DEFAULT_MAX_RUNTIME_STATE_BYTES = 512 * 1024;
+var VALUE_OMITTED_REASON = "runtime_state_size_budget";
+var encodedBytes = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+var boundedLimit = (value, fallback) => Number.isFinite(value) ? Math.max(4 * 1024, Math.floor(value)) : fallback;
+var sizeMetadata = (originalBytes, targetBytes, maximumBytes) => ({
+  reason: "runtime_state_size_budget",
+  originalBytes,
+  finalBytes: 0,
+  targetBytes,
+  maximumBytes,
+  eventValuesDropped: 0,
+  eventsDropped: 0,
+  functionDefinitionsDropped: 0
+});
+var withSizeMetadata = (state, size) => ({
+  ...state,
+  truncated: {
+    eventsDropped: state.truncated?.eventsDropped ?? 0,
+    ...state.truncated,
+    size
+  }
+});
+var settleFinalBytes = (state) => {
+  const size = state.truncated?.size;
+  if (!size) return state;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const encoded = encodedBytes(state);
+    if (size.finalBytes === encoded) break;
+    size.finalBytes = encoded;
+  }
+  return state;
+};
+var dropEventValues = (events) => {
+  let dropped = 0;
+  const marker = () => rasputinUnavailable(VALUE_OMITTED_REASON);
+  const bounded = events.map((event) => {
+    if (event.type === "function_enter") {
+      dropped += event.args.length;
+      return { ...event, args: event.args.map(marker) };
+    }
+    if (event.type === "function_exit" && "returnValue" in event) {
+      dropped++;
+      return { ...event, returnValue: marker() };
+    }
+    if (event.type === "function_throw" && "error" in event) {
+      dropped++;
+      return { ...event, error: marker() };
+    }
+    return { ...event };
+  });
+  return { events: bounded, dropped };
+};
+var truncateUtf8 = (value, maximumBytes) => {
+  if (value === void 0 || Buffer.byteLength(value, "utf8") <= maximumBytes) return value;
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(value.slice(0, middle), "utf8") <= maximumBytes) low = middle;
+    else high = middle - 1;
+  }
+  return value.slice(0, low);
+};
+var minimalState = (state, size) => {
+  const request = state.execution.request;
+  const execution = {
+    kind: state.execution.kind,
+    ...state.execution.name === void 0 ? {} : { name: truncateUtf8(state.execution.name, 4 * 1024) },
+    ...request ? {
+      request: {
+        ...request.method == null ? {} : { method: truncateUtf8(request.method, 1024) },
+        ...request.route == null ? {} : { route: truncateUtf8(request.route, 4 * 1024) },
+        ...request.status == null ? {} : { status: request.status }
+      }
+    } : {}
+  };
+  return withSizeMetadata(
+    {
+      version: 4,
+      captureProfile: {
+        source: state.captureProfile.source,
+        functionBoundaries: state.captureProfile.functionBoundaries === "none" ? "none" : "partial",
+        functionValues: "none",
+        timings: state.captureProfile.timings === "none" ? "none" : "partial"
+      },
+      executionId: truncateUtf8(state.executionId, 256) ?? "",
+      startedAt: truncateUtf8(state.startedAt, 128) ?? "",
+      durationMs: Number.isFinite(state.durationMs) ? state.durationMs : 0,
+      recorder: {
+        inlineWallTimeMs: Number.isFinite(state.recorder?.inlineWallTimeMs) ? state.recorder.inlineWallTimeMs : 0
+      },
+      execution,
+      functions: [],
+      events: [],
+      ...state.capture ? { capture: { ...state.capture } } : {}
+    },
+    size
+  );
+};
+var enforceRuntimeStateSizeBudget = (input, options = {}) => {
+  const maximumBytes = boundedLimit(options.maximumBytes, DEFAULT_MAX_RUNTIME_STATE_BYTES);
+  const targetBytes = Math.min(
+    maximumBytes,
+    boundedLimit(options.targetBytes, DEFAULT_RUNTIME_STATE_TARGET_BYTES)
+  );
+  const initialBytes = encodedBytes(input);
+  const existingSize = input.truncated?.size;
+  if (existingSize && initialBytes <= maximumBytes) return settleFinalBytes(input);
+  if (initialBytes <= maximumBytes) return input;
+  const originalBytes = existingSize?.originalBytes ?? initialBytes;
+  const size = sizeMetadata(originalBytes, targetBytes, maximumBytes);
+  let state = input;
+  const stripped = dropEventValues(state.events);
+  size.eventValuesDropped += stripped.dropped;
+  state = settleFinalBytes(
+    withSizeMetadata(
+      {
+        ...state,
+        captureProfile: {
+          ...state.captureProfile,
+          functionValues: state.captureProfile.functionValues === "none" ? "none" : "selective"
+        },
+        events: stripped.events
+      },
+      size
+    )
+  );
+  if (encodedBytes(state) <= maximumBytes) return state;
+  size.eventsDropped += state.events.length;
+  size.functionDefinitionsDropped += state.functions.length;
+  state = settleFinalBytes(
+    withSizeMetadata(
+      {
+        ...state,
+        captureProfile: {
+          ...state.captureProfile,
+          functionBoundaries: state.captureProfile.functionBoundaries === "none" ? "none" : "partial",
+          functionValues: "none",
+          timings: state.captureProfile.timings === "none" ? "none" : "partial"
+        },
+        functions: [],
+        events: [],
+        truncated: {
+          eventsDropped: (state.truncated?.eventsDropped ?? 0) + size.eventsDropped,
+          size
+        }
+      },
+      size
+    )
+  );
+  if (encodedBytes(state) <= maximumBytes) return state;
+  state = settleFinalBytes(minimalState(state, size));
+  if (encodedBytes(state) <= maximumBytes) return state;
+  const emergency = {
+    version: 4,
+    captureProfile: {
+      source: state.captureProfile.source,
+      functionBoundaries: "partial",
+      functionValues: "none",
+      timings: "partial"
+    },
+    executionId: "",
+    startedAt: "",
+    durationMs: 0,
+    execution: { kind: state.execution.kind },
+    functions: [],
+    events: [],
+    truncated: { eventsDropped: size.eventsDropped, size }
+  };
+  return settleFinalBytes(emergency);
+};
+
+// src/execution-recorder/encode-frozen.ts
+import { Buffer as Buffer3 } from "node:buffer";
+
+// src/execution-recorder/value-freeze.ts
 import { Buffer as Buffer2 } from "node:buffer";
-var DEFAULT_REDACT_KEYS = [
-  "password",
-  "token",
-  "authorization",
-  "cookie",
-  "secret",
-  "apikey",
-  "creditcard"
-];
+import { types } from "node:util";
+import { RASPUTIN_WIRE_TAG } from "@rasputin-ai/core";
+
+// src/execution-recorder/redact-keys.ts
+import { defaultSensitivePropertyNames, propertyNameIsSensitive } from "@rasputin-ai/core";
+var compactKey = (key) => {
+  let compacted = "";
+  for (let index = 0; index < key.length; index++) {
+    const code = key.charCodeAt(index);
+    if (code === 45 || code === 46 || code === 95) continue;
+    compacted += code >= 65 && code <= 90 ? String.fromCharCode(code + 32) : key[index];
+  }
+  return compacted;
+};
+var stripTrailingDigits = (value) => {
+  let end = value.length;
+  while (end > 0) {
+    const code = value.charCodeAt(end - 1);
+    if (code < 48 || code > 57) break;
+    end--;
+  }
+  return end === 0 ? value : value.slice(0, end);
+};
+var normalizeKey = (key) => stripTrailingDigits(compactKey(key));
+var compileRedactKeys = (extra) => {
+  if (!extra?.length) return defaultSensitivePropertyNames();
+  return /* @__PURE__ */ new Set([...defaultSensitivePropertyNames(), ...extra.map(normalizeKey)]);
+};
+var keyIsRedacted = (key, redactKeys) => {
+  if (propertyNameIsSensitive(key)) return true;
+  if (redactKeys.has(key)) return true;
+  const compacted = compactKey(key);
+  if (redactKeys.has(compacted)) return true;
+  return redactKeys.has(stripTrailingDigits(compacted));
+};
+
+// src/execution-recorder/value-freeze.ts
+var REDACTED = "[RASPUTIN_REDACTED]";
 var defaults = {
   maxDepth: 3,
   maxObjectKeys: 30,
@@ -916,441 +1303,1017 @@ var defaults = {
   maxStringLength: 500,
   maxSerializedValueBytes: 8 * 1024
 };
-var REDACTED = "[RASPUTIN_REDACTED]";
-var truncation = (reason, extra = {}) => ({
-  __rasputin_truncated: true,
-  __reason: reason,
-  ...extra
+var compileFreezeLimits = (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 typeMarker = (type, value) => ({
-  __rasputin_type: type,
-  ...value === void 0 ? {} : { value }
+var FROZEN = Symbol("rasputin.frozen");
+var NODE = 24;
+var taggedNumberKind = (value) => {
+  if (Number.isNaN(value)) return "NaN";
+  if (value === Infinity) return "Infinity";
+  if (value === -Infinity) return "-Infinity";
+  if (Object.is(value, -0)) return "-0";
+  return void 0;
+};
+var atom = (kind, extra = {}) => ({
+  [FROZEN]: kind,
+  ...extra
 });
-var jsonStringUtf8Bytes = (value) => {
-  let bytes = 2;
-  for (let index = 0; index < value.length; index++) {
-    const code = value.charCodeAt(index);
-    if (code === 34 || code === 92) {
-      bytes += 2;
-      continue;
-    }
-    if (code === 8 || code === 9 || code === 10 || code === 12 || code === 13) {
-      bytes += 2;
-      continue;
+var ownData = (value, key) => {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor) return void 0;
+    if ("value" in descriptor) return { present: true, value: descriptor.value };
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+var nativeErrorStackGet = (() => {
+  try {
+    return Object.getOwnPropertyDescriptor(Error.prototype, "stack")?.get;
+  } catch {
+    return void 0;
+  }
+})();
+var nativeInstanceStackGet = (() => {
+  try {
+    const probe = new Error("rasputin-stack-probe");
+    return Object.getOwnPropertyDescriptor(probe, "stack")?.get;
+  } catch {
+    return void 0;
+  }
+})();
+var nativeErrorMessageGet = (() => {
+  try {
+    return Object.getOwnPropertyDescriptor(Error.prototype, "message")?.get;
+  } catch {
+    return void 0;
+  }
+})();
+var typedArrayProto = Object.getPrototypeOf(Uint8Array.prototype);
+var typedArrayByteLengthGet = typedArrayProto ? Object.getOwnPropertyDescriptor(typedArrayProto, "byteLength")?.get : void 0;
+var typedArrayByteOffsetGet = typedArrayProto ? Object.getOwnPropertyDescriptor(typedArrayProto, "byteOffset")?.get : void 0;
+var typedArrayBufferGet = typedArrayProto ? Object.getOwnPropertyDescriptor(typedArrayProto, "buffer")?.get : void 0;
+var dataViewByteLengthGet = Object.getOwnPropertyDescriptor(
+  DataView.prototype,
+  "byteLength"
+)?.get;
+var domExceptionNameGet = typeof DOMException === "undefined" ? void 0 : Object.getOwnPropertyDescriptor(DOMException.prototype, "name")?.get;
+var domExceptionMessageGet = typeof DOMException === "undefined" ? void 0 : Object.getOwnPropertyDescriptor(DOMException.prototype, "message")?.get;
+var prepareStackTraceDepth = 0;
+var savedPrepareStackTrace;
+var withoutPrepareStackTrace = (read) => {
+  if (prepareStackTraceDepth === 0) {
+    savedPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = void 0;
+  }
+  prepareStackTraceDepth += 1;
+  try {
+    return read();
+  } finally {
+    prepareStackTraceDepth -= 1;
+    if (prepareStackTraceDepth === 0) Error.prepareStackTrace = savedPrepareStackTrace;
+  }
+};
+var isDomException = (value) => {
+  try {
+    return typeof DOMException !== "undefined" && value instanceof DOMException;
+  } catch {
+    return false;
+  }
+};
+var functionNameOf = (value) => {
+  const own = ownData(value, "name");
+  if (own && typeof own.value === "string" && own.value.length > 0) return own.value;
+  return "anonymous";
+};
+var errorNameOf = (value) => {
+  if (isDomException(value) && domExceptionNameGet) {
+    try {
+      const name = domExceptionNameGet.call(value);
+      if (typeof name === "string" && name.length > 0) return name;
+    } catch {
     }
-    if (code < 32) {
-      bytes += 6;
-      continue;
+  }
+  let current = value;
+  while (current) {
+    const slot = ownData(current, "name");
+    if (slot && typeof slot.value === "string" && slot.value.length > 0) return slot.value;
+    try {
+      current = Object.getPrototypeOf(current);
+    } catch {
+      break;
     }
-    if (code < 128) {
-      bytes += 1;
-      continue;
+  }
+  return "Error";
+};
+var errorMessageOf = (value) => {
+  if (isDomException(value) && domExceptionMessageGet) {
+    try {
+      return domExceptionMessageGet.call(value);
+    } catch {
     }
-    if (code < 2048) {
-      bytes += 2;
-      continue;
+  }
+  const own = ownData(value, "message");
+  if (own) return own.value;
+  if (!nativeErrorMessageGet) return void 0;
+  try {
+    return nativeErrorMessageGet.call(value);
+  } catch {
+    return void 0;
+  }
+};
+var errorStackOf = (value) => withoutPrepareStackTrace(() => {
+  const own = ownData(value, "stack");
+  if (own && typeof own.value === "string" && own.value.length > 0) return own.value;
+  try {
+    const getter = Object.getOwnPropertyDescriptor(value, "stack")?.get;
+    if (getter && nativeInstanceStackGet && getter === nativeInstanceStackGet) {
+      const stack = getter.call(value);
+      if (typeof stack === "string" && stack.length > 0) return stack;
     }
-    if (code >= 55296 && code <= 56319) {
-      const next = value.charCodeAt(index + 1);
-      if (index + 1 < value.length && next >= 56320 && next <= 57343) {
-        bytes += 4;
-        index++;
-        continue;
-      }
-      bytes += 6;
-      continue;
+  } catch {
+  }
+  if (!nativeErrorStackGet) return void 0;
+  try {
+    const stack = nativeErrorStackGet.call(value);
+    return typeof stack === "string" && stack.length > 0 ? stack : void 0;
+  } catch {
+    return void 0;
+  }
+});
+var viewByteLength = (value) => {
+  try {
+    if (types.isDataView(value)) {
+      return dataViewByteLengthGet ? dataViewByteLengthGet.call(value) : 0;
     }
-    if (code >= 56320 && code <= 57343) {
-      bytes += 6;
-      continue;
+    return typedArrayByteLengthGet ? typedArrayByteLengthGet.call(value) : 0;
+  } catch {
+    return 0;
+  }
+};
+var typedArrayName = (value) => {
+  if (types.isUint8Array(value)) return "Uint8Array";
+  if (types.isUint8ClampedArray(value)) return "Uint8ClampedArray";
+  if (types.isInt8Array(value)) return "Int8Array";
+  if (types.isUint16Array(value)) return "Uint16Array";
+  if (types.isInt16Array(value)) return "Int16Array";
+  if (types.isUint32Array(value)) return "Uint32Array";
+  if (types.isInt32Array(value)) return "Int32Array";
+  if (types.isFloat32Array(value)) return "Float32Array";
+  if (types.isFloat64Array(value)) return "Float64Array";
+  if (types.isBigUint64Array(value)) return "BigUint64Array";
+  if (types.isBigInt64Array(value)) return "BigInt64Array";
+  return "TypedArray";
+};
+var prototypeChainHasProxy = (value) => {
+  let current = value;
+  for (let depth = 0; depth < 8; depth++) {
+    try {
+      current = Object.getPrototypeOf(current);
+    } catch {
+      return true;
     }
-    bytes += 3;
+    if (!current) return false;
+    if (types.isProxy(current)) return true;
   }
-  return bytes;
+  return true;
 };
-var jsonLiteralUtf8Bytes = (value) => {
-  if (value === null) return 4;
-  switch (typeof value) {
-    case "boolean":
-      return value ? 4 : 5;
-    case "number":
-      if (!Number.isFinite(value)) return 4;
-      if (Object.is(value, -0)) return 1;
-      return String(value).length;
-    case "string":
-      return jsonStringUtf8Bytes(value);
-    case "object": {
-      if (Array.isArray(value)) {
-        let bytes2 = 2;
-        for (let index = 0; index < value.length; index++) {
-          if (index > 0) bytes2 += 1;
-          bytes2 += jsonLiteralUtf8Bytes(value[index]);
-        }
-        return bytes2;
-      }
-      const record = value;
-      let bytes = 2;
-      let first = true;
-      for (const key of Object.keys(record)) {
-        if (!first) bytes += 1;
-        first = false;
-        bytes += jsonStringUtf8Bytes(key) + 1;
-        bytes += jsonLiteralUtf8Bytes(record[key]);
-      }
-      return bytes;
+var sampleBytes = (bytes, max) => {
+  const length = Math.min(max, bytes.length);
+  const sample = new Array(length);
+  for (let index = 0; index < length; index++) sample[index] = bytes[index] ?? 0;
+  return sample;
+};
+var RESERVED_USER_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "__rasputin_type",
+  "__rasputin_truncated",
+  "__rasputin_fields",
+  "__reason",
+  "__original_length",
+  "__serialized_bytes"
+]);
+var assignFrozenField = (fields, key, value) => {
+  if (RESERVED_USER_KEYS.has(key) || key.startsWith("__rasputin_")) {
+    const escaped = fields.__rasputin_fields ?? [];
+    escaped.push({ name: key, value });
+    fields.__rasputin_fields = escaped;
+    return;
+  }
+  fields[key] = value;
+};
+var ownEnumerableKeys = (value, maxKeys) => {
+  const keys = [];
+  let proto = null;
+  try {
+    proto = Object.getPrototypeOf(value);
+  } catch {
+    proto = null;
+  }
+  const protoIsProxy = proto !== null && types.isProxy(proto);
+  try {
+    for (const key in value) {
+      if (protoIsProxy && !Object.hasOwn(value, key)) break;
+      if (!Object.hasOwn(value, key)) continue;
+      if (keys.length >= maxKeys) return { keys, truncated: true };
+      keys.push(key);
     }
-    default:
-      return Buffer2.byteLength(JSON.stringify(value) ?? "null", "utf8");
+  } catch {
+    return { keys, truncated: keys.length >= maxKeys };
   }
+  return { keys, truncated: false };
 };
-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 bufferByteLength = (value) => {
+  try {
+    return Buffer2.byteLength(value);
+  } catch {
+    return 0;
+  }
 };
-var keyNeedsCaseFold = (key) => {
+var stringEstimate = (value) => NODE + 2 + Buffer2.byteLength(value, "utf8");
+var URL_LIKE_PROPERTY_NAMES = /* @__PURE__ */ new Set([
+  "url",
+  "href",
+  "originalurl",
+  "path",
+  "pathname",
+  "search",
+  "query",
+  "requesturl",
+  "requesturi",
+  "location",
+  "referer",
+  "referrer",
+  "uri",
+  "connectionuri",
+  "connectionurl",
+  "databaseuri",
+  "databaseurl",
+  "mongouri",
+  "mongourl",
+  "redisuri",
+  "redisurl",
+  "postgresuri",
+  "postgresurl"
+]);
+var compactPropertyName = (key) => {
+  let compacted = "";
   for (let index = 0; index < key.length; index++) {
     const code = key.charCodeAt(index);
-    if (code > 127 || code >= 65 && code <= 90) return true;
+    if (code === 45 || code === 46 || code === 95) continue;
+    compacted += code >= 65 && code <= 90 ? String.fromCharCode(code + 32) : key[index];
   }
-  return false;
+  return compacted;
 };
-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;
+var propertyNameLooksLikeUrl = (key) => URL_LIKE_PROPERTY_NAMES.has(compactPropertyName(key));
+var looksLikeBareQueryString = (text) => {
+  if (!text.includes("=") || /\s/.test(text)) return false;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(text) || text.startsWith("/")) return false;
+  return /^[^\s=]+=[^\s]*(&[^\s=]+=[^\s]*)*$/.test(text);
+};
+var redactSensitiveQuery = (text, redactKeys) => {
+  const queryAt = text.indexOf("?");
+  let prefix = "";
+  let query = "";
+  let suffix = "";
+  if (queryAt >= 0) {
+    if (queryAt === text.length - 1) return text;
+    const hashAt = text.indexOf("#", queryAt + 1);
+    prefix = text.slice(0, queryAt + 1);
+    query = hashAt < 0 ? text.slice(queryAt + 1) : text.slice(queryAt + 1, hashAt);
+    suffix = hashAt < 0 ? "" : text.slice(hashAt);
+  } else if (looksLikeBareQueryString(text)) {
+    query = text;
+  } else {
+    return text;
   }
-  return true;
+  if (!query.includes("=")) return text;
+  let changed = false;
+  const next = query.split("&").map((part) => {
+    const equals = part.indexOf("=");
+    const rawKey = equals < 0 ? part : part.slice(0, equals);
+    if (!rawKey) return part;
+    let decoded = rawKey;
+    try {
+      decoded = decodeURIComponent(rawKey.replace(/\+/g, " "));
+    } catch {
+      decoded = rawKey;
+    }
+    if (!keyIsRedacted(decoded, redactKeys) && !keyIsRedacted(rawKey, redactKeys)) return part;
+    changed = true;
+    return `${rawKey}=${REDACTED}`;
+  });
+  if (!changed) return text;
+  return `${prefix}${next.join("&")}${suffix}`;
 };
-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 > maxStringLength || !isJsonSafeString(value)) return void 0;
-    return { value, bytes: 2 + Buffer2.byteLength(value, "utf8"), visitedNodes: 1 };
-  }
-  if (typeof value === "undefined") {
-    const serialized = typeMarker("undefined");
-    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
-  }
-  if (typeof value === "bigint") {
-    const serialized = typeMarker("bigint", value.toString());
-    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
-  }
-  if (typeof value === "symbol") {
-    const text = String(value);
-    if (!isJsonSafeString(text)) return void 0;
-    const serialized = typeMarker("symbol", text);
-    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
-  }
-  if (typeof value === "function") {
-    const name = value.name || "anonymous";
-    if (!isJsonSafeString(name)) return void 0;
-    const serialized = typeMarker("function", name);
-    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
+var redactUrlUserinfo = (text) => {
+  const schemeEnd = text.indexOf("://");
+  if (schemeEnd <= 0) return text;
+  const rest = text.slice(schemeEnd + 3);
+  let authorityEnd = rest.length;
+  for (const marker of ["/", "?", "#"]) {
+    const at = rest.indexOf(marker);
+    if (at >= 0 && at < authorityEnd) authorityEnd = at;
   }
-  return void 0;
+  const authority = rest.slice(0, authorityEnd);
+  const userinfoEnd = authority.lastIndexOf("@");
+  if (userinfoEnd < 0) return text;
+  return `${text.slice(0, schemeEnd + 3)}${REDACTED}@${authority.slice(userinfoEnd + 1)}${rest.slice(authorityEnd)}`;
 };
-var createSafeSerializer = (options = {}) => {
-  const limits = compileLimits(options);
-  const redactKeys = compileRedactKeys(options);
+var redactUrlLikeString = (text, redactKeys) => redactSensitiveQuery(redactUrlUserinfo(text), redactKeys);
+var isFrozenAtom = (value) => typeof value === "object" && value !== null && FROZEN in value;
+var createValueFreezer = (options = {}) => {
+  const limits = compileFreezeLimits(options);
+  const redactKeys = compileRedactKeys(options.redactKeys);
   const sharedPath = /* @__PURE__ */ new Set();
-  let serializing = false;
-  const isRedactedKey = (key) => {
-    if (redactKeys.has(key)) return true;
-    if (!keyNeedsCaseFold(key)) return false;
-    return redactKeys.has(key.toLowerCase());
-  };
-  const addBytes = (metrics, count) => {
-    metrics.bytes += count;
-    if (metrics.bytes > limits.maxSerializedValueBytes) metrics.oversize = true;
-  };
-  const boundedOversize = (bytes, visitedNodes) => {
-    const bounded = truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
-    return { value: bounded, bytes: jsonLiteralUtf8Bytes(bounded), visitedNodes };
-  };
-  const openObject = (metrics, allocate) => {
-    addBytes(metrics, 2);
-    return {
-      target: allocate && !metrics.oversize ? {} : void 0,
-      first: true
-    };
+  let freezing = false;
+  const add = (metrics, count) => {
+    metrics.estimatedBytes += count;
+    if (metrics.estimatedBytes > limits.maxSerializedValueBytes) metrics.oversize = true;
   };
-  const openArray = (metrics, allocate) => {
-    addBytes(metrics, 2);
-    return {
-      items: allocate && !metrics.oversize ? [] : void 0,
-      first: true
-    };
-  };
-  const beginField = (metrics, object, key) => {
-    if (!object.first) addBytes(metrics, 1);
-    object.first = false;
-    addBytes(metrics, jsonStringUtf8Bytes(key) + 1);
-  };
-  const assignField = (object, key, fieldValue) => {
-    if (object.target) object.target[key] = fieldValue;
-  };
-  const writeLiteralField = (metrics, object, key, jsonValue) => {
-    beginField(metrics, object, key);
-    addBytes(metrics, jsonLiteralUtf8Bytes(jsonValue));
-    assignField(object, key, jsonValue);
-  };
-  const writeTypeMarker = (metrics, allocate, type, nestedValue) => {
-    const object = openObject(metrics, allocate);
-    writeLiteralField(metrics, object, "__rasputin_type", type);
-    if (nestedValue !== void 0) writeLiteralField(metrics, object, "value", nestedValue);
-    return object.target;
-  };
-  const writeTruncation = (metrics, allocate, reason, extra = {}) => {
-    const object = openObject(metrics, allocate);
-    writeLiteralField(metrics, object, "__rasputin_truncated", true);
-    writeLiteralField(metrics, object, "__reason", reason);
-    for (const key of Object.keys(extra)) writeLiteralField(metrics, object, key, extra[key]);
-    return object.target;
-  };
-  const serializeInner = (value, depth, path, allocate, metrics) => {
+  const freezeInner = (value, depth, path, metrics) => {
+    if (metrics.oversize) return void 0;
     metrics.visitedNodes++;
-    const store = allocate && !metrics.oversize;
     if (value === null) {
-      addBytes(metrics, 4);
-      return store ? null : void 0;
+      add(metrics, 4);
+      return null;
     }
     if (typeof value === "boolean") {
-      addBytes(metrics, value ? 4 : 5);
-      return store ? value : void 0;
+      add(metrics, value ? 4 : 5);
+      return value;
     }
     if (typeof value === "number") {
-      if (!Number.isFinite(value)) addBytes(metrics, 4);
-      else if (Object.is(value, -0)) addBytes(metrics, 1);
-      else addBytes(metrics, String(value).length);
-      return store ? value : void 0;
+      const kind = taggedNumberKind(value);
+      if (kind) {
+        add(metrics, NODE + 16);
+        return atom(kind);
+      }
+      add(metrics, NODE + String(value).length);
+      return value;
     }
     if (typeof value === "string") {
       if (value.length <= limits.maxStringLength) {
-        addBytes(metrics, jsonStringUtf8Bytes(value));
-        return store ? value : void 0;
+        add(metrics, stringEstimate(value));
+        return value;
       }
-      return writeTruncation(metrics, store, "max_string_length", {
-        __original_length: value.length,
-        value: value.slice(0, limits.maxStringLength)
+      const sliced = value.slice(0, limits.maxStringLength);
+      add(metrics, NODE + stringEstimate(sliced) + 48);
+      return atom("truncated", {
+        reason: "max_string_length",
+        originalLength: value.length,
+        value: sliced
       });
     }
-    if (typeof value === "undefined") return writeTypeMarker(metrics, store, "undefined");
+    if (typeof value === "undefined") {
+      add(metrics, NODE + 16);
+      return atom("undefined");
+    }
     if (typeof value === "bigint") {
-      return writeTypeMarker(metrics, store, "bigint", value.toString());
+      const text = value.toString();
+      add(metrics, NODE + stringEstimate(text));
+      return atom("bigint", { value: text });
     }
     if (typeof value === "symbol") {
-      return writeTypeMarker(metrics, store, "symbol", String(value));
+      const text = String(value);
+      add(metrics, NODE + stringEstimate(text));
+      return atom("symbol", { value: text });
     }
     if (typeof value === "function") {
-      return writeTypeMarker(metrics, store, "function", value.name || "anonymous");
+      if (types.isProxy(value)) {
+        add(metrics, NODE + 16);
+        return atom("Proxy");
+      }
+      const name = functionNameOf(value);
+      add(metrics, NODE + stringEstimate(name));
+      return atom("function", { value: name });
+    }
+    if (typeof value !== "object") {
+      add(metrics, NODE + 16);
+      return atom("unserializable");
+    }
+    if (path.has(value)) {
+      add(metrics, NODE + 16);
+      return atom("circular");
     }
-    if (depth >= limits.maxDepth) return writeTruncation(metrics, store, "max_depth");
-    if (typeof value !== "object") return writeTypeMarker(metrics, store, typeof value);
-    if (path.has(value)) return writeTypeMarker(metrics, store, "circular");
     path.add(value);
-    const bytesBefore = metrics.bytes;
-    const oversizeBefore = metrics.oversize;
     try {
-      const childAllocate = allocate && !metrics.oversize;
-      if (value instanceof Error) {
-        const object2 = openObject(metrics, childAllocate);
-        writeLiteralField(metrics, object2, "__rasputin_type", "Error");
-        writeLiteralField(metrics, object2, "name", value.name);
-        beginField(metrics, object2, "message");
-        assignField(
-          object2,
-          "message",
-          serializeInner(value.message, depth + 1, path, childAllocate, metrics)
-        );
-        if (value.stack) {
-          beginField(metrics, object2, "stack");
-          assignField(
-            object2,
-            "stack",
-            serializeInner(value.stack, depth + 1, path, childAllocate, metrics)
-          );
-        }
-        return object2.target;
+      if (types.isProxy(value) || prototypeChainHasProxy(value)) {
+        add(metrics, NODE + 16);
+        return atom("Proxy");
+      }
+      if (types.isDate(value)) {
+        const time = Date.prototype.getTime.call(value);
+        const iso = Number.isFinite(time) ? new Date(time).toISOString() : "Invalid Date";
+        add(metrics, NODE + stringEstimate(iso));
+        return atom("Date", { value: iso });
+      }
+      if (depth >= limits.maxDepth) {
+        add(metrics, NODE + 32);
+        return atom("truncated", { reason: "max_depth" });
       }
-      if (value instanceof Date) {
-        return writeTypeMarker(metrics, childAllocate, "Date", value.toISOString());
+      if (types.isNativeError(value) || isDomException(value)) {
+        add(metrics, NODE + 32);
+        const name = errorNameOf(value);
+        add(metrics, stringEstimate(name));
+        const message = freezeInner(errorMessageOf(value), depth + 1, path, metrics);
+        const stack = errorStackOf(value);
+        const extras = {};
+        for (const key of ["code", "cause", "statusCode"]) {
+          const slot = ownData(value, key);
+          if (!slot) continue;
+          extras[key] = freezeInner(slot.value, depth + 1, path, metrics);
+        }
+        return atom("Error", {
+          name,
+          message,
+          ...extras,
+          ...stack ? { stack: freezeInner(stack, depth + 1, path, metrics) } : {}
+        });
       }
       if (Buffer2.isBuffer(value)) {
-        return writeTypeMarker(metrics, childAllocate, "Buffer", {
-          byteLength: value.byteLength,
-          base64: value.subarray(0, limits.maxStringLength).toString("base64"),
-          ...value.byteLength > limits.maxStringLength ? { __rasputin_truncated: true } : {}
+        const byteLength = bufferByteLength(value);
+        const slice = Buffer2.prototype.subarray.call(value, 0, limits.maxStringLength);
+        const base64 = Buffer2.prototype.toString.call(slice, "base64");
+        add(metrics, NODE + stringEstimate(base64) + 24);
+        return atom("Buffer", {
+          byteLength,
+          base64,
+          ...byteLength > limits.maxStringLength ? { truncated: true } : {}
         });
       }
-      if (value instanceof Promise) return writeTypeMarker(metrics, childAllocate, "Promise");
-      if (value instanceof Map) {
-        const object2 = openObject(metrics, childAllocate);
-        writeLiteralField(metrics, object2, "__rasputin_type", "Map");
-        beginField(metrics, object2, "entries");
-        const entries = openArray(metrics, childAllocate);
+      if (types.isPromise(value)) {
+        add(metrics, NODE + 16);
+        return atom("Promise");
+      }
+      if (types.isMap(value)) {
+        add(metrics, NODE + 16);
+        const entries = [];
         let counted2 = 0;
-        for (const entry of value.entries()) {
-          if (counted2 >= limits.maxArrayElements) break;
-          if (!entries.first) addBytes(metrics, 1);
-          entries.first = false;
-          addBytes(metrics, 2);
-          const key = serializeInner(entry[0], depth + 1, path, childAllocate, metrics);
-          addBytes(metrics, 1);
-          const mapped = serializeInner(entry[1], depth + 1, path, childAllocate, metrics);
-          entries.items?.push([key, mapped]);
+        const mapSize = Object.getOwnPropertyDescriptor(Map.prototype, "size")?.get;
+        const size = mapSize ? mapSize.call(value) : 0;
+        for (const mapKey of Map.prototype.keys.call(value)) {
+          if (counted2 >= limits.maxArrayElements || metrics.oversize) break;
+          const key = freezeInner(mapKey, depth + 1, path, metrics);
+          if (typeof mapKey === "string" && keyIsRedacted(mapKey, redactKeys)) {
+            add(metrics, stringEstimate(REDACTED));
+            entries.push([key, REDACTED]);
+          } else {
+            entries.push([
+              key,
+              freezeInner(Map.prototype.get.call(value, mapKey), depth + 1, path, metrics)
+            ]);
+          }
           counted2++;
         }
-        assignField(object2, "entries", entries.items ?? []);
-        if (value.size > limits.maxArrayElements) {
-          writeLiteralField(metrics, object2, "__rasputin_truncated", true);
-          writeLiteralField(metrics, object2, "__reason", "max_array_elements");
-          writeLiteralField(metrics, object2, "__original_length", value.size);
-        }
-        return object2.target;
+        return atom("Map", {
+          entries,
+          ...size > limits.maxArrayElements ? { truncated: true, reason: "max_array_elements", originalLength: size } : {}
+        });
       }
-      if (value instanceof Set) {
-        const object2 = openObject(metrics, childAllocate);
-        writeLiteralField(metrics, object2, "__rasputin_type", "Set");
-        beginField(metrics, object2, "values");
-        const items = openArray(metrics, childAllocate);
+      if (types.isSet(value)) {
+        add(metrics, NODE + 16);
+        const values = [];
         let counted2 = 0;
-        for (const item of value.values()) {
-          if (counted2 >= limits.maxArrayElements) break;
-          if (!items.first) addBytes(metrics, 1);
-          items.first = false;
-          const serializedItem = serializeInner(item, depth + 1, path, childAllocate, metrics);
-          items.items?.push(serializedItem);
+        const setSize = Object.getOwnPropertyDescriptor(Set.prototype, "size")?.get;
+        const size = setSize ? setSize.call(value) : 0;
+        for (const item of Set.prototype.values.call(value)) {
+          if (counted2 >= limits.maxArrayElements || metrics.oversize) break;
+          values.push(freezeInner(item, depth + 1, path, metrics));
           counted2++;
         }
-        assignField(object2, "values", items.items ?? []);
-        if (value.size > limits.maxArrayElements) {
-          writeLiteralField(metrics, object2, "__rasputin_truncated", true);
-          writeLiteralField(metrics, object2, "__reason", "max_array_elements");
-          writeLiteralField(metrics, object2, "__original_length", value.size);
-        }
-        return object2.target;
+        return atom("Set", {
+          values,
+          ...size > limits.maxArrayElements ? { truncated: true, reason: "max_array_elements", originalLength: size } : {}
+        });
       }
       if (Array.isArray(value)) {
-        const items = openArray(metrics, childAllocate);
+        add(metrics, 2);
+        const items = [];
         const maxItems = value.length > limits.maxArrayElements ? limits.maxArrayElements - 1 : value.length;
+        let redactNext = false;
         for (let index = 0; index < maxItems; index++) {
-          if (!items.first) addBytes(metrics, 1);
-          items.first = false;
-          items.items?.push(serializeInner(value[index], depth + 1, path, childAllocate, metrics));
+          if (metrics.oversize) break;
+          let descriptor;
+          try {
+            descriptor = Object.getOwnPropertyDescriptor(value, index);
+          } catch {
+            descriptor = void 0;
+          }
+          if (!descriptor) {
+            add(metrics, NODE + 16);
+            items.push(atom("hole"));
+            redactNext = false;
+            continue;
+          }
+          if (!("value" in descriptor)) {
+            add(metrics, NODE + 16);
+            items.push(atom("accessor"));
+            redactNext = false;
+            continue;
+          }
+          if (redactNext) {
+            add(metrics, stringEstimate(REDACTED));
+            items.push(REDACTED);
+            redactNext = false;
+          } else {
+            items.push(freezeInner(descriptor.value, depth + 1, path, metrics));
+            redactNext = typeof descriptor.value === "string" && keyIsRedacted(descriptor.value, redactKeys);
+          }
         }
         if (value.length > limits.maxArrayElements) {
-          if (!items.first) addBytes(metrics, 1);
-          items.first = false;
-          items.items?.push(
-            writeTruncation(metrics, childAllocate, "max_array_elements", {
-              __original_length: value.length
+          add(metrics, NODE + 32);
+          items.push(
+            atom("truncated", {
+              reason: "max_array_elements",
+              originalLength: value.length
             })
           );
         }
-        return items.items;
+        if (items[0] === RASPUTIN_WIRE_TAG) {
+          return atom("instance", { type: "Array", value: { items } });
+        }
+        return items;
+      }
+      if (types.isTypedArray(value)) {
+        const view = value;
+        const byteLength = viewByteLength(view);
+        const sampleLimit = Math.min(32, limits.maxStringLength);
+        let sample = [];
+        try {
+          const buffer = typedArrayBufferGet?.call(view);
+          const byteOffset = typedArrayByteOffsetGet?.call(view);
+          if (buffer) {
+            const bytes = new Uint8Array(
+              buffer,
+              byteOffset ?? 0,
+              Math.min(sampleLimit, byteLength)
+            );
+            sample = sampleBytes(bytes, sampleLimit);
+          }
+        } catch {
+          sample = [];
+        }
+        const typeName2 = typedArrayName(value);
+        add(metrics, NODE + stringEstimate(typeName2) + 48);
+        return atom("instance", {
+          type: typeName2,
+          value: {
+            byteLength,
+            ...sample.length > 0 ? { sample } : {},
+            ...byteLength > sampleLimit ? { truncated: true } : {}
+          }
+        });
+      }
+      if (types.isDataView(value)) {
+        const view = value;
+        const byteLength = viewByteLength(view);
+        add(metrics, NODE + 32);
+        return atom("instance", {
+          type: "DataView",
+          value: { byteLength }
+        });
+      }
+      if (types.isArrayBuffer(value) || types.isSharedArrayBuffer(value)) {
+        const buffer = value;
+        let byteLength = 0;
+        try {
+          byteLength = buffer.byteLength;
+        } catch {
+          byteLength = 0;
+        }
+        add(metrics, NODE + 32);
+        return atom("instance", {
+          type: types.isSharedArrayBuffer(value) ? "SharedArrayBuffer" : "ArrayBuffer",
+          value: { byteLength }
+        });
+      }
+      if (types.isStringObject(value) || types.isNumberObject(value) || types.isBooleanObject(value)) {
+        try {
+          if (types.isStringObject(value)) {
+            return freezeInner(String.prototype.valueOf.call(value), depth, path, metrics);
+          }
+          if (types.isNumberObject(value)) {
+            return freezeInner(Number.prototype.valueOf.call(value), depth, path, metrics);
+          }
+          return freezeInner(Boolean.prototype.valueOf.call(value), depth, path, metrics);
+        } catch {
+          return atom("unserializable");
+        }
+      }
+      add(metrics, 2);
+      const fields = /* @__PURE__ */ Object.create(null);
+      let typeName;
+      let prototype = null;
+      try {
+        prototype = Object.getPrototypeOf(value);
+      } catch {
+        prototype = null;
+      }
+      if (prototype && types.isProxy(prototype)) {
+        add(metrics, NODE + 16);
+        return atom("instance", { type: "Proxy", value: fields });
       }
-      const object = openObject(metrics, childAllocate);
-      const prototype = Object.getPrototypeOf(value);
       if (prototype && prototype !== Object.prototype) {
-        writeLiteralField(
-          metrics,
-          object,
-          "__rasputin_type",
-          prototype.constructor?.name ?? "instance"
-        );
+        typeName = "instance";
+        if (!types.isProxy(prototype)) {
+          const ctor = ownData(prototype, "constructor")?.value;
+          if (typeof ctor === "function") {
+            const name = functionNameOf(ctor);
+            if (name && name !== "anonymous") typeName = name;
+          }
+        }
+        add(metrics, NODE + stringEstimate(typeName));
       }
-      const keys = Object.keys(value);
-      const maxKeys = keys.length > limits.maxObjectKeys ? limits.maxObjectKeys - 1 : keys.length;
+      const pairLabel = ownData(value, "name") ?? ownData(value, "key");
+      const pairIsSensitive = pairLabel !== void 0 && typeof pairLabel.value === "string" && keyIsRedacted(pairLabel.value, redactKeys);
+      const { keys, truncated } = ownEnumerableKeys(value, limits.maxObjectKeys);
+      const maxKeys = truncated ? Math.max(0, limits.maxObjectKeys - 1) : keys.length;
       for (let index = 0; index < maxKeys; index++) {
         const key = keys[index];
-        if (key === void 0) continue;
-        if (isRedactedKey(key)) {
-          writeLiteralField(metrics, object, key, REDACTED);
+        if (key === void 0 || metrics.oversize) continue;
+        add(metrics, stringEstimate(key));
+        if (keyIsRedacted(key, redactKeys) || key === "value" && pairIsSensitive) {
+          add(metrics, stringEstimate(REDACTED));
+          assignFrozenField(fields, key, REDACTED);
           continue;
         }
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (descriptor && "value" in descriptor) {
-          beginField(metrics, object, key);
-          assignField(
-            object,
-            key,
-            serializeInner(descriptor.value, depth + 1, path, childAllocate, metrics)
-          );
+        const slot = ownData(value, key);
+        if (slot) {
+          const field = typeof slot.value === "string" && propertyNameLooksLikeUrl(key) ? redactUrlLikeString(slot.value, redactKeys) : slot.value;
+          assignFrozenField(fields, key, freezeInner(field, depth + 1, path, metrics));
         } else {
-          beginField(metrics, object, key);
-          assignField(object, key, writeTypeMarker(metrics, childAllocate, "accessor"));
+          add(metrics, NODE + 16);
+          assignFrozenField(fields, key, atom("accessor"));
         }
       }
-      if (keys.length > limits.maxObjectKeys) {
-        writeLiteralField(metrics, object, "__rasputin_truncated", true);
-        writeLiteralField(metrics, object, "__reason", "max_object_keys");
-        writeLiteralField(metrics, object, "__original_length", keys.length);
+      if (truncated) {
+        return atom("instance", {
+          type: typeName,
+          value: fields,
+          truncated: true,
+          reason: "max_object_keys"
+        });
       }
-      return object.target;
+      if (typeName) return atom("instance", { type: typeName, value: fields });
+      return fields;
     } catch (error) {
-      metrics.bytes = bytesBefore;
-      metrics.oversize = oversizeBefore;
-      return writeTypeMarker(
-        metrics,
-        allocate && !metrics.oversize,
-        "unserializable",
-        error instanceof Error ? error.message : void 0
-      );
+      add(metrics, NODE + 32);
+      return atom("unserializable", {
+        value: error instanceof Error ? error.message : void 0
+      });
     } finally {
       path.delete(value);
     }
   };
-  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, bytes: 0, oversize: false };
-    const reentrant = serializing;
+  const freeze = (value) => {
+    const metrics = { visitedNodes: 0, estimatedBytes: 0, oversize: false };
+    const reentrant = freezing;
     const path = reentrant ? /* @__PURE__ */ new Set() : sharedPath;
     if (!reentrant) {
-      serializing = true;
+      freezing = true;
       sharedPath.clear();
     }
     try {
-      const serialized = serializeInner(value, 0, path, true, metrics);
-      if (metrics.bytes > limits.maxSerializedValueBytes) {
-        return boundedOversize(metrics.bytes, metrics.visitedNodes);
+      const frozen = freezeInner(value, 0, path, metrics);
+      if (metrics.oversize) {
+        return {
+          value: atom("truncated", {
+            reason: "max_serialized_value_bytes",
+            serializedBytes: metrics.estimatedBytes
+          }),
+          estimatedBytes: metrics.estimatedBytes,
+          visitedNodes: metrics.visitedNodes,
+          oversize: true
+        };
       }
-      return { value: serialized, bytes: metrics.bytes, visitedNodes: metrics.visitedNodes };
+      return {
+        value: frozen,
+        estimatedBytes: metrics.estimatedBytes,
+        visitedNodes: metrics.visitedNodes,
+        oversize: false
+      };
     } catch {
-      const failed = typeMarker("unserializable");
       return {
-        value: failed,
-        bytes: jsonLiteralUtf8Bytes(failed),
-        visitedNodes: metrics.visitedNodes
+        value: atom("unserializable"),
+        estimatedBytes: NODE + 16,
+        visitedNodes: Math.max(1, metrics.visitedNodes),
+        oversize: false
       };
     } finally {
       path.clear();
-      if (!reentrant) serializing = false;
+      if (!reentrant) freezing = false;
+    }
+  };
+  return { freeze, limits };
+};
+
+// src/execution-recorder/encode-frozen.ts
+var typeMarker = (type, value) => ({
+  __rasputin_type: type,
+  ...value === void 0 ? {} : { value }
+});
+var truncation = (reason, extra = {}) => ({
+  __rasputin_truncated: true,
+  __reason: reason,
+  ...extra
+});
+var taggedNumber = (value) => {
+  if (Number.isNaN(value)) return { __rasputin_type: "NaN" };
+  if (value === Infinity) return { __rasputin_type: "Infinity" };
+  if (value === -Infinity) return { __rasputin_type: "-Infinity" };
+  if (Object.is(value, -0)) return { __rasputin_type: "-0" };
+  return void 0;
+};
+var jsonStringUtf8Bytes = (value) => {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code === 34 || code === 92) {
+      bytes += 2;
+      continue;
+    }
+    if (code === 8 || code === 9 || code === 10 || code === 12 || code === 13) {
+      bytes += 2;
+      continue;
+    }
+    if (code < 32) {
+      bytes += 6;
+      continue;
+    }
+    if (code < 128) {
+      bytes += 1;
+      continue;
+    }
+    if (code < 2048) {
+      bytes += 2;
+      continue;
+    }
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (index + 1 < value.length && next >= 56320 && next <= 57343) {
+        bytes += 4;
+        index++;
+        continue;
+      }
+      bytes += 6;
+      continue;
+    }
+    if (code >= 56320 && code <= 57343) {
+      bytes += 6;
+      continue;
+    }
+    bytes += 3;
+  }
+  return bytes;
+};
+var ownData2 = (value, key) => {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor && "value" in descriptor) return descriptor.value;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+var jsonLiteralUtf8Bytes = (value) => {
+  if (value === null) return 4;
+  switch (typeof value) {
+    case "boolean":
+      return value ? 4 : 5;
+    case "number": {
+      const tagged = taggedNumber(value);
+      if (tagged) return jsonLiteralUtf8Bytes(tagged);
+      return String(value).length;
+    }
+    case "string":
+      return jsonStringUtf8Bytes(value);
+    case "object": {
+      if (Array.isArray(value)) {
+        let bytes2 = 2;
+        for (let index = 0; index < value.length; index++) {
+          if (index > 0) bytes2 += 1;
+          bytes2 += jsonLiteralUtf8Bytes(ownData2(value, index));
+        }
+        return bytes2;
+      }
+      const record = value;
+      let bytes = 2;
+      let first = true;
+      for (const key of Object.keys(record)) {
+        if (!first) bytes += 1;
+        first = false;
+        bytes += jsonStringUtf8Bytes(key) + 1;
+        bytes += jsonLiteralUtf8Bytes(ownData2(record, key));
+      }
+      return bytes;
+    }
+    default:
+      return Buffer3.byteLength(JSON.stringify(value) ?? "null", "utf8");
+  }
+};
+var BUILTIN_INSTANCE_TYPES = /* @__PURE__ */ new Set([
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int8Array",
+  "Uint16Array",
+  "Int16Array",
+  "Uint32Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigUint64Array",
+  "BigInt64Array",
+  "TypedArray",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "Proxy"
+]);
+var RESERVED_WIRE_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "__rasputin_type",
+  "__rasputin_truncated",
+  "__rasputin_fields",
+  "__reason",
+  "__original_length",
+  "__serialized_bytes"
+]);
+var encodePlainObject = (value) => {
+  const record = value;
+  if (typeof record.__rasputin_type === "string") {
+    const encoded2 = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(record)) {
+      if (key === "__proto__") continue;
+      encoded2[key] = encodeFrozen(record[key]);
+    }
+    encoded2.__rasputin_type = record.__rasputin_type;
+    return encoded2;
+  }
+  const encoded = /* @__PURE__ */ Object.create(null);
+  const escaped = [];
+  for (const key of Object.keys(record)) {
+    const encodedValue = encodeFrozen(record[key]);
+    if (key === "__proto__" || RESERVED_WIRE_KEYS.has(key) || key.startsWith("__rasputin_")) {
+      if (key === "__rasputin_fields") {
+        encoded.__rasputin_fields = encodedValue;
+        continue;
+      }
+      escaped.push({ name: key, value: encodedValue });
+    } else {
+      encoded[key] = encodedValue;
+    }
+  }
+  if (escaped.length > 0) {
+    const existing = Array.isArray(encoded.__rasputin_fields) ? encoded.__rasputin_fields : [];
+    encoded.__rasputin_fields = [...existing, ...escaped];
+  }
+  return encoded;
+};
+var encodeAtom = (frozen) => {
+  const kind = frozen[FROZEN];
+  switch (kind) {
+    case "undefined":
+    case "NaN":
+    case "Infinity":
+    case "-Infinity":
+    case "-0":
+    case "Proxy":
+    case "circular":
+    case "Promise":
+    case "accessor":
+    case "hole":
+      return typeMarker(kind);
+    case "bigint":
+    case "symbol":
+    case "function":
+    case "Date":
+      return typeMarker(kind, encodeFrozen(frozen.value));
+    case "unserializable":
+      return frozen.value === void 0 ? typeMarker("unserializable") : typeMarker("unserializable", encodeFrozen(frozen.value));
+    case "Error": {
+      const encoded = {
+        __rasputin_type: "Error",
+        name: frozen.name,
+        message: encodeFrozen(frozen.message)
+      };
+      if (frozen.stack !== void 0) encoded.stack = encodeFrozen(frozen.stack);
+      if (frozen.code !== void 0) encoded.code = encodeFrozen(frozen.code);
+      if (frozen.cause !== void 0) encoded.cause = encodeFrozen(frozen.cause);
+      if (frozen.statusCode !== void 0) encoded.statusCode = encodeFrozen(frozen.statusCode);
+      return encoded;
+    }
+    case "Buffer":
+      return typeMarker("Buffer", {
+        byteLength: frozen.byteLength,
+        base64: frozen.base64,
+        ...frozen.truncated ? { __rasputin_truncated: true } : {}
+      });
+    case "Map": {
+      const encoded = {
+        __rasputin_type: "Map",
+        entries: encodeFrozen(frozen.entries)
+      };
+      if (frozen.truncated) {
+        encoded.__rasputin_truncated = true;
+        encoded.__reason = frozen.reason;
+        encoded.__original_length = frozen.originalLength;
+      }
+      return encoded;
+    }
+    case "Set": {
+      const encoded = {
+        __rasputin_type: "Set",
+        values: encodeFrozen(frozen.values)
+      };
+      if (frozen.truncated) {
+        encoded.__rasputin_truncated = true;
+        encoded.__reason = frozen.reason;
+        encoded.__original_length = frozen.originalLength;
+      }
+      return encoded;
+    }
+    case "truncated":
+      return truncation(frozen.reason ?? "max_depth", {
+        ...frozen.originalLength === void 0 ? {} : { __original_length: frozen.originalLength },
+        ...frozen.serializedBytes === void 0 ? {} : { __serialized_bytes: frozen.serializedBytes },
+        ...frozen.value === void 0 ? {} : { value: encodeFrozen(frozen.value) }
+      });
+    case "instance": {
+      const fields = typeof frozen.value === "object" && frozen.value !== null && !Array.isArray(frozen.value) ? encodePlainObject(frozen.value) : encodeFrozen(frozen.value);
+      const encoded = /* @__PURE__ */ Object.create(null);
+      if (typeof fields === "object" && fields !== null && !Array.isArray(fields)) {
+        for (const key of Object.keys(fields)) {
+          encoded[key] = fields[key];
+        }
+      }
+      if (frozen.type && BUILTIN_INSTANCE_TYPES.has(frozen.type)) {
+        encoded.__rasputin_type = frozen.type;
+      } else if (frozen.type) {
+        encoded.__rasputin_type = "instance";
+        encoded.__rasputin_class = frozen.type;
+      } else if (!frozen.truncated) {
+        encoded.__rasputin_type = "instance";
+      }
+      if (frozen.truncated) {
+        encoded.__rasputin_truncated = true;
+        encoded.__reason = frozen.reason;
+        if (frozen.originalLength !== void 0) encoded.__original_length = frozen.originalLength;
+      }
+      return encoded;
+    }
+    default:
+      return typeMarker("unserializable");
+  }
+};
+var encodeFrozen = (value) => {
+  if (value === REDACTED) return REDACTED;
+  if (isFrozenAtom(value)) return encodeAtom(value);
+  if (Array.isArray(value)) {
+    const items = new Array(value.length);
+    for (let index = 0; index < value.length; index++) {
+      items[index] = encodeFrozen(value[index]);
     }
+    return items;
+  }
+  if (typeof value === "object" && value !== null) {
+    return encodePlainObject(value);
+  }
+  return value;
+};
+var encodeFrozenWithBytes = (frozen, visitedNodes, maxSerializedValueBytes) => {
+  const encoded = encodeFrozen(frozen);
+  if (typeof encoded === "object" && encoded !== null && !Array.isArray(encoded) && encoded.__reason === "max_serialized_value_bytes") {
+    const bytes2 = jsonLiteralUtf8Bytes(encoded);
+    return { value: encoded, bytes: bytes2, visitedNodes };
+  }
+  const bytes = jsonLiteralUtf8Bytes(encoded);
+  if (bytes > maxSerializedValueBytes) {
+    const bounded = truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
+    return { value: bounded, bytes: jsonLiteralUtf8Bytes(bounded), visitedNodes };
+  }
+  return { value: encoded, bytes, visitedNodes };
+};
+
+// src/execution-recorder/safe-serialize.ts
+var createSafeSerializer = (options = {}) => {
+  const freezer = createValueFreezer(options);
+  const serializeWithBytes = (value) => {
+    const frozen = freezer.freeze(value);
+    return encodeFrozenWithBytes(
+      frozen.value,
+      frozen.visitedNodes,
+      freezer.limits.maxSerializedValueBytes
+    );
   };
   return {
+    freeze: freezer.freeze,
+    encode: encodeFrozen,
     serialize: (value) => serializeWithBytes(value).value,
     serializeWithBytes
   };
@@ -1421,9 +2384,40 @@ var createSourceExclusionMatcher = (exclusions) => {
   return matchers.length === 0 ? () => false : (definition) => matchers.some((matcher) => matcher(definition));
 };
 
+// src/execution-recorder/warn-missing-async-context-frame.ts
+var ASYNC_CONTEXT_FRAME_FLAG = "--experimental-async-context-frame";
+var ASYNC_CONTEXT_FRAME_WARNING_SUPPRESS_ENV = "RASPUTIN_SUPPRESS_ASYNC_CONTEXT_FRAME_WARNING";
+var warnedSymbol = Symbol.for("rasputin.asyncContextFrameWarning");
+var hasFlag = (execArgv, nodeOptions) => {
+  if (execArgv.includes(ASYNC_CONTEXT_FRAME_FLAG)) return true;
+  if (!nodeOptions) return false;
+  return nodeOptions.split(/\s+/).includes(ASYNC_CONTEXT_FRAME_FLAG);
+};
+var missingAsyncContextFrameWarning = (runtime) => {
+  if (runtime.bun || !runtime.node) return void 0;
+  const major = Number(runtime.node.split(".")[0]);
+  if (!Number.isInteger(major) || major >= 24) return void 0;
+  if (hasFlag(runtime.execArgv, runtime.nodeOptions)) return void 0;
+  return `[rasputin] Node.js ${major} is running without ${ASYNC_CONTEXT_FRAME_FLAG}. AsyncLocalStorage is faster with that flag, which is the default on Node.js 24+. Start Node with ${ASYNC_CONTEXT_FRAME_FLAG}, or use Node.js 24 or newer. Set ${ASYNC_CONTEXT_FRAME_WARNING_SUPPRESS_ENV}=1 to hide this warning.`;
+};
+var warnIfMissingAsyncContextFrame = () => {
+  if (process.env[ASYNC_CONTEXT_FRAME_WARNING_SUPPRESS_ENV] === "1") return;
+  if (Reflect.get(globalThis, warnedSymbol)) return;
+  const message = missingAsyncContextFrameWarning({
+    bun: process.versions.bun,
+    node: process.versions.node,
+    execArgv: process.execArgv,
+    nodeOptions: process.env.NODE_OPTIONS
+  });
+  if (!message) return;
+  Reflect.set(globalThis, warnedSymbol, true);
+  console.warn(message);
+};
+
 // src/execution-recorder/execution-recorder.ts
 var DEFAULT_MAX_ACTIVE_MEMORY_BYTES = 64 * 1024 * 1024;
-var DERIVATION_ROOT_RECORD_BYTES = 64;
+var DEFAULT_MAX_EXECUTION_HOLD_MS = 6e4;
+var DEFAULT_MAX_RETAINED_ERROR_RECORDINGS = 32;
 var phaseTimingEnabled = process.env.RASPUTIN_RECORDER_PHASE_TIMING === "1";
 var manualFunctionDefinition = (value) => {
   const located = /^(.+):([^:@]+)@(\d+):(\d+)$/.exec(value);
@@ -1442,72 +2436,39 @@ var normalizeFunctionDefinition = (value) => typeof value === "string" ? manualF
 var elapsedMs2 = (startedAtNs, endedAtNs = process.hrtime.bigint()) => Number(endedAtNs - startedAtNs) / 1e6;
 var roundedMilliseconds2 = (nanoseconds) => Math.round(Number(nanoseconds) / 1e6 * 1e4) / 1e4;
 var addRecorderTime = (recording, nanoseconds) => {
-  if (nanoseconds > 0n) recording.inlineRecorderTimeNs += nanoseconds;
+  if (process.env.RASPUTIN_RECORDER_PHASE_TIMING !== "1" || nanoseconds <= 0n) return;
+  recording.inlineRecorderTimeNs += nanoseconds;
+};
+var mapArrayLike = (args, map) => {
+  const mapped = new Array(args.length);
+  for (let index = 0; index < args.length; index++) {
+    mapped[index] = map(args[index], index);
+  }
+  return mapped;
 };
-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) => {
+var observeRecordedCallback = function __rasputinHandleRun__2(recording, recorderStartedAtNs, callback, onReturn, onThrow) {
+  const callbackStartedAtNs = phaseTimingEnabled ? process.hrtime.bigint() : recorderStartedAtNs;
+  const recordExitWork = (callbackEndedAtNs) => {
+    if (!phaseTimingEnabled) return;
     addRecorderTime(recording, callbackStartedAtNs - recorderStartedAtNs);
-    addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs2);
+    addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs);
   };
   let result;
   try {
     result = callback();
   } catch (error) {
-    const callbackEndedAtNs2 = process.hrtime.bigint();
     notifyObserver(onThrow, error);
-    recordExitWork(callbackEndedAtNs2);
+    recordExitWork(phaseTimingEnabled ? process.hrtime.bigint() : recorderStartedAtNs);
     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);
+  recordExitWork(phaseTimingEnabled ? process.hrtime.bigint() : recorderStartedAtNs);
   return result;
 };
 var emptyStats = {
@@ -1537,32 +2498,34 @@ var emptyStats = {
   journalPoolMisses: 0,
   journalPoolSize: 0,
   journalAllocatedCapacity: 0,
-  derivationCandidateFunctions: 0,
-  derivationElidedFunctionCalls: 0,
-  derivationRootsCaptured: 0,
-  derivationControlFactsCaptured: 0,
-  derivationValuesAvoided: 0,
-  derivationFallbackFunctions: 0,
-  derivationFallbackExpressions: 0,
-  derivationFallbackReasons: {},
-  derivationRootBytes: 0
+  attributionDegradations: 0
 };
 var noOpExecution = {
   createScope: () => ({
     run: (callback) => callback(),
     getErrorState: () => void 0,
+    associateError: () => {
+    },
     finish: () => {
     }
   }),
-  run: (_metadata, callback) => callback(),
   getErrorState: () => void 0,
   runFunction: (_functionId, _args, callback) => callback(),
   runFunctionPlans: (_plans, _planIndex, _args, callback) => callback(),
   prepareFunctionPlans: () => [],
   runPreparedFunction: (_plan, _args, callback) => callback(),
+  enterPreparedFunction: () => ({
+    leave: (value) => value,
+    fail: () => {
+    },
+    end: () => {
+    },
+    run: (callback) => callback(),
+    suspend: (value) => value,
+    resume: (value) => value
+  }),
   trace: (_functionId, fn) => fn,
-  getStats: () => ({ ...emptyStats, derivationFallbackReasons: {} }),
-  captureDerivationRoot: (_rootId, value) => value
+  getStats: () => ({ ...emptyStats })
 };
 var mergeExecutionMetadata = (target, metadata) => {
   if (metadata.kind) target.kind = metadata.kind;
@@ -1587,7 +2550,41 @@ var newSuppression = (group, parentCallId, startedAtNs, endedAtNs) => ({
 });
 var createExecutionRecorder = (options) => {
   if (!options?.enabled) return noOpExecution;
+  warnIfMissingAsyncContextFrame();
   const storage = new AsyncLocalStorage();
+  const currentStore = () => {
+    try {
+      return storage.getStore();
+    } catch {
+      return void 0;
+    }
+  };
+  const degradeAttribution = (recording, plan) => {
+    if (!recording.attributionDegraded) {
+      recording.attributionDegraded = true;
+      stats.attributionDegradations++;
+      const eventsDropped = Math.max(
+        1,
+        recording.journal?.dropped ?? recording.memory.eventsDropped
+      );
+      recording.cachedState = {
+        events: [],
+        functions: [],
+        truncated: { eventsDropped },
+        capture: {
+          completeness: "unavailable",
+          reason: "attribution_invariant",
+          valuesDropped: recording.memory.valuesDropped,
+          eventsDropped
+        }
+      };
+    }
+    if (plan) plan.disabled = true;
+  };
+  const noteDisabledPlan = (recording) => {
+    if (recording.finished || recording.evicted || recording.attributionDegraded) return;
+    recording.disabledPlanEncountered = true;
+  };
   const maxEventsPerExecution = sanitizeJournalCapacity(options.maxEventsPerExecution);
   const maxCapturedCallsPerFunction = Math.max(
     1,
@@ -1597,6 +2594,14 @@ var createExecutionRecorder = (options) => {
     0,
     Math.floor(options.maxActiveMemoryBytes ?? DEFAULT_MAX_ACTIVE_MEMORY_BYTES)
   );
+  const maxExecutionHoldNs = BigInt(Math.max(1, Math.floor(options.maxExecutionHoldMs ?? DEFAULT_MAX_EXECUTION_HOLD_MS))) * 1000000n;
+  const maxRetainedErrorRecordings = Math.max(
+    1,
+    Math.floor(options.maxRetainedErrorRecordings ?? DEFAULT_MAX_RETAINED_ERROR_RECORDINGS)
+  );
+  const liveRecordings = [];
+  let lastSweepNs = 0n;
+  const sweepIntervalNs = maxExecutionHoldNs / 4n < 50000000n ? maxExecutionHoldNs / 4n : 50000000n;
   const memoryBudget = new RecorderMemoryBudget(
     maxActiveMemoryBytes,
     options.maxSerializedValueBytes ?? 8 * 1024
@@ -1604,12 +2609,17 @@ var createExecutionRecorder = (options) => {
   const serializer = createSafeSerializer(options);
   const excludesSource = createSourceExclusionMatcher(options.excludeSources);
   const journalPool = new ExecutionJournalPool(maxEventsPerExecution);
+  const runtimeStateSizeBudget = {
+    targetBytes: options.runtimeStateTargetBytes,
+    maximumBytes: options.maxRuntimeStateBytes
+  };
   const plansByRuntimeId = [];
   let executionCounter = 0;
   let nextRuntimePlanId = 1;
   const internedPlans = /* @__PURE__ */ new Map();
   const preparedModules = /* @__PURE__ */ new WeakMap();
   const errorExecutions = /* @__PURE__ */ new WeakMap();
+  const retainedErrorRecordings = [];
   const phases = phaseTimingEnabled ? { alsNs: 0n, materializeNs: 0n } : void 0;
   const stats = {
     functionCallsObserved: 0,
@@ -1628,15 +2638,7 @@ var createExecutionRecorder = (options) => {
     measuredExecutions: 0,
     totalInlineWallTimeMs: 0,
     maxInlineWallTimeMs: 0,
-    derivationCandidateFunctions: 0,
-    derivationElidedFunctionCalls: 0,
-    derivationRootsCaptured: 0,
-    derivationControlFactsCaptured: 0,
-    derivationValuesAvoided: 0,
-    derivationFallbackFunctions: 0,
-    derivationFallbackExpressions: 0,
-    derivationFallbackReasons: {},
-    derivationRootBytes: 0
+    attributionDegradations: 0
   };
   const addPhase = (key, nanoseconds) => {
     if (phases && nanoseconds > 0n) phases[key] += nanoseconds;
@@ -1647,14 +2649,36 @@ var createExecutionRecorder = (options) => {
     stats.totalInlineWallTimeMs = Math.round((stats.totalInlineWallTimeMs + inlineWallTimeMs) * 1e4) / 1e4;
     stats.maxInlineWallTimeMs = Math.max(stats.maxInlineWallTimeMs, inlineWallTimeMs);
   };
-  const serializeAndCount = (value) => {
-    const serialized = serializer.serializeWithBytes(value);
+  const freezeAndCount = (value) => {
+    const frozen = serializer.freeze(value);
     stats.serializedValues++;
-    stats.serializedValueNodes += serialized.visitedNodes;
-    stats.serializedValueBytes += serialized.bytes;
-    return serialized;
+    stats.serializedValueNodes += frozen.visitedNodes;
+    stats.serializedValueBytes += frozen.estimatedBytes;
+    return {
+      value: frozen.value,
+      bytes: frozen.estimatedBytes,
+      visitedNodes: frozen.visitedNodes
+    };
+  };
+  const captureValue = (recording, value) => {
+    try {
+      return memoryBudget.captureValue(recording.memory, () => freezeAndCount(value));
+    } catch {
+      return { __rasputin_type: "unserializable" };
+    }
   };
-  const captureValue = (recording, value) => memoryBudget.captureValue(recording.memory, () => serializeAndCount(value));
+  const encodeEventValues = (events) => events.map((event) => {
+    if (event.type === "function_enter") {
+      return { ...event, args: event.args.map((argument) => serializer.encode(argument)) };
+    }
+    if (event.type === "function_exit") {
+      return { ...event, returnValue: serializer.encode(event.returnValue) };
+    }
+    if (event.type === "function_throw") {
+      return { ...event, error: serializer.encode(event.error) };
+    }
+    return event;
+  });
   const storePlan = (plan) => {
     plansByRuntimeId[plan.runtimePlanId] = plan;
     return plan;
@@ -1667,7 +2691,8 @@ var createExecutionRecorder = (options) => {
       definition,
       functionId: definition.functionId,
       excluded: excludesSource(definition),
-      estimatedCallBytes: estimatedCallBytesFor(definition.functionId)
+      estimatedCallBytes: estimatedCallBytesFor(definition.functionId),
+      omitCallValues: false
     });
     internedPlans.set(definition.functionId, plan);
     return plan;
@@ -1682,89 +2707,124 @@ var createExecutionRecorder = (options) => {
         definition,
         functionId: definition.functionId,
         excluded: excludesSource(definition),
-        estimatedCallBytes: estimatedCallBytesFor(definition.functionId)
+        estimatedCallBytes: estimatedCallBytesFor(definition.functionId),
+        omitCallValues: encodedPlanOmitsCallValues(encoded)
       });
     });
     preparedModules.set(plans, prepared);
     return prepared;
   };
-  const derivationMetrics = (recording) => {
-    const manifest = snapshotInstrumentationManifest();
-    const plans = manifest?.derivationPlans ?? [];
-    const reasons = { ...stats.derivationFallbackReasons };
-    return {
-      derivationCandidateFunctions: plans.filter((plan) => !plan.fallbackReason).length,
-      derivationElidedFunctionCalls: stats.derivationElidedFunctionCalls,
-      derivationRootsCaptured: recording.derivationRoots.length,
-      derivationControlFactsCaptured: stats.derivationControlFactsCaptured,
-      derivationValuesAvoided: stats.derivationValuesAvoided,
-      derivationFallbackFunctions: plans.filter((plan) => plan.fallbackReason).length,
-      derivationFallbackExpressions: recording.derivationRoots.length,
-      derivationFallbackReasons: reasons,
-      derivationRootBytes: recording.derivationRootBytes
-    };
-  };
-  const resolveCaptureMode = (recording) => {
-    if (recording.derivationRoots.length > 0) return "derivation";
-    const plans = snapshotInstrumentationManifest()?.derivationPlans ?? [];
-    if (recording.sawAutomatic && plans.some(
-      (plan) => !plan.fallbackReason && recording.executedFunctionIds.has(plan.functionId)
-    )) {
-      return "derivation";
+  const eventsHaveOmittedValues = (events) => {
+    for (const event of events) {
+      if (event.type === "function_enter" && event.args.some((arg) => rasputinTagKind(arg) === "omitted")) {
+        return true;
+      }
+      if (event.type === "function_exit" && rasputinTagKind(event.returnValue) === "omitted") {
+        return true;
+      }
     }
-    if (recording.sawAutomatic) return "automatic-full";
-    if (recording.sawManual) return "manual";
-    return "scope-only";
-  };
-  const derivationCapture = (recording) => {
-    const manifest = snapshotInstrumentationManifest();
-    if (!manifest) return void 0;
-    return {
-      manifestHash: hashInstrumentationManifest(manifest),
-      roots: recording.derivationRoots.slice(),
-      controlFacts: []
-    };
+    return false;
   };
-  const stateFrom = (recording, endedAtNs = process.hrtime.bigint()) => {
-    const recorderStartedAtNs = process.hrtime.bigint();
+  const resolveCaptureProfile = (recording, events, truncated, capture) => {
+    const source = recording.sawAutomatic ? "automatic" : recording.sawManual ? "manual" : "scope-only";
+    if (source === "scope-only") {
+      return {
+        source,
+        functionBoundaries: "none",
+        functionValues: "none",
+        timings: "none"
+      };
+    }
+    if (recording.evicted || capture?.completeness === "unavailable") {
+      return {
+        source,
+        functionBoundaries: "none",
+        functionValues: "none",
+        timings: "none"
+      };
+    }
+    if (recording.budgetExpired || capture?.reason === "long_lived_execution_budget") {
+      return {
+        source,
+        functionBoundaries: events.length > 0 ? "partial" : "none",
+        functionValues: events.length > 0 ? "selective" : "none",
+        timings: events.length > 0 ? "partial" : "none"
+      };
+    }
+    if (capture?.reason === "plan_disabled_after_attribution_invariant") {
+      return {
+        source,
+        functionBoundaries: events.length > 0 ? "partial" : "none",
+        functionValues: eventsHaveOmittedValues(events) ? "selective" : events.length > 0 ? "full" : "none",
+        timings: events.length > 0 ? "partial" : "none"
+      };
+    }
+    const droppedEvents = Boolean(truncated?.eventsDropped || capture?.eventsDropped);
+    return {
+      source,
+      functionBoundaries: droppedEvents ? "partial" : "full",
+      functionValues: eventsHaveOmittedValues(events) ? "selective" : "full",
+      timings: droppedEvents ? "partial" : "full"
+    };
+  };
+  const stateFrom = (recording, endedAtNs = process.hrtime.bigint()) => {
+    const recorderStartedAtNs = process.hrtime.bigint();
     let events = [];
     let functions = [];
     let truncated;
     let capture;
-    let derivation;
     if (recording.cachedState) {
       events = recording.cachedState.events;
       functions = recording.cachedState.functions;
       truncated = recording.cachedState.truncated;
       capture = recording.cachedState.capture;
-      derivation = recording.cachedState.derivation;
     } else {
       if (recording.journal) {
         const materialized = recording.journal.materialize(plansByRuntimeId, recording.startedAtNs);
-        events = materialized.events;
+        events = encodeEventValues(materialized.events);
+        if (recording.lateCapturedCallIds && recording.lateCapturedCallIds.size > 0) {
+          events = events.map(
+            (event) => event.type === "function_enter" && recording.lateCapturedCallIds?.has(event.callId) ? { ...event, capturedAt: "throw" } : event
+          );
+        }
         functions = materialized.functions;
         truncated = recording.journal.dropped > 0 ? { eventsDropped: recording.journal.dropped } : void 0;
       }
-      capture = recording.memory.underPressure ? {
-        completeness: "partial",
-        reason: "process_memory_budget",
-        valuesDropped: recording.memory.valuesDropped,
-        eventsDropped: recording.memory.eventsDropped
-      } : void 0;
-      derivation = derivationCapture(recording);
+      if (recording.budgetExpired) {
+        capture = {
+          completeness: "partial",
+          reason: "long_lived_execution_budget",
+          valuesDropped: recording.memory.valuesDropped,
+          eventsDropped: recording.memory.eventsDropped
+        };
+      } else if (recording.disabledPlanEncountered) {
+        capture = {
+          completeness: "partial",
+          reason: "plan_disabled_after_attribution_invariant",
+          valuesDropped: recording.memory.valuesDropped,
+          eventsDropped: recording.memory.eventsDropped
+        };
+      } else if (recording.memory.underPressure) {
+        capture = {
+          completeness: "partial",
+          reason: "process_memory_budget",
+          valuesDropped: recording.memory.valuesDropped,
+          eventsDropped: recording.memory.eventsDropped
+        };
+      }
       if (recording.finished && recording.inFlightCalls === 0 && recording.journal) {
-        recording.cachedState = { events, functions, truncated, capture, derivation };
+        recording.cachedState = { events, functions, truncated, capture };
         journalPool.release(recording.journal);
         recording.journal = void 0;
       }
     }
     const state = {
-      version: 3,
-      captureMode: resolveCaptureMode(recording),
+      version: 4,
+      captureProfile: resolveCaptureProfile(recording, events, truncated, capture),
       executionId: recording.executionId,
       startedAt: recording.startedAt,
       durationMs: elapsedMs2(recording.startedAtNs, endedAtNs),
-      recorder: { inlineWallTimeMs: 0, derivation: derivationMetrics(recording) },
+      recorder: { inlineWallTimeMs: 0 },
       execution: {
         ...recording.execution,
         ...recording.execution.request ? { request: { ...recording.execution.request } } : {}
@@ -1772,29 +2832,153 @@ var createExecutionRecorder = (options) => {
       functions: functions.slice(),
       events: events.slice(),
       ...truncated ? { truncated: { ...truncated } } : {},
-      ...capture ? { capture: { ...capture } } : {},
-      ...derivation ? { derivation: { ...derivation, roots: derivation.roots.slice() } } : {}
+      ...capture ? { capture: { ...capture } } : {}
     };
     if (phaseTimingEnabled)
       addPhase("materializeNs", process.hrtime.bigint() - recorderStartedAtNs);
-    addRecorderTime(recording, process.hrtime.bigint() - recorderStartedAtNs);
+    const sizeBudgetStartedAtNs = process.hrtime.bigint();
+    addRecorderTime(recording, sizeBudgetStartedAtNs - recorderStartedAtNs);
     state.recorder = {
-      inlineWallTimeMs: roundedMilliseconds2(recording.inlineRecorderTimeNs),
-      derivation: derivationMetrics(recording)
+      inlineWallTimeMs: roundedMilliseconds2(recording.inlineRecorderTimeNs)
+    };
+    const boundedState = enforceRuntimeStateSizeBudget(state, runtimeStateSizeBudget);
+    addRecorderTime(recording, process.hrtime.bigint() - sizeBudgetStartedAtNs);
+    boundedState.recorder = {
+      inlineWallTimeMs: roundedMilliseconds2(recording.inlineRecorderTimeNs)
     };
-    return state;
+    return boundedState.truncated?.size ? enforceRuntimeStateSizeBudget(boundedState, runtimeStateSizeBudget) : boundedState;
+  };
+  const evictRetainedRecording = (recording) => {
+    const eventCount = recording.cachedState?.events.length ?? recording.journal?.eventCount ?? 0;
+    const dropped = (recording.cachedState?.truncated?.eventsDropped ?? recording.journal?.dropped ?? 0) + eventCount;
+    try {
+      memoryBudget.release(recording.memory);
+    } catch {
+    }
+    if (recording.journal) {
+      journalPool.release(recording.journal);
+      recording.journal = void 0;
+    }
+    recording.evicted = true;
+    detachLiveRecording(recording);
+    recording.cachedState = {
+      events: [],
+      functions: [],
+      truncated: { eventsDropped: Math.max(1, dropped) },
+      capture: {
+        completeness: "unavailable",
+        reason: "retained_state_evicted",
+        valuesDropped: 0,
+        eventsDropped: Math.max(1, dropped)
+      }
+    };
+  };
+  const trimFinishedRetainedRecordings = (keep) => {
+    while (retainedErrorRecordings.length > maxRetainedErrorRecordings) {
+      const evictIndex = retainedErrorRecordings.findIndex(
+        (candidate) => candidate !== keep && candidate.finished
+      );
+      if (evictIndex < 0) break;
+      const [evicted] = retainedErrorRecordings.splice(evictIndex, 1);
+      if (evicted) evictRetainedRecording(evicted);
+    }
+  };
+  const retainErrorRecording = (recording) => {
+    if (recording.retainedForError) return;
+    recording.retainedForError = true;
+    retainedErrorRecordings.push(recording);
+    trimFinishedRetainedRecordings(recording);
+  };
+  const detachLiveRecording = (recording) => {
+    const index = liveRecordings.indexOf(recording);
+    if (index >= 0) liveRecordings.splice(index, 1);
+  };
+  const expireLongLivedRecording = (recording, nowNs) => {
+    if (recording.evicted || recording.budgetExpired) return;
+    recording.budgetExpired = true;
+    recording.memory.underPressure = true;
+    const journalEvents = recording.journal?.eventCount ?? 0;
+    const cachedEvents = recording.cachedState?.events.length ?? 0;
+    const eventsDropped = Math.max(
+      1,
+      recording.memory.eventsDropped + journalEvents + cachedEvents
+    );
+    try {
+      memoryBudget.release(recording.memory);
+    } catch {
+    }
+    if (recording.journal) {
+      journalPool.release(recording.journal);
+      recording.journal = void 0;
+    }
+    recording.cachedState = {
+      events: [],
+      functions: [],
+      truncated: { eventsDropped },
+      capture: {
+        completeness: "partial",
+        reason: "long_lived_execution_budget",
+        valuesDropped: recording.memory.valuesDropped,
+        eventsDropped
+      }
+    };
+    if (!recording.finished) {
+      recording.finished = true;
+      stats.activeExecutions = Math.max(0, stats.activeExecutions - 1);
+      recording.finishedAtNs = nowNs;
+      if (!recording.hasError) {
+        stats.successfulExecutionsDiscarded++;
+      }
+    }
+    detachLiveRecording(recording);
+  };
+  const sweepLongLivedExecutions = (nowNs) => {
+    if (nowNs - lastSweepNs < sweepIntervalNs && liveRecordings.length < 256) return;
+    lastSweepNs = nowNs;
+    for (let index = liveRecordings.length - 1; index >= 0; index--) {
+      const recording = liveRecordings[index];
+      if (!recording) continue;
+      if (recording.evicted || recording.memory.released || recording.budgetExpired) {
+        liveRecordings.splice(index, 1);
+        continue;
+      }
+      if (nowNs - recording.startedAtNs < maxExecutionHoldNs) continue;
+      try {
+        expireLongLivedRecording(recording, nowNs);
+      } catch {
+      }
+    }
   };
   const rememberError = (error, recording) => {
     recording.hasError = true;
-    if (typeof error !== "object" && typeof error !== "function" || error === null) return;
-    if (!errorExecutions.has(error)) {
+    const key = (typeof error === "object" || typeof error === "function") && error !== null ? error : void 0;
+    if (recording.budgetExpired && !(key && errorExecutions.has(key))) {
+      const eventsDropped = Math.max(
+        1,
+        recording.cachedState?.capture?.eventsDropped ?? recording.cachedState?.truncated?.eventsDropped ?? recording.memory.eventsDropped
+      );
+      recording.cachedState = {
+        events: [],
+        functions: [],
+        truncated: { eventsDropped },
+        capture: {
+          completeness: "unavailable",
+          reason: "long_lived_execution_budget",
+          valuesDropped: recording.memory.valuesDropped,
+          eventsDropped
+        }
+      };
+    }
+    retainErrorRecording(recording);
+    if (!key) return;
+    if (!errorExecutions.has(key)) {
       stats.errorSnapshots++;
       if (recording.memory.underPressure && !recording.partialSnapshotCounted) {
         recording.partialSnapshotCounted = true;
         stats.partialErrorSnapshots++;
       }
     }
-    errorExecutions.set(error, recording);
+    errorExecutions.set(key, recording);
   };
   const countDroppedEvents = (recording, droppedBefore) => {
     const dropped = recording.journal?.dropped ?? droppedBefore;
@@ -1844,13 +3028,19 @@ 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: serializeAndCount(error).value,
+      value: (() => {
+        try {
+          return freezeAndCount(error).value;
+        } catch {
+          return { __rasputin_type: "unserializable" };
+        }
+      })(),
       commit: () => {
         if (key) recording.capturedErrors.set(key, callId);
       }
     };
   };
-  const captureCompletedThrow = (recording, plan, args, parentCallId, startedAtNs, error) => {
+  const captureCompletedThrow = (recording, plan, args, parentCallId, startedAtNs, error, capturedArgs) => {
     if (!recording.journal) {
       rememberError(error, recording);
       return;
@@ -1861,7 +3051,7 @@ var createExecutionRecorder = (options) => {
     }
     const callId = ++recording.nextCallId;
     const capturedError = serializedError(recording, error, callId);
-    const capturedArgs = Array.from(args, (argument) => captureValue(recording, argument));
+    const recordedArgs = capturedArgs ?? mapArrayLike(args, (argument) => captureValue(recording, argument));
     const endedAtNs = process.hrtime.bigint();
     const droppedBefore = recording.journal.dropped;
     const retained = recording.journal.forceCompletedCall(
@@ -1869,13 +3059,15 @@ var createExecutionRecorder = (options) => {
       callId,
       parentCallId,
       startedAtNs - recording.startedAtNs,
-      capturedArgs,
+      recordedArgs,
       KIND_THROW,
       endedAtNs - recording.startedAtNs,
       endedAtNs - startedAtNs,
       capturedError.value
     );
     if (retained) {
+      recording.lateCapturedCallIds ??= /* @__PURE__ */ new Set();
+      recording.lateCapturedCallIds.add(callId);
       stats.functionCallsCaptured++;
       capturedError.commit();
     }
@@ -1920,35 +3112,47 @@ var createExecutionRecorder = (options) => {
   };
   const settleInFlight = (recording) => {
     if (recording.inFlightCalls > 0) recording.inFlightCalls--;
-    releaseJournalIfIdle(recording);
+    releaseWhenIdle(recording);
   };
-  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++;
+  const releaseWhenIdle = (recording) => {
+    try {
+      if (!recording.finished || recording.inFlightCalls > 0) return;
+      memoryBudget.release(recording.memory);
       releaseJournalIfIdle(recording);
+    } catch {
     }
-    recording.finishedAtNs = process.hrtime.bigint();
-    addRecorderTime(recording, recording.finishedAtNs - recorderStartedAtNs);
-    recordInlineTiming(recording);
   };
-  const runStore = (store, callback) => {
+  const finish = (store, metadata) => {
+    try {
+      const { recording } = store;
+      if (recording.finished) return;
+      const recorderStartedAtNs = process.hrtime.bigint();
+      recording.finished = true;
+      if (metadata) mergeExecutionMetadata(recording.execution, metadata);
+      stats.activeExecutions = Math.max(0, stats.activeExecutions - 1);
+      if (!recording.hasError) {
+        stats.successfulExecutionsDiscarded++;
+      }
+      recording.finishedAtNs = process.hrtime.bigint();
+      addRecorderTime(recording, recording.finishedAtNs - recorderStartedAtNs);
+      recordInlineTiming(recording);
+      releaseWhenIdle(recording);
+      if (recording.inFlightCalls === 0) detachLiveRecording(recording);
+    } catch {
+    }
+  };
+  const runStore = function __rasputinHandleRun__3(store, callback) {
     if (!phaseTimingEnabled) return storage.run(store, callback);
     const alsStartedAtNs = process.hrtime.bigint();
-    return storage.run(store, () => {
+    return storage.run(store, function __rasputinHandleRun__4() {
       addPhase("alsNs", process.hrtime.bigint() - alsStartedAtNs);
       return callback();
     });
   };
   const createScope = (metadata) => {
-    const recorderStartedAtNs = process.hrtime.bigint();
     try {
+      const recorderStartedAtNs = process.hrtime.bigint();
+      sweepLongLivedExecutions(recorderStartedAtNs);
       const recording = {
         executionId: `${Date.now()}-${process.pid}-${++executionCounter}`,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1967,30 +3171,52 @@ var createExecutionRecorder = (options) => {
         hasError: false,
         memory: memoryBudget.startExecution(),
         partialSnapshotCounted: false,
-        derivationRoots: [],
-        derivationRootBytes: 0,
         sawAutomatic: false,
-        sawManual: false,
-        executedFunctionIds: /* @__PURE__ */ new Set()
+        sawManual: false
       };
       stats.activeExecutions++;
       stats.peakActiveExecutions = Math.max(stats.peakActiveExecutions, stats.activeExecutions);
+      liveRecordings.push(recording);
       addRecorderTime(recording, process.hrtime.bigint() - recorderStartedAtNs);
       const store = { recording };
       return {
-        run: (callback) => {
-          const runStartedAtNs = process.hrtime.bigint();
-          return runStore(store, () => {
-            addRecorderTime(recording, process.hrtime.bigint() - runStartedAtNs);
+        run: function __rasputinHandleRun__3(callback) {
+          let startedCallback = false;
+          try {
+            const runStartedAtNs = process.hrtime.bigint();
+            return runStore(store, function __rasputinHandleRun__4() {
+              startedCallback = true;
+              addRecorderTime(recording, process.hrtime.bigint() - runStartedAtNs);
+              try {
+                return callback();
+              } catch (error) {
+                if (recording.budgetExpired || recording.evicted) {
+                  rememberError(error, recording);
+                }
+                throw error;
+              }
+            });
+          } catch (error) {
+            if (startedCallback) throw error;
             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);
+          try {
+            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);
+          } catch {
+            return void 0;
+          }
+        },
+        associateError: (error) => {
+          try {
+            rememberError(error, recording);
+          } catch {
+          }
         },
         finish: (finishMetadata) => finish(store, finishMetadata)
       };
@@ -1998,32 +3224,11 @@ var createExecutionRecorder = (options) => {
       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;
+      const recording = (weakKey ? errorExecutions.get(weakKey) : void 0) ?? currentStore()?.recording;
       if (!recording) return void 0;
       if (metadata) mergeExecutionMetadata(recording.execution, metadata);
       rememberError(error, recording);
@@ -2033,14 +3238,46 @@ var createExecutionRecorder = (options) => {
       return void 0;
     }
   };
-  const runPreparedFunction = (plan, args, callback, omitValues) => {
-    const store = storage.getStore();
-    if (!store || store.recording.finished) return callback();
+  const runPreparedFunctionFromStore = function __rasputinHandleRun__3(store, plan, args, callback, omitValues) {
+    let startedCallback = false;
+    try {
+      return runPreparedFunctionFromStoreInner(
+        store,
+        plan,
+        args,
+        function __rasputinHandleRun__4() {
+          startedCallback = true;
+          return callback();
+        },
+        omitValues
+      );
+    } catch (error) {
+      if (startedCallback) throw error;
+      return callback();
+    }
+  };
+  const runPreparedFunctionFromStoreInner = function __rasputinHandleRun__3(store, plan, args, callback, omitValues) {
+    const omitCallValues = omitValues === true || plan.omitCallValues;
+    if (!store) return callback();
+    if (plan.disabled) {
+      noteDisabledPlan(store.recording);
+      return callback();
+    }
+    if (store.recording.finished) {
+      try {
+        return callback();
+      } catch (error) {
+        if (store.recording.budgetExpired || store.recording.evicted) {
+          rememberError(error, store.recording);
+        }
+        throw error;
+      }
+    }
     stats.functionCallsObserved++;
     const recorderStartedAtNs = process.hrtime.bigint();
     if (store.suppressCapture || plan.excluded) {
       stats.functionCallsExcluded++;
-      return runStore({ ...store, suppressCapture: true }, () => {
+      return runStore({ ...store, suppressCapture: true }, function __rasputinHandleRun__4() {
         addRecorderTime(store.recording, process.hrtime.bigint() - recorderStartedAtNs);
         return callback();
       });
@@ -2051,41 +3288,21 @@ var createExecutionRecorder = (options) => {
     const group = repeatedCallGroup(recording, plan, parentCallId);
     group.observedCalls++;
     const journal = acquireJournal(recording);
-    if (group.observedCalls === 1) journal?.notePlan(plan.runtimePlanId);
+    try {
+      if (group.observedCalls === 1) journal?.notePlan(plan.runtimePlanId);
+    } catch {
+    }
     if (group.observedCalls > maxCapturedCallsPerFunction) {
       const startedAtNs2 = process.hrtime.bigint();
       try {
-        const result = callback();
-        if (isPromiseLike(result)) {
-          addRecorderTime(recording, startedAtNs2 - recorderStartedAtNs);
-          return result.then(
-            (value) => {
-              const callbackEndedAtNs2 = process.hrtime.bigint();
-              recordSuppressedCall(recording, group, parentCallId, startedAtNs2, callbackEndedAtNs2);
-              addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs2);
-              settleInFlight(recording);
-              return value;
-            },
-            (error) => {
-              const callbackEndedAtNs2 = process.hrtime.bigint();
-              captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs2, error);
-              addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs2);
-              settleInFlight(recording);
-              throw error;
-            }
-          );
-        }
-        const callbackEndedAtNs = process.hrtime.bigint();
-        recordSuppressedCall(recording, group, parentCallId, startedAtNs2, callbackEndedAtNs);
-        addRecorderTime(recording, startedAtNs2 - recorderStartedAtNs);
-        addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs);
+        const result = runStore(store, function __rasputinHandleRun__4() {
+          return callback();
+        });
+        recordSuppressedCall(recording, group, parentCallId, startedAtNs2, process.hrtime.bigint());
         settleInFlight(recording);
         return result;
       } catch (error) {
-        const callbackEndedAtNs = process.hrtime.bigint();
         captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs2, error);
-        addRecorderTime(recording, startedAtNs2 - recorderStartedAtNs);
-        addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs);
         settleInFlight(recording);
         throw error;
       }
@@ -2093,9 +3310,8 @@ var createExecutionRecorder = (options) => {
     const startedAtNs = process.hrtime.bigint();
     if (!journal) {
       memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes);
-      return runStore(
-        store,
-        () => observeRecordedCallback(
+      return runStore(store, function __rasputinHandleRun__4() {
+        return observeRecordedCallback(
           recording,
           recorderStartedAtNs,
           callback,
@@ -2104,8 +3320,8 @@ var createExecutionRecorder = (options) => {
             rememberError(error, recording);
             settleInFlight(recording);
           }
-        )
-      );
+        );
+      });
     }
     if (!journal.canStartCall()) {
       const captureSuccess = () => {
@@ -2114,9 +3330,8 @@ var createExecutionRecorder = (options) => {
         countDroppedEvents(recording, droppedBefore);
         settleInFlight(recording);
       };
-      return runStore(
-        store,
-        () => observeRecordedCallback(
+      return runStore(store, function __rasputinHandleRun__4() {
+        return observeRecordedCallback(
           recording,
           recorderStartedAtNs,
           callback,
@@ -2125,8 +3340,8 @@ var createExecutionRecorder = (options) => {
             captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs, error);
             settleInFlight(recording);
           }
-        )
-      );
+        );
+      });
     }
     if (!memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes)) {
       return observeRecordedCallback(
@@ -2142,12 +3357,27 @@ var createExecutionRecorder = (options) => {
     }
     const callId = ++recording.nextCallId;
     const enterTimestampNs = process.hrtime.bigint() - recording.startedAtNs;
-    const capturedArgs = omitValues ? Array.from(args, () => rasputinOmitted()) : Array.from(args, (argument) => captureValue(recording, argument));
-    journal.startCall(plan.runtimePlanId, callId, parentCallId, enterTimestampNs, capturedArgs);
+    const capturedArgs = omitCallValues ? mapArrayLike(args, () => rasputinOmitted()) : mapArrayLike(args, (argument) => captureValue(recording, argument));
+    try {
+      journal.startCall(plan.runtimePlanId, callId, parentCallId, enterTimestampNs, capturedArgs);
+    } catch {
+      journal.dropCall();
+      return runStore(store, function __rasputinHandleRun__4() {
+        return observeRecordedCallback(
+          recording,
+          recorderStartedAtNs,
+          callback,
+          () => settleInFlight(recording),
+          (error) => {
+            rememberError(error, recording);
+            settleInFlight(recording);
+          }
+        );
+      });
+    }
     const callStore = { recording, currentCallId: callId };
-    return runStore(
-      callStore,
-      () => observeRecordedCallback(
+    return runStore(callStore, function __rasputinHandleRun__4() {
+      return observeRecordedCallback(
         recording,
         recorderStartedAtNs,
         callback,
@@ -2155,7 +3385,7 @@ var createExecutionRecorder = (options) => {
           if (recording.journal) {
             const timestampNs = process.hrtime.bigint() - recording.startedAtNs;
             const durationNs = process.hrtime.bigint() - startedAtNs;
-            const returnValue = omitValues ? rasputinOmitted() : captureValue(recording, value);
+            const returnValue = omitCallValues ? rasputinOmitted() : captureValue(recording, value);
             recording.journal.finishCall(KIND_EXIT, callId, timestampNs, durationNs, returnValue);
             stats.functionCallsCaptured++;
           }
@@ -2180,113 +3410,519 @@ var createExecutionRecorder = (options) => {
           rememberError(error, recording);
           settleInFlight(recording);
         }
-      )
-    );
+      );
+    });
+  };
+  const noopHandle2 = {
+    leave: (value) => value,
+    fail: () => {
+    },
+    end: () => {
+    },
+    run: function __rasputinHandleRun__3(callback) {
+      return runExactlyOnce((invoke) => invoke(), callback);
+    },
+    suspend: (value) => value,
+    resume: (value) => value
+  };
+  const bindStoreTransitions = (active, parent, recording, plan) => {
+    let suspended = false;
+    const enter = (next) => {
+      try {
+        storage.enterWith(next);
+      } catch {
+        degradeAttribution(recording, plan);
+      }
+    };
+    const expectStore = (expected) => {
+      if (currentStore() !== expected) degradeAttribution(recording, plan);
+    };
+    return {
+      enterActive: () => enter(active),
+      run: function __rasputinHandleRun__3(callback) {
+        return runExactlyOnce((invoke) => {
+          try {
+            enter(parent);
+          } catch {
+          }
+          return storage.run(active, invoke);
+        }, callback);
+      },
+      suspend: (value) => {
+        expectStore(active);
+        suspended = true;
+        enter(parent);
+        return value;
+      },
+      resume: (value) => {
+        if (suspended) {
+          expectStore(parent);
+          suspended = false;
+          enter(active);
+        } else {
+          expectStore(active);
+        }
+        return value;
+      },
+      restore: () => {
+        expectStore(active);
+        enter(parent);
+      }
+    };
+  };
+  const enterPreparedFunctionFromStore = (store, plan, args, omitValues) => {
+    if (!store) return noopHandle2;
+    if (plan.disabled) {
+      noteDisabledPlan(store.recording);
+      return noopHandle2;
+    }
+    if (store.recording.finished) {
+      if (!store.recording.budgetExpired && !store.recording.evicted) return noopHandle2;
+      const expired = store.recording;
+      const expiredStore = { recording: expired };
+      return {
+        leave: (value) => value,
+        fail: (error) => {
+          rememberError(error, expired);
+        },
+        end: () => {
+        },
+        run: function __rasputinHandleRun__3(callback) {
+          return runExactlyOnce((invoke) => storage.run(expiredStore, invoke), callback);
+        },
+        suspend: (value) => value,
+        resume: (value) => value
+      };
+    }
+    stats.functionCallsObserved++;
+    const recording = store.recording;
+    const omitCallValues = omitValues === true || plan.omitCallValues;
+    const parentCallId = store.currentCallId;
+    if (store.suppressCapture || plan.excluded) {
+      stats.functionCallsExcluded++;
+      const excludedStore = { ...store, suppressCapture: true };
+      const excluded = bindStoreTransitions(excludedStore, store, recording, plan);
+      excluded.enterActive();
+      let ended2 = false;
+      return {
+        leave: (value) => value,
+        fail: () => {
+        },
+        end: () => {
+          if (ended2) return;
+          ended2 = true;
+          excluded.restore();
+        },
+        run: excluded.run,
+        suspend: excluded.suspend,
+        resume: excluded.resume
+      };
+    }
+    recording.inFlightCalls++;
+    const group = repeatedCallGroup(recording, plan, parentCallId);
+    group.observedCalls++;
+    const journal = acquireJournal(recording);
+    try {
+      if (group.observedCalls === 1) journal?.notePlan(plan.runtimePlanId);
+    } catch {
+    }
+    let status = "open";
+    let pendingReturn;
+    let ended = false;
+    const startedAtNs = process.hrtime.bigint();
+    const parentStore = store;
+    const uncaptured = bindStoreTransitions(parentStore, parentStore, recording, plan);
+    const finishEnd = () => {
+      if (ended) return;
+      ended = true;
+      settleInFlight(recording);
+      uncaptured.restore();
+    };
+    const context = {
+      run: uncaptured.run,
+      suspend: uncaptured.suspend,
+      resume: uncaptured.resume
+    };
+    if (group.observedCalls > maxCapturedCallsPerFunction) {
+      uncaptured.enterActive();
+      return {
+        leave: (value) => {
+          if (status !== "failed") {
+            status = "left";
+            pendingReturn = value;
+          }
+          return value;
+        },
+        fail: (error, liveArgs) => {
+          if (status === "failed") return;
+          status = "failed";
+          captureCompletedThrow(
+            recording,
+            plan,
+            liveArgs ?? args,
+            parentCallId,
+            startedAtNs,
+            error
+          );
+        },
+        end: () => {
+          if (status !== "failed") {
+            recordSuppressedCall(
+              recording,
+              group,
+              parentCallId,
+              startedAtNs,
+              process.hrtime.bigint()
+            );
+          }
+          finishEnd();
+        },
+        ...context
+      };
+    }
+    const dropWithoutCapture = (onThrow) => {
+      uncaptured.enterActive();
+      return {
+        leave: (value) => {
+          if (status !== "failed") {
+            status = "left";
+            pendingReturn = value;
+          }
+          return value;
+        },
+        fail: (error) => {
+          if (status === "failed") return;
+          status = "failed";
+          onThrow(error);
+        },
+        end: () => {
+          if (status !== "failed") {
+            const droppedBefore = recording.journal?.dropped ?? 0;
+            recording.journal?.dropCall();
+            countDroppedEvents(recording, droppedBefore);
+          }
+          finishEnd();
+        },
+        ...context
+      };
+    };
+    if (!journal) {
+      memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes);
+      uncaptured.enterActive();
+      return {
+        leave: (value) => {
+          if (status !== "failed") {
+            status = "left";
+            pendingReturn = value;
+          }
+          return value;
+        },
+        fail: (error) => {
+          if (status === "failed") return;
+          status = "failed";
+          rememberError(error, recording);
+        },
+        end: finishEnd,
+        ...context
+      };
+    }
+    if (!journal.canStartCall()) {
+      return dropWithoutCapture((error) => {
+        captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs, error);
+      });
+    }
+    if (!memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes)) {
+      uncaptured.enterActive();
+      return {
+        leave: (value) => {
+          if (status !== "failed") {
+            status = "left";
+            pendingReturn = value;
+          }
+          return value;
+        },
+        fail: (error) => {
+          if (status === "failed") return;
+          status = "failed";
+          rememberError(error, recording);
+        },
+        end: finishEnd,
+        ...context
+      };
+    }
+    const callId = ++recording.nextCallId;
+    const enterTimestampNs = process.hrtime.bigint() - recording.startedAtNs;
+    const capturedArgs = omitCallValues ? mapArrayLike(args, () => rasputinOmitted()) : mapArrayLike(args, (argument) => captureValue(recording, argument));
+    try {
+      journal.startCall(plan.runtimePlanId, callId, parentCallId, enterTimestampNs, capturedArgs);
+    } catch {
+      journal.dropCall();
+      return dropWithoutCapture((error) => rememberError(error, recording));
+    }
+    const callStore = { recording, currentCallId: callId };
+    const captured = bindStoreTransitions(callStore, parentStore, recording, plan);
+    captured.enterActive();
+    const writeExit = (value) => {
+      if (!recording.journal) return;
+      const timestampNs = process.hrtime.bigint() - recording.startedAtNs;
+      const durationNs = process.hrtime.bigint() - startedAtNs;
+      const returnValue = omitCallValues ? rasputinOmitted() : captureValue(recording, value);
+      recording.journal.finishCall(KIND_EXIT, callId, timestampNs, durationNs, returnValue);
+      stats.functionCallsCaptured++;
+    };
+    const writeThrow = (error) => {
+      if (!recording.journal) {
+        rememberError(error, recording);
+        return;
+      }
+      const capturedError = serializedError(recording, error, callId);
+      recording.journal.finishCall(
+        KIND_THROW,
+        callId,
+        process.hrtime.bigint() - recording.startedAtNs,
+        process.hrtime.bigint() - startedAtNs,
+        capturedError.value
+      );
+      stats.functionCallsCaptured++;
+      capturedError.commit();
+      rememberError(error, recording);
+    };
+    return {
+      leave: (value) => {
+        if (status !== "failed") {
+          status = "left";
+          pendingReturn = value;
+        }
+        return value;
+      },
+      fail: (error) => {
+        if (status === "failed") return;
+        status = "failed";
+        try {
+          writeThrow(error);
+        } catch {
+          rememberError(error, recording);
+        }
+      },
+      end: () => {
+        try {
+          if (status !== "failed") writeExit(status === "left" ? pendingReturn : void 0);
+        } catch {
+        }
+        if (ended) return;
+        ended = true;
+        settleInFlight(recording);
+        captured.restore();
+      },
+      run: captured.run,
+      suspend: captured.suspend,
+      resume: captured.resume
+    };
+  };
+  const runPreparedFunction = (plan, args, callback, omitValues) => {
+    const store = currentStore();
+    if (store && !store.recording.finished && !store.recording.sawAutomatic) {
+      store.recording.sawAutomatic = true;
+    }
+    return runPreparedFunctionFromStore(store, plan, args, callback, omitValues);
+  };
+  const isolateHandle2 = (handle) => ({
+    leave: (value) => {
+      try {
+        return handle.leave(value);
+      } catch {
+        return value;
+      }
+    },
+    fail: (error, liveArgs) => {
+      try {
+        handle.fail(error, liveArgs);
+      } catch {
+      }
+    },
+    end: () => {
+      try {
+        handle.end();
+      } catch {
+      }
+    },
+    run: function __rasputinHandleRun__3(callback) {
+      return runExactlyOnce((invoke) => handle.run(invoke), callback);
+    },
+    suspend: (value) => {
+      try {
+        return handle.suspend(value);
+      } catch {
+        return value;
+      }
+    },
+    resume: (value) => {
+      try {
+        return handle.resume(value);
+      } catch {
+        return value;
+      }
+    }
+  });
+  const enterPreparedFunction = (plan, args, omitValues) => {
+    try {
+      const store = currentStore();
+      if (store && !store.recording.finished && !store.recording.sawAutomatic) {
+        store.recording.sawAutomatic = true;
+      }
+      return isolateHandle2(enterPreparedFunctionFromStore(store, plan, args, omitValues));
+    } catch {
+      return noopHandle2;
+    }
   };
   const runFunction = (input, args, callback) => {
-    const store = storage.getStore();
+    const store = currentStore();
     if (store && !store.recording.finished) store.recording.sawManual = true;
-    return runPreparedFunction(preparePlan(normalizeFunctionDefinition(input)), args, callback);
+    return runPreparedFunctionFromStore(
+      store,
+      preparePlan(normalizeFunctionDefinition(input)),
+      args,
+      callback
+    );
   };
   const runFunctionPlans = (plans, planIndex, args, callback, omitValues) => {
-    const store = storage.getStore();
+    const store = currentStore();
     const plan = preparedPlansFor(plans)[planIndex];
-    if (store && !store.recording.finished) {
+    if (store && !store.recording.finished && !store.recording.sawAutomatic) {
       store.recording.sawAutomatic = true;
-      if (plan) store.recording.executedFunctionIds.add(plan.functionId);
     }
-    return plan ? runPreparedFunction(plan, args, callback, omitValues) : callback();
+    return plan ? runPreparedFunctionFromStore(store, plan, args, callback, omitValues) : 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) {
-      const store = storage.getStore();
+    return function __rasputinHandleRun__3(...args) {
+      if (new.target) {
+        throw new TypeError("execution.trace() wraps function calls, not constructors");
+      }
+      const receiver = this;
+      const store = currentStore();
       if (store && !store.recording.finished) store.recording.sawManual = true;
-      return runPreparedFunction(plan, args, () => fn.apply(this, args));
+      return runPreparedFunctionFromStore(store, plan, args, function __rasputinHandleRun__4() {
+        return fn.apply(receiver, args);
+      });
     };
   }
-  const captureDerivationRoot = (rootId, value) => {
-    const store = storage.getStore();
-    if (!store || store.recording.finished || store.suppressCapture) return value;
-    const recording = store.recording;
-    if (recording.memory.mode !== "full") return value;
-    if (recording.derivationRoots.length >= maxEventsPerExecution) return value;
-    const recorderStartedAtNs = process.hrtime.bigint();
-    try {
-      const serialized = captureValue(recording, value);
-      if (recording.memory.mode !== "full") return value;
-      if (!memoryBudget.reserveStorage(recording.memory, DERIVATION_ROOT_RECORD_BYTES)) {
-        return value;
-      }
-      const completeness = capturedValueCompleteness(serialized);
-      const bytes = jsonLiteralUtf8Bytes(serialized);
-      recording.derivationRoots.push({
-        rootId,
-        callId: store.currentCallId ?? 0,
-        value: serialized,
-        completeness
-      });
-      recording.derivationRootBytes += bytes;
-      stats.derivationRootsCaptured++;
-      stats.derivationRootBytes += bytes;
-      stats.derivationFallbackExpressions++;
-      return value;
-    } finally {
-      addRecorderTime(recording, process.hrtime.bigint() - recorderStartedAtNs);
-    }
-  };
   return {
     createScope,
-    run,
     getErrorState,
     runFunction,
     runFunctionPlans,
     prepareFunctionPlans,
     runPreparedFunction,
+    enterPreparedFunction,
     trace,
-    captureDerivationRoot,
-    getStats: () => {
-      const manifest = snapshotInstrumentationManifest();
-      const plans = manifest?.derivationPlans ?? [];
-      return {
-        ...stats,
-        ...memoryBudget.getStats(),
-        ...journalPool.stats(),
-        derivationCandidateFunctions: plans.filter((plan) => !plan.fallbackReason).length,
-        derivationFallbackFunctions: plans.filter((plan) => plan.fallbackReason).length,
-        derivationFallbackReasons: { ...stats.derivationFallbackReasons },
-        ...phases ? {
-          phaseAlsNs: Number(phases.alsNs),
-          phaseMaterializeNs: Number(phases.materializeNs)
-        } : {}
-      };
-    }
+    getStats: () => ({
+      ...stats,
+      ...memoryBudget.getStats(),
+      ...journalPool.stats(),
+      ...phases ? {
+        phaseAlsNs: Number(phases.alsNs),
+        phaseMaterializeNs: Number(phases.materializeNs)
+      } : {}
+    })
   };
 };
 
 // src/execution-recorder/automatic-runtime.ts
-var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v3";
 var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
-var passthroughCapture = (_rootId, value) => value;
-var passthrough = (_planIndex, _args, callback) => callback();
+var passthroughHandle = () => ({
+  leave: (value) => value,
+  fail: () => {
+  },
+  end: () => {
+  },
+  run: function __rasputinHandleRun__3(callback) {
+    return runExactlyOnce((invoke) => invoke(), callback);
+  },
+  suspend: (value) => value,
+  resume: (value) => value
+});
+var isolateHandle = (handle) => ({
+  leave: (value) => {
+    try {
+      return handle.leave(value);
+    } catch {
+      return value;
+    }
+  },
+  fail: (error, liveArgs) => {
+    try {
+      handle.fail(error, liveArgs);
+    } catch {
+    }
+  },
+  end: () => {
+    try {
+      handle.end();
+    } catch {
+    }
+  },
+  run: function __rasputinHandleRun__3(callback) {
+    return runExactlyOnce((invoke) => handle.run(invoke), callback);
+  },
+  suspend: (value) => {
+    try {
+      return handle.suspend(value);
+    } catch {
+      return value;
+    }
+  },
+  resume: (value) => {
+    try {
+      return handle.resume(value);
+    } catch {
+      return value;
+    }
+  }
+});
+var passthroughRun = (_planIndex, _args, callback) => callback();
+var passthroughEnter = () => passthroughHandle();
 var bindPassthrough = (module) => {
-  module.cell.run = passthrough;
+  module.cell.run = passthroughRun;
+  module.cell.enter = passthroughEnter;
+};
+var attachRunner = (cell) => {
+  const run = ((planIndex, args, callback, omitValues) => cell.run(planIndex, args, callback, omitValues));
+  run.enter = (planIndex, args, omitValues) => cell.enter(planIndex, args, omitValues);
+  return run;
+};
+var bindExecution = (execution, module) => {
+  const prepared = execution.prepareFunctionPlans(module.plans);
+  module.cell.run = (planIndex, args, callback, omitValues) => {
+    const plan = prepared[planIndex];
+    return plan ? execution.runPreparedFunction(plan, args, callback, omitValues) : callback();
+  };
+  module.cell.enter = (planIndex, args, omitValues) => {
+    try {
+      const plan = prepared[planIndex];
+      return isolateHandle(
+        plan ? execution.enterPreparedFunction(plan, args, omitValues) : passthroughEnter(planIndex, args, omitValues)
+      );
+    } catch {
+      return passthroughHandle();
+    }
+  };
 };
 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 cell = { run: passthroughRun, enter: passthroughEnter };
   const module = { plans, cell };
   registry.modules.push(module);
   registry.runtimes.at(-1)?.bind(module);
-  return (planIndex, args, callback, omitValues) => cell.run(planIndex, args, callback, omitValues);
+  return attachRunner(cell);
 };
 var createRegistry = () => {
   const registry = {
     runtimes: [],
     modules: [],
-    captureRoot: passthroughCapture,
     register(plans) {
       return registerModule(registry, plans);
     }
@@ -2296,9 +3932,6 @@ var createRegistry = () => {
 var getAutomaticRuntimeRegistry = () => {
   const existing = Reflect.get(globalThis, runtimeSymbol);
   if (existing && typeof existing === "object" && isRegistry(existing)) {
-    if (typeof existing.captureRoot !== "function") {
-      existing.captureRoot = passthroughCapture;
-    }
     return existing;
   }
   const registry = createRegistry();
@@ -2309,18 +3942,15 @@ var installAutomaticExecutionRuntime = (execution) => {
   const registry = getAutomaticRuntimeRegistry();
   const runtime = {
     bind(module) {
-      module.cell.run = (planIndex, args, callback, omitValues) => execution.runFunctionPlans(module.plans, planIndex, args, callback, omitValues);
-    },
-    captureRoot: (rootId, value) => execution.captureDerivationRoot(rootId, value)
+      bindExecution(execution, module);
+    }
   };
   registry.runtimes.push(runtime);
-  registry.captureRoot = runtime.captureRoot;
   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);
-    registry.captureRoot = current?.captureRoot ?? passthroughCapture;
     for (const module of registry.modules) {
       if (current) current.bind(module);
       else bindPassthrough(module);
@@ -2329,117 +3959,234 @@ var installAutomaticExecutionRuntime = (execution) => {
 };
 
 // src/install-global-handlers.ts
+var RASPUTIN_PROCESS_LISTENER = Symbol.for("rasputin.process.listener.v1");
+var unhandledRejectionMode = () => {
+  const tokens = [
+    ...process.execArgv,
+    ...(process.env.NODE_OPTIONS?.match(/(?:[^\s"]+|"[^"]*")+/g) ?? []).map(
+      (token) => token.replace(/^"|"$/g, "")
+    )
+  ];
+  for (let index = tokens.length - 1; index >= 0; index--) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token.startsWith("--unhandled-rejections="))
+      return token.slice("--unhandled-rejections=".length);
+    if (token === "--unhandled-rejections") return tokens[index + 1] ?? "";
+  }
+  return "throw";
+};
+var isBun = typeof process.versions.bun === "string";
+var unhandledRejectionIsFatal = () => {
+  const mode = unhandledRejectionMode();
+  return mode === "throw" || mode === "strict";
+};
+var printDiagnostic = (error) => {
+  if (error instanceof Error) {
+    console.error(error.stack ?? `${error.name}: ${error.message}`);
+    return;
+  }
+  console.error(error);
+};
 var removeProcessListener = process.off.bind(process);
-var installGlobalHandlers = (client, options = {}) => {
-  const exitOnUncaught = options.exitOnUncaughtException ?? true;
-  const flushTimeoutMs = options.flushTimeoutMs ?? 2e3;
-  let handlingUncaught = false;
-  const onUnhandledRejection = (reason) => {
+var tagListener = (listener) => {
+  Object.defineProperty(listener, RASPUTIN_PROCESS_LISTENER, { value: true });
+  return listener;
+};
+var hostListenerCount = (event) => {
+  const listeners = event === "uncaughtException" ? process.listeners("uncaughtException") : process.listeners("unhandledRejection");
+  return listeners.filter((listener) => !(RASPUTIN_PROCESS_LISTENER in listener)).length;
+};
+var registered = [];
+var uninstallProcess;
+var handlingUncaught = false;
+var captureOnAll = (error) => {
+  for (const entry of registered) {
     try {
-      client.captureException(reason);
+      entry.client.captureException(error);
     } catch {
     }
-  };
-  const onUncaughtException = (error) => {
+  }
+};
+var flushAll = async (timeoutMs) => {
+  await Promise.all(
+    registered.map(
+      (entry) => entry.client.flush(timeoutMs).catch(() => {
+      })
+    )
+  );
+};
+var installSharedListeners = () => {
+  if (uninstallProcess) return;
+  const onUnhandledRejection = tagListener((reason) => {
+    captureOnAll(reason);
+    if (hostListenerCount("unhandledRejection") > 0) return;
+    const mode = unhandledRejectionMode();
+    if (mode !== "none") printDiagnostic(reason);
+    if (mode === "warn-with-error-code") process.exitCode = 1;
+  });
+  const onUncaughtException = tagListener((error, origin) => {
+    const exitOnUncaught = registered.some((entry) => entry.exitOnUncaught);
+    const flushTimeoutMs = registered.reduce(
+      (max, entry) => Math.max(max, entry.flushTimeoutMs),
+      2e3
+    );
     if (handlingUncaught) {
-      process.exit(1);
+      if (exitOnUncaught && hostListenerCount("uncaughtException") === 0) {
+        process.exit(1);
+      }
       return;
     }
     handlingUncaught = true;
-    try {
-      client.captureException(error);
-    } catch {
-    }
-    const soleListener = process.listenerCount("uncaughtException") <= 1;
+    captureOnAll(error);
+    const hostOwns = hostListenerCount("uncaughtException") > 0;
+    const shouldExit = exitOnUncaught && !hostOwns && !(isBun && origin === "unhandledRejection");
+    if (!hostOwns) printDiagnostic(error);
+    if (shouldExit) process.exitCode = 1;
     const shutdown = async () => {
       try {
-        await client.flush(flushTimeoutMs);
+        await flushAll(flushTimeoutMs);
       } catch {
       }
-      if (exitOnUncaught && soleListener) process.exit(1);
+      if (shouldExit) {
+        process.exit(1);
+        return;
+      }
+      handlingUncaught = false;
     };
+    if (shouldExit) {
+      const watchdog = setTimeout(() => process.exit(1), flushTimeoutMs + 50);
+      void shutdown().finally(() => clearTimeout(watchdog));
+      return;
+    }
     void shutdown();
-  };
+  });
   try {
     process.on("uncaughtException", onUncaughtException);
-    process.on("unhandledRejection", onUnhandledRejection);
+    if (!unhandledRejectionIsFatal()) {
+      process.on("unhandledRejection", onUnhandledRejection);
+    }
   } catch {
-    return () => {
-    };
+    return;
   }
-  return () => {
+  uninstallProcess = () => {
     try {
       removeProcessListener("uncaughtException", onUncaughtException);
       removeProcessListener("unhandledRejection", onUnhandledRejection);
     } catch {
     }
+    uninstallProcess = void 0;
+    handlingUncaught = false;
+  };
+};
+var installGlobalHandlers = (client, options = {}) => {
+  const entry = {
+    client,
+    exitOnUncaught: options.exitOnUncaughtException ?? true,
+    flushTimeoutMs: options.flushTimeoutMs ?? 2e3
+  };
+  registered.push(entry);
+  installSharedListeners();
+  return () => {
+    const index = registered.indexOf(entry);
+    if (index >= 0) registered.splice(index, 1);
+    if (registered.length === 0) uninstallProcess?.();
   };
 };
-
-// src/rasputin-init.ts
-import { join } from "node:path";
-import {
-  createClient,
-  isClientEnabled
-} from "@rasputin-ai/core";
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/node";
-var SDK_VERSION = "0.5.0-alpha.8";
+var SDK_VERSION = "0.5.0";
 
 // src/rasputin-init.ts
-var withExecution = (client, execution, installRuntime, manifest) => {
-  const uninstallRuntime = installRuntime ? installAutomaticExecutionRuntime(execution) : () => {
+var publicExecution = (runtime) => ({
+  createScope: (metadata) => {
+    const scope = runtime.createScope(metadata);
+    return {
+      run: scope.run,
+      associateError: scope.associateError,
+      finish: scope.finish
+    };
+  },
+  trace: runtime.trace,
+  getStats: runtime.getStats
+});
+var withExecution = (client, runtime, installRuntime, manifest, uninstallHandlers = () => {
+}) => {
+  const uninstallRuntime = installRuntime ? installAutomaticExecutionRuntime(runtime) : () => {
   };
   const manifestUpload = scheduleInstrumentationManifestUpload(manifest);
+  const execution = publicExecution(runtime);
   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 });
+      const result = client.captureException(error, context);
       manifestUpload.flushSoon();
       return result;
     },
     flush: async (timeoutMs) => {
+      const startedAt = Date.now();
       await client.flush(timeoutMs);
-      await manifestUpload.wait();
+      if (timeoutMs === void 0) {
+        await manifestUpload.wait();
+        return;
+      }
+      await manifestUpload.wait(Math.max(0, timeoutMs - (Date.now() - startedAt)));
     },
     close: async () => {
+      uninstallHandlers();
       uninstallRuntime();
       manifestUpload.disconnect();
+      const startedAt = Date.now();
       await client.close();
-      await manifestUpload.wait();
+      await manifestUpload.wait(Math.max(0, 2e3 - (Date.now() - startedAt)));
     }
   };
 };
 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({
+    const enabled = isClientEnabled(options);
+    const recorderEnabled = enabled && options.executionRecorder?.enabled !== false;
+    const runtime = createExecutionRecorder({
       ...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,
-      apiUrl: options.apiUrl,
-      enabled: isClientEnabled(options),
-      sourceRoot: options.sourceRoot,
-      sourceRoots: options.sourceRoots,
-      logSuccess: options.logSuccess
+    const client = createClient(options, {
+      sdkVersion: SDK_VERSION,
+      sdkName: SDK_NAME,
+      installTransportSignalHandlers: options.installTransportSignalHandlers,
+      resolveRuntimeState: (error, context) => runtime.getErrorState(
+        error,
+        context?.request ? { kind: "http", request: context.request } : void 0
+      )
     });
-    if (isClientEnabled(options)) {
-      installGlobalHandlers(wrappedClient);
+    if (enabled) {
+      loadInstrumentationManifestIfPresent(
+        options.instrumentationManifestPath ?? process.env.RASPUTIN_INSTRUMENTATION_MANIFEST ?? join(process.cwd(), ".rasputin", "instrumentation-manifest.json")
+      );
+    }
+    let uninstallHandlers = () => {
+    };
+    const wrappedClient = withExecution(
+      client,
+      runtime,
+      recorderEnabled,
+      {
+        projectApiKey: options.projectApiKey ?? "",
+        release: options.release,
+        apiUrl: options.apiUrl,
+        enabled,
+        sourceRoot: options.sourceRoot,
+        sourceRoots: options.sourceRoots,
+        logSuccess: options.logSuccess
+      },
+      () => uninstallHandlers()
+    );
+    if (enabled && options.installGlobalHandlers !== false) {
+      uninstallHandlers = installGlobalHandlers(wrappedClient);
     }
     return wrappedClient;
   } catch {
@@ -2448,7 +4195,7 @@ var RasputinInit = (options) => {
       createExecutionRecorder({ enabled: false }),
       false,
       {
-        projectApiKey: options.projectApiKey,
+        projectApiKey: options.projectApiKey ?? "",
         release: options.release,
         apiUrl: options.apiUrl,
         enabled: false,
@@ -2460,9 +4207,5 @@ var RasputinInit = (options) => {
   }
 };
 export {
-  RasputinInit,
-  createExecutionRecorder,
-  installAutomaticExecutionRuntime,
-  installGlobalHandlers,
-  scheduleInstrumentationManifestUpload
+  RasputinInit
 };