@rasputin-ai/node 0.5.0-alpha.9 → 0.5.1

package/dist/internal.js

@@ -0,0 +1,4072 @@
+// 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/instrumentation-manifest-registry.ts
+import { createHash } from "node:crypto";
+import {
+  INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+  sourceLocatorFromFile as sourceLocatorFromFile2
+} from "@rasputin-ai/core";
+
+// src/execution-recorder/function-plan.ts
+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;
+  const source = packageRelativePath ? {
+    ...packageName ? { packageName } : {},
+    packageRelativePath,
+    ...line == null ? {} : { line },
+    ...column == null ? {} : { column }
+  } : void 0;
+  return {
+    functionId,
+    name,
+    ...source ? { source } : {},
+    ...encodedPlanHasPreBodyParameterEvaluation(plan) ? { parentAttribution: "pre_body_parameter_evaluation" } : {}
+  };
+};
+var estimatedCallBytesFor = (functionId) => EVENT_PAIR_BASE_ESTIMATED_BYTES + Buffer.byteLength(functionId, "utf8") * 2;
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v3";
+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") {
+    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,
+    alreadyInstrumented: 0
+  };
+  Reflect.set(globalThis, registrySymbol, registry);
+  return registry;
+};
+var sourceAt = (filePath, line, column) => {
+  const source = sourceLocatorFromFile2(filePath);
+  return source ? { ...source, line, column } : void 0;
+};
+var stableId = (kind, ...parts) => `${kind}_${createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 24)}`;
+var isInstrumentationManifestDirty = () => {
+  const registry = getRegistry();
+  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 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;
+      functions.push({
+        functionId: definition.functionId,
+        source: definition.source,
+        name: fn.name,
+        startLine: fn.startLine,
+        startColumn: fn.startColumn,
+        endLine: fn.endLine,
+        endColumn: fn.endColumn,
+        params: fn.params,
+        ...fn.instrumented === false ? { instrumented: false, skipReason: fn.skipReason } : {}
+      });
+    }
+    for (const site of delta.callSites) {
+      const source = sourceAt(site.filePath, site.line, site.column);
+      if (!source) continue;
+      callSites.push({
+        id: stableId(
+          "cs",
+          site.callerFunctionId,
+          source.packageName ?? "",
+          source.packageRelativePath,
+          site.line,
+          site.column
+        ),
+        callerFunctionId: site.callerFunctionId,
+        calleeName: site.calleeName,
+        calleeText: site.calleeText,
+        source,
+        line: site.line,
+        column: site.column,
+        endLine: site.endLine,
+        endColumn: site.endColumn,
+        resultBinding: site.resultBinding,
+        argIdentifiers: site.argIdentifiers
+      });
+    }
+    for (const destructure of delta.destructures) {
+      const source = sourceAt(destructure.filePath, destructure.line, destructure.column);
+      if (!source) continue;
+      destructures.push({
+        callerFunctionId: destructure.callerFunctionId,
+        sourceParam: destructure.sourceParam,
+        source,
+        line: destructure.line,
+        column: destructure.column,
+        binding: destructure.binding
+      });
+    }
+  }
+  if (registry.prebuilt && registry.files.size === 0) {
+    const prebuilt = registry.prebuilt;
+    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 remember(void 0);
+  }
+  const packages = { ...options.sourceRoots ?? {} };
+  return remember({
+    schema_version: INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+    ...options.sourceRoot || Object.keys(packages).length > 0 ? {
+      sourceRoots: {
+        ...options.sourceRoot ? { default: options.sourceRoot } : {},
+        packages
+      }
+    } : {},
+    functions,
+    callSites,
+    destructures
+  });
+};
+var markInstrumentationManifestUploaded = (generation) => {
+  const registry = getRegistry();
+  if (registry.generation === generation) registry.uploadedGeneration = generation;
+};
+var setInstrumentationManifestOnDirty = (onDirty) => {
+  getRegistry().onDirty = onDirty;
+};
+
+// src/auto-instrumentation/schedule-instrumentation-manifest-upload.ts
+var unavailable = () => ({
+  status: "unavailable",
+  verified: 0,
+  unresolved: [],
+  packages: []
+});
+var noopHandle = {
+  flushSoon() {
+  },
+  async wait() {
+  },
+  disconnect() {
+  },
+  async verify() {
+    return unavailable();
+  }
+};
+var scheduleInstrumentationManifestUpload = (options) => {
+  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 = 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.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 = () => {
+    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);
+          }
+        }
+      } finally {
+        working = false;
+      }
+    });
+  };
+  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 (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();
+      await inflight;
+      return verification;
+    }
+  };
+};
+
+// src/execution-recorder/execution-recorder.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import {
+  rasputinOmitted,
+  rasputinTagKind,
+  runtimeFunctionId as runtimeFunctionId2
+} from "@rasputin-ai/core";
+
+// src/execution-recorder/execution-journal.ts
+var KIND_ENTER = 1;
+var KIND_EXIT = 2;
+var KIND_THROW = 3;
+var KIND_SUPPRESSED = 4;
+var NO_PARENT = 4294967295;
+var NO_SUPPRESSION = 4294967295;
+var MAX_POOLED_JOURNALS = 8;
+var MAX_POOLED_JOURNAL_CAPACITY = 4096;
+var INITIAL_JOURNAL_STORAGE = 32;
+var BYTES_PER_EVENT = Uint8Array.BYTES_PER_ELEMENT + Uint32Array.BYTES_PER_ELEMENT * 4 + BigInt64Array.BYTES_PER_ELEMENT * 2;
+var DEFAULT_MAX_EVENTS_PER_EXECUTION = 500;
+var MAX_JOURNAL_EVENTS = 16384;
+var elapsedMs = (startedAtNs, endedAtNs) => Number(endedAtNs - startedAtNs) / 1e6;
+var roundedMilliseconds = (nanoseconds) => Math.round(Number(nanoseconds) / 1e6 * 1e4) / 1e4;
+var relativeMs = (relativeNs) => Number(relativeNs) / 1e6;
+var sanitizeJournalCapacity = (value) => {
+  const requested = value ?? DEFAULT_MAX_EVENTS_PER_EXECUTION;
+  if (!Number.isFinite(requested)) return DEFAULT_MAX_EVENTS_PER_EXECUTION;
+  return Math.min(MAX_JOURNAL_EVENTS, Math.max(2, Math.floor(requested)));
+};
+var ExecutionJournal = class {
+  dropped = 0;
+  allocatedBytes = 0;
+  onGrow;
+  length = 0;
+  kind = new Uint8Array(0);
+  planId = new Uint32Array(0);
+  callId = new Uint32Array(0);
+  parentCallId = new Uint32Array(0);
+  timestampNs = new BigInt64Array(0);
+  durationNs = new BigInt64Array(0);
+  suppressionIndex = new Uint32Array(0);
+  payloads = [];
+  suppressions = [];
+  openCallIds = /* @__PURE__ */ new Set();
+  notedPlanIds = [];
+  notedPlanSet = /* @__PURE__ */ new Set();
+  maxCapacity;
+  constructor(capacity) {
+    this.maxCapacity = sanitizeJournalCapacity(capacity);
+    this.reallocate(Math.min(this.maxCapacity, INITIAL_JOURNAL_STORAGE));
+  }
+  get capacity() {
+    return this.maxCapacity;
+  }
+  get hasOpenCalls() {
+    return this.openCallIds.size > 0;
+  }
+  get eventCount() {
+    return this.length;
+  }
+  get payloadSlotCount() {
+    return this.payloads.length;
+  }
+  canStartCall() {
+    if (this.length + this.openCallIds.size + 2 > this.maxCapacity) return false;
+    return this.ensureCapacity(this.length + 2);
+  }
+  notePlan(runtimePlanId) {
+    if (this.notedPlanSet.has(runtimePlanId)) return;
+    this.notedPlanSet.add(runtimePlanId);
+    this.notedPlanIds.push(runtimePlanId);
+  }
+  registerSuppression(group) {
+    if (group.storageIndex >= 0) return group;
+    group.storageIndex = this.suppressions.length;
+    this.suppressions.push(group);
+    return group;
+  }
+  startCall(runtimePlanId, callId, parentCallId, timestampNs, args) {
+    if (!this.write(
+      KIND_ENTER,
+      runtimePlanId,
+      callId,
+      parentCallId,
+      timestampNs,
+      0n,
+      args,
+      NO_SUPPRESSION
+    )) {
+      this.dropped += 2;
+      return;
+    }
+    this.openCallIds.add(callId);
+  }
+  finishCall(kind, callId, timestampNs, durationNs, payload) {
+    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;
+  }
+  appendSuppressed(group) {
+    if (this.length + this.openCallIds.size + 1 > this.maxCapacity) {
+      this.dropped++;
+      return false;
+    }
+    this.registerSuppression(group);
+    group.retainedIndex = this.length;
+    if (!this.write(
+      KIND_SUPPRESSED,
+      group.runtimePlanId,
+      0,
+      group.parentCallId,
+      0n,
+      0n,
+      void 0,
+      group.storageIndex
+    )) {
+      group.retainedIndex = -1;
+      this.dropped++;
+      return false;
+    }
+    return true;
+  }
+  forceCompletedCall(runtimePlanId, callId, parentCallId, enterTimestampNs, args, terminalKind, terminalTimestampNs, durationNs, payload) {
+    while (this.length + this.openCallIds.size + 2 > this.maxCapacity) {
+      if (!this.evictCompletedLeafOrSummary()) {
+        this.dropCall();
+        return false;
+      }
+    }
+    if (!this.ensureCapacity(this.length + 2)) {
+      this.dropCall();
+      return false;
+    }
+    this.write(
+      KIND_ENTER,
+      runtimePlanId,
+      callId,
+      parentCallId,
+      enterTimestampNs,
+      0n,
+      args,
+      NO_SUPPRESSION
+    );
+    this.write(
+      terminalKind,
+      0,
+      callId,
+      void 0,
+      terminalTimestampNs,
+      durationNs,
+      payload,
+      NO_SUPPRESSION
+    );
+    return true;
+  }
+  materialize(plansByRuntimeId, executionStartedAtNs) {
+    const events = [];
+    const referencedFunctionIds = /* @__PURE__ */ new Set();
+    for (let index = 0; index < this.length; index++) {
+      const event = this.eventAt(index, plansByRuntimeId, executionStartedAtNs);
+      if (!event) continue;
+      events.push(event);
+      if (event.type === "function_enter" || event.type === "function_calls_suppressed") {
+        referencedFunctionIds.add(event.functionId);
+      }
+    }
+    const functions = [];
+    const seenFunctionIds = /* @__PURE__ */ new Set();
+    for (const runtimePlanId of this.notedPlanIds) {
+      const definition = plansByRuntimeId[runtimePlanId]?.definition;
+      if (!definition || !referencedFunctionIds.has(definition.functionId)) continue;
+      if (seenFunctionIds.has(definition.functionId)) continue;
+      seenFunctionIds.add(definition.functionId);
+      functions.push(definition);
+    }
+    return { events, functions };
+  }
+  clear() {
+    this.length = 0;
+    this.dropped = 0;
+    this.onGrow = void 0;
+    this.openCallIds.clear();
+    this.notedPlanIds.length = 0;
+    this.notedPlanSet.clear();
+    for (let index = 0; index < this.payloads.length; index++) this.payloads[index] = void 0;
+    this.payloads.length = 0;
+    for (const group of this.suppressions) {
+      group.retainedIndex = -1;
+      group.storageIndex = -1;
+    }
+    this.suppressions.length = 0;
+  }
+  eventAt(index, plansByRuntimeId, executionStartedAtNs) {
+    const kind = this.kind[index];
+    if (kind === KIND_ENTER) {
+      const functionId = plansByRuntimeId[this.planId[index] ?? 0]?.functionId;
+      if (!functionId) return void 0;
+      const parentCallId = this.parentCallId[index] ?? NO_PARENT;
+      const payload = this.payloads[index];
+      return {
+        type: "function_enter",
+        callId: this.callId[index] ?? 0,
+        functionId,
+        timestampMs: relativeMs(this.timestampNs[index] ?? 0n),
+        args: Array.isArray(payload) ? payload : [],
+        ...parentCallId === NO_PARENT ? {} : { parentCallId }
+      };
+    }
+    if (kind === KIND_EXIT) {
+      return {
+        type: "function_exit",
+        callId: this.callId[index] ?? 0,
+        timestampMs: relativeMs(this.timestampNs[index] ?? 0n),
+        durationMs: relativeMs(this.durationNs[index] ?? 0n),
+        returnValue: this.payloads[index]
+      };
+    }
+    if (kind === KIND_THROW) {
+      return {
+        type: "function_throw",
+        callId: this.callId[index] ?? 0,
+        timestampMs: relativeMs(this.timestampNs[index] ?? 0n),
+        durationMs: relativeMs(this.durationNs[index] ?? 0n),
+        error: this.payloads[index]
+      };
+    }
+    if (kind === KIND_SUPPRESSED) {
+      const group = this.suppressions[this.suppressionIndex[index] ?? 0];
+      if (!group) return void 0;
+      return {
+        type: "function_calls_suppressed",
+        functionId: group.functionId,
+        timestampMs: elapsedMs(executionStartedAtNs, group.firstTimestampNs),
+        lastTimestampMs: elapsedMs(executionStartedAtNs, group.lastTimestampNs),
+        suppressedCallCount: group.count,
+        totalDurationMs: roundedMilliseconds(group.totalDurationNs),
+        ...group.parentCallId === void 0 ? {} : { parentCallId: group.parentCallId }
+      };
+    }
+    return void 0;
+  }
+  write(kind, runtimePlanId, callId, parentCallId, timestampNs, durationNs, payload, suppressionIndex) {
+    if (!this.ensureCapacity(this.length + 1)) return false;
+    const index = this.length;
+    this.kind[index] = kind;
+    this.planId[index] = runtimePlanId;
+    this.callId[index] = callId;
+    this.parentCallId[index] = parentCallId === void 0 ? NO_PARENT : parentCallId;
+    this.timestampNs[index] = timestampNs;
+    this.durationNs[index] = durationNs;
+    this.payloads[index] = payload;
+    this.suppressionIndex[index] = suppressionIndex;
+    this.length++;
+    return true;
+  }
+  ensureCapacity(needed) {
+    if (needed <= this.kind.length) return true;
+    if (needed > this.maxCapacity) return false;
+    let next = this.kind.length === 0 ? Math.min(INITIAL_JOURNAL_STORAGE, this.maxCapacity) : this.kind.length;
+    while (next < needed) {
+      const grown = Math.min(this.maxCapacity, next * 2);
+      if (grown <= next) return false;
+      next = grown;
+    }
+    const extraBytes = (next - this.kind.length) * BYTES_PER_EVENT;
+    if (this.onGrow && extraBytes > 0 && !this.onGrow(extraBytes)) return false;
+    this.reallocate(next);
+    return true;
+  }
+  reallocate(size) {
+    const nextKind = new Uint8Array(size);
+    const nextPlanId = new Uint32Array(size);
+    const nextCallId = new Uint32Array(size);
+    const nextParentCallId = new Uint32Array(size);
+    const nextTimestampNs = new BigInt64Array(size);
+    const nextDurationNs = new BigInt64Array(size);
+    const nextSuppressionIndex = new Uint32Array(size);
+    if (this.length > 0) {
+      nextKind.set(this.kind.subarray(0, this.length));
+      nextPlanId.set(this.planId.subarray(0, this.length));
+      nextCallId.set(this.callId.subarray(0, this.length));
+      nextParentCallId.set(this.parentCallId.subarray(0, this.length));
+      nextTimestampNs.set(this.timestampNs.subarray(0, this.length));
+      nextDurationNs.set(this.durationNs.subarray(0, this.length));
+      nextSuppressionIndex.set(this.suppressionIndex.subarray(0, this.length));
+    }
+    this.kind = nextKind;
+    this.planId = nextPlanId;
+    this.callId = nextCallId;
+    this.parentCallId = nextParentCallId;
+    this.timestampNs = nextTimestampNs;
+    this.durationNs = nextDurationNs;
+    this.suppressionIndex = nextSuppressionIndex;
+    this.allocatedBytes = size * BYTES_PER_EVENT;
+  }
+  evictCompletedLeafOrSummary() {
+    for (let index = 0; index < this.length; index++) {
+      if (this.kind[index] !== KIND_SUPPRESSED) continue;
+      const group = this.suppressions[this.suppressionIndex[index] ?? 0];
+      if (group) group.retainedIndex = -1;
+      this.removeAt(index);
+      this.dropped++;
+      return true;
+    }
+    const parentCallIds = /* @__PURE__ */ new Set();
+    for (let index = 0; index < this.length; index++) {
+      const kind = this.kind[index];
+      if (kind !== KIND_ENTER && kind !== KIND_SUPPRESSED) continue;
+      const parentCallId = this.parentCallId[index] ?? NO_PARENT;
+      if (parentCallId !== NO_PARENT) parentCallIds.add(parentCallId);
+    }
+    for (let index = 0; index < this.length; index++) {
+      if (this.kind[index] !== KIND_ENTER) continue;
+      const eventCallId = this.callId[index] ?? 0;
+      if (this.openCallIds.has(eventCallId) || parentCallIds.has(eventCallId)) continue;
+      let terminalIndex = -1;
+      for (let candidate = 0; candidate < this.length; candidate++) {
+        const kind = this.kind[candidate];
+        if ((kind === KIND_EXIT || kind === KIND_THROW) && this.callId[candidate] === eventCallId) {
+          terminalIndex = candidate;
+          break;
+        }
+      }
+      if (terminalIndex < 0) continue;
+      const later = Math.max(index, terminalIndex);
+      const earlier = Math.min(index, terminalIndex);
+      this.removeAt(later);
+      this.removeAt(earlier);
+      this.dropped += 2;
+      return true;
+    }
+    return false;
+  }
+  removeAt(index) {
+    this.payloads[index] = void 0;
+    const next = index + 1;
+    if (next < this.length) {
+      this.kind.copyWithin(index, next, this.length);
+      this.planId.copyWithin(index, next, this.length);
+      this.callId.copyWithin(index, next, this.length);
+      this.parentCallId.copyWithin(index, next, this.length);
+      this.timestampNs.copyWithin(index, next, this.length);
+      this.durationNs.copyWithin(index, next, this.length);
+      this.suppressionIndex.copyWithin(index, next, this.length);
+      this.payloads.copyWithin(index, next, this.length);
+    }
+    this.payloads[this.length - 1] = void 0;
+    this.length--;
+    this.payloads.length = this.length;
+    for (const group of this.suppressions) {
+      if (group.retainedIndex > index) group.retainedIndex--;
+    }
+  }
+};
+var ExecutionJournalPool = class {
+  constructor(capacity, maxPooled = MAX_POOLED_JOURNALS) {
+    this.capacity = capacity;
+    this.maxPooled = maxPooled;
+  }
+  hits = 0;
+  misses = 0;
+  available = [];
+  acquire() {
+    const pooled = this.available.pop();
+    if (pooled) {
+      this.hits++;
+      return pooled;
+    }
+    this.misses++;
+    return new ExecutionJournal(this.capacity);
+  }
+  release(journal) {
+    journal.clear();
+    if (this.available.length >= this.maxPooled || journal.capacity > MAX_POOLED_JOURNAL_CAPACITY || journal.capacity !== this.capacity) {
+      return;
+    }
+    this.available.push(journal);
+  }
+  stats() {
+    return {
+      journalPoolHits: this.hits,
+      journalPoolMisses: this.misses,
+      journalPoolSize: this.available.length,
+      journalAllocatedCapacity: this.capacity
+    };
+  }
+};
+
+// src/execution-recorder/recorder-memory-budget.ts
+var EXECUTION_BASE_ESTIMATED_BYTES = 1024;
+var SUMMARY_EVENT_BASE_ESTIMATED_BYTES = 256;
+var VALUE_HEAP_ESTIMATE_MULTIPLIER = 2;
+var MEMORY_BUDGET_VALUE_MARKER = {
+  __rasputin_type: "omitted",
+  __reason: "process_memory_budget"
+};
+var RecorderMemoryBudget = class {
+  constructor(maximumBytes, maximumSerializedValueBytes) {
+    this.maximumBytes = maximumBytes;
+    this.maximumSerializedValueBytes = maximumSerializedValueBytes;
+  }
+  activeEstimatedBytes = 0;
+  stats = {
+    activeEstimatedBytes: 0,
+    peakActiveEstimatedBytes: 0,
+    memoryPressureExecutions: 0,
+    memoryPressureDegradations: 0,
+    valuesDroppedByMemoryBudget: 0,
+    eventsDroppedByMemoryBudget: 0
+  };
+  startExecution() {
+    const allocation = {
+      mode: "full",
+      estimatedBytes: 0,
+      released: false,
+      underPressure: false,
+      valuesDropped: 0,
+      eventsDropped: 0
+    };
+    if (!this.reserve(allocation, EXECUTION_BASE_ESTIMATED_BYTES)) {
+      this.markPressure(allocation, "metadata-only");
+    }
+    return allocation;
+  }
+  captureValue(allocation, serialize) {
+    if (allocation.released) {
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    if (allocation.mode !== "full") {
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    const maximumEstimate = this.maximumSerializedValueBytes * VALUE_HEAP_ESTIMATE_MULTIPLIER;
+    if (this.activeEstimatedBytes + maximumEstimate > this.maximumBytes) {
+      this.markPressure(allocation, "structure-only");
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    const serialized = serialize();
+    if (!this.reserve(allocation, serialized.bytes * VALUE_HEAP_ESTIMATE_MULTIPLIER)) {
+      this.markPressure(allocation, "structure-only");
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    return serialized.value;
+  }
+  reserveCall(allocation, estimatedBytes) {
+    if (allocation.mode === "metadata-only") {
+      this.dropEvents(allocation, 2);
+      return false;
+    }
+    if (this.reserve(allocation, estimatedBytes)) return true;
+    this.markPressure(allocation, "metadata-only");
+    this.dropEvents(allocation, 2);
+    return false;
+  }
+  reserveStandaloneEvent(allocation) {
+    if (allocation.mode === "metadata-only") {
+      this.dropEvents(allocation, 1);
+      return false;
+    }
+    if (this.reserve(allocation, SUMMARY_EVENT_BASE_ESTIMATED_BYTES)) return true;
+    this.markPressure(allocation, "metadata-only");
+    this.dropEvents(allocation, 1);
+    return false;
+  }
+  reserveStorage(allocation, bytes) {
+    if (allocation.released || allocation.mode === "metadata-only") return false;
+    if (this.reserve(allocation, bytes)) return true;
+    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;
+    this.activeEstimatedBytes = Math.max(0, this.activeEstimatedBytes - allocation.estimatedBytes);
+    this.stats.activeEstimatedBytes = this.activeEstimatedBytes;
+  }
+  getStats() {
+    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;
+    allocation.estimatedBytes += boundedBytes;
+    this.stats.activeEstimatedBytes = this.activeEstimatedBytes;
+    this.stats.peakActiveEstimatedBytes = Math.max(
+      this.stats.peakActiveEstimatedBytes,
+      this.activeEstimatedBytes
+    );
+    return true;
+  }
+  markPressure(allocation, mode) {
+    if (!allocation.underPressure) {
+      allocation.underPressure = true;
+      this.stats.memoryPressureExecutions++;
+    }
+    if (allocation.mode === mode || allocation.mode === "metadata-only" && mode === "structure-only") {
+      return;
+    }
+    allocation.mode = mode;
+    this.stats.memoryPressureDegradations++;
+  }
+  dropValues(allocation, count) {
+    allocation.valuesDropped += count;
+    this.stats.valuesDroppedByMemoryBudget += count;
+  }
+  dropEvents(allocation, count) {
+    allocation.eventsDropped += count;
+    this.stats.eventsDroppedByMemoryBudget += count;
+  }
+};
+
+// src/execution-recorder/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";
+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,
+  maxArrayElements: 20,
+  maxStringLength: 500,
+  maxSerializedValueBytes: 8 * 1024
+};
+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 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 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 {
+    }
+  }
+  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;
+    }
+  }
+  return "Error";
+};
+var errorMessageOf = (value) => {
+  if (isDomException(value) && domExceptionMessageGet) {
+    try {
+      return domExceptionMessageGet.call(value);
+    } catch {
+    }
+  }
+  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;
+    }
+  } 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;
+    }
+    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;
+    }
+    if (!current) return false;
+    if (types.isProxy(current)) return true;
+  }
+  return true;
+};
+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);
+    }
+  } catch {
+    return { keys, truncated: keys.length >= maxKeys };
+  }
+  return { keys, truncated: false };
+};
+var bufferByteLength = (value) => {
+  try {
+    return Buffer2.byteLength(value);
+  } catch {
+    return 0;
+  }
+};
+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 === 45 || code === 46 || code === 95) continue;
+    compacted += code >= 65 && code <= 90 ? String.fromCharCode(code + 32) : key[index];
+  }
+  return compacted;
+};
+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;
+  }
+  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 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;
+  }
+  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 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 freezing = false;
+  const add = (metrics, count) => {
+    metrics.estimatedBytes += count;
+    if (metrics.estimatedBytes > limits.maxSerializedValueBytes) metrics.oversize = true;
+  };
+  const freezeInner = (value, depth, path, metrics) => {
+    if (metrics.oversize) return void 0;
+    metrics.visitedNodes++;
+    if (value === null) {
+      add(metrics, 4);
+      return null;
+    }
+    if (typeof value === "boolean") {
+      add(metrics, value ? 4 : 5);
+      return value;
+    }
+    if (typeof value === "number") {
+      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) {
+        add(metrics, stringEstimate(value));
+        return value;
+      }
+      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") {
+      add(metrics, NODE + 16);
+      return atom("undefined");
+    }
+    if (typeof value === "bigint") {
+      const text = value.toString();
+      add(metrics, NODE + stringEstimate(text));
+      return atom("bigint", { value: text });
+    }
+    if (typeof value === "symbol") {
+      const text = String(value);
+      add(metrics, NODE + stringEstimate(text));
+      return atom("symbol", { value: text });
+    }
+    if (typeof value === "function") {
+      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");
+    }
+    path.add(value);
+    try {
+      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 (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)) {
+        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 (types.isPromise(value)) {
+        add(metrics, NODE + 16);
+        return atom("Promise");
+      }
+      if (types.isMap(value)) {
+        add(metrics, NODE + 16);
+        const entries = [];
+        let counted2 = 0;
+        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++;
+        }
+        return atom("Map", {
+          entries,
+          ...size > limits.maxArrayElements ? { truncated: true, reason: "max_array_elements", originalLength: size } : {}
+        });
+      }
+      if (types.isSet(value)) {
+        add(metrics, NODE + 16);
+        const values = [];
+        let counted2 = 0;
+        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++;
+        }
+        return atom("Set", {
+          values,
+          ...size > limits.maxArrayElements ? { truncated: true, reason: "max_array_elements", originalLength: size } : {}
+        });
+      }
+      if (Array.isArray(value)) {
+        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 (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) {
+          add(metrics, NODE + 32);
+          items.push(
+            atom("truncated", {
+              reason: "max_array_elements",
+              originalLength: value.length
+            })
+          );
+        }
+        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 });
+      }
+      if (prototype && prototype !== Object.prototype) {
+        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 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 || metrics.oversize) continue;
+        add(metrics, stringEstimate(key));
+        if (keyIsRedacted(key, redactKeys) || key === "value" && pairIsSensitive) {
+          add(metrics, stringEstimate(REDACTED));
+          assignFrozenField(fields, key, REDACTED);
+          continue;
+        }
+        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 {
+          add(metrics, NODE + 16);
+          assignFrozenField(fields, key, atom("accessor"));
+        }
+      }
+      if (truncated) {
+        return atom("instance", {
+          type: typeName,
+          value: fields,
+          truncated: true,
+          reason: "max_object_keys"
+        });
+      }
+      if (typeName) return atom("instance", { type: typeName, value: fields });
+      return fields;
+    } catch (error) {
+      add(metrics, NODE + 32);
+      return atom("unserializable", {
+        value: error instanceof Error ? error.message : void 0
+      });
+    } finally {
+      path.delete(value);
+    }
+  };
+  const freeze = (value) => {
+    const metrics = { visitedNodes: 0, estimatedBytes: 0, oversize: false };
+    const reentrant = freezing;
+    const path = reentrant ? /* @__PURE__ */ new Set() : sharedPath;
+    if (!reentrant) {
+      freezing = true;
+      sharedPath.clear();
+    }
+    try {
+      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: frozen,
+        estimatedBytes: metrics.estimatedBytes,
+        visitedNodes: metrics.visitedNodes,
+        oversize: false
+      };
+    } catch {
+      return {
+        value: atom("unserializable"),
+        estimatedBytes: NODE + 16,
+        visitedNodes: Math.max(1, metrics.visitedNodes),
+        oversize: false
+      };
+    } finally {
+      path.clear();
+      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
+  };
+};
+var defaultSerializer = createSafeSerializer();
+
+// src/execution-recorder/source-exclusions.ts
+var sourcePathFrom = (definition) => definition.source?.packageRelativePath.replaceAll("\\", "/") ?? definition.name;
+var searchableIdentity = (definition) => {
+  const source = definition.source;
+  return source ? `${source.packageName ? `${source.packageName}:` : ""}${source.packageRelativePath}:${definition.name}@${source.line ?? ""}:${source.column ?? ""}` : definition.name;
+};
+var normalizePattern = (pattern) => pattern.trim().replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+var globRegex = (pattern) => {
+  let expression = "";
+  for (let index = 0; index < pattern.length; index++) {
+    const character = pattern[index];
+    const next = pattern[index + 1];
+    if (character === "*" && next === "*") {
+      if (pattern[index + 2] === "/") {
+        expression += "(?:.*/)?";
+        index += 2;
+      } else {
+        expression += ".*";
+        index++;
+      }
+      continue;
+    }
+    if (character === "*") {
+      expression += "[^/]*";
+      continue;
+    }
+    if (character === "?") {
+      expression += "[^/]";
+      continue;
+    }
+    expression += character?.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") ?? "";
+  }
+  return new RegExp(`^${expression}$`);
+};
+var createSourceExclusionMatcher = (exclusions) => {
+  const matchers = (exclusions ?? []).flatMap(
+    (exclusion) => {
+      if (exclusion instanceof RegExp) {
+        return [
+          (definition) => {
+            exclusion.lastIndex = 0;
+            const matched = exclusion.test(searchableIdentity(definition));
+            exclusion.lastIndex = 0;
+            return matched;
+          }
+        ];
+      }
+      const pattern = normalizePattern(exclusion);
+      if (!pattern) return [];
+      if (pattern.includes("*") || pattern.includes("?")) {
+        const regex = globRegex(pattern);
+        return [(definition) => regex.test(sourcePathFrom(definition))];
+      }
+      return [
+        (definition) => {
+          const sourcePath = sourcePathFrom(definition);
+          return sourcePath === pattern || sourcePath.startsWith(`${pattern}/`);
+        }
+      ];
+    }
+  );
+  return matchers.length === 0 ? () => false : (definition) => matchers.some((matcher) => matcher(definition));
+};
+
+// src/execution-recorder/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 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);
+  const named = located ? void 0 : /^(.+):([^:@]+)$/.exec(value);
+  const path = located?.[1] ?? named?.[1];
+  const name = located?.[2] ?? named?.[2] ?? value;
+  const source = path ? {
+    packageRelativePath: path.replaceAll("\\", "/").replace(/^\.\//, ""),
+    ...located?.[3] ? { line: Number(located[3]) } : {},
+    ...located?.[4] ? { column: Number(located[4]) } : {}
+  } : void 0;
+  const definition = { name, ...source ? { source } : {} };
+  return { ...definition, functionId: runtimeFunctionId2(definition) };
+};
+var normalizeFunctionDefinition = (value) => typeof value === "string" ? manualFunctionDefinition(value) : value;
+var 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 (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 notifyObserver = (observer, value) => {
+  try {
+    observer(value);
+  } catch {
+  }
+};
+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() - callbackEndedAtNs);
+  };
+  let result;
+  try {
+    result = callback();
+  } catch (error) {
+    notifyObserver(onThrow, error);
+    recordExitWork(phaseTimingEnabled ? process.hrtime.bigint() : recorderStartedAtNs);
+    throw error;
+  }
+  notifyObserver(onReturn, result);
+  recordExitWork(phaseTimingEnabled ? process.hrtime.bigint() : recorderStartedAtNs);
+  return result;
+};
+var emptyStats = {
+  functionCallsObserved: 0,
+  functionCallsCaptured: 0,
+  functionCallsExcluded: 0,
+  serializedValues: 0,
+  serializedValueNodes: 0,
+  serializedValueBytes: 0,
+  errorSnapshots: 0,
+  successfulExecutionsDiscarded: 0,
+  truncatedEvents: 0,
+  repeatedCallsSuppressed: 0,
+  activeExecutions: 0,
+  peakActiveExecutions: 0,
+  memoryPressureExecutions: 0,
+  memoryPressureDegradations: 0,
+  valuesDroppedByMemoryBudget: 0,
+  eventsDroppedByMemoryBudget: 0,
+  partialErrorSnapshots: 0,
+  measuredExecutions: 0,
+  totalInlineWallTimeMs: 0,
+  maxInlineWallTimeMs: 0,
+  activeEstimatedBytes: 0,
+  peakActiveEstimatedBytes: 0,
+  journalPoolHits: 0,
+  journalPoolMisses: 0,
+  journalPoolSize: 0,
+  journalAllocatedCapacity: 0,
+  attributionDegradations: 0
+};
+var noOpExecution = {
+  createScope: () => ({
+    run: (callback) => callback(),
+    getErrorState: () => void 0,
+    associateError: () => {
+    },
+    finish: () => {
+    }
+  }),
+  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 })
+};
+var mergeExecutionMetadata = (target, metadata) => {
+  if (metadata.kind) target.kind = metadata.kind;
+  if (metadata.name !== void 0) target.name = metadata.name;
+  if (metadata.request) target.request = { ...target.request, ...metadata.request };
+};
+var newRepeatedGroup = (plan) => ({
+  observedCalls: 0,
+  functionId: plan.functionId,
+  runtimePlanId: plan.runtimePlanId
+});
+var newSuppression = (group, parentCallId, startedAtNs, endedAtNs) => ({
+  count: 1,
+  firstTimestampNs: startedAtNs,
+  lastTimestampNs: endedAtNs,
+  totalDurationNs: endedAtNs - startedAtNs,
+  functionId: group.functionId,
+  runtimePlanId: group.runtimePlanId,
+  ...parentCallId === void 0 ? {} : { parentCallId },
+  storageIndex: -1,
+  retainedIndex: -1
+});
+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,
+    Math.floor(options.maxCapturedCallsPerFunction ?? 3)
+  );
+  const maxActiveMemoryBytes = Math.max(
+    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
+  );
+  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,
+    functionCallsCaptured: 0,
+    functionCallsExcluded: 0,
+    serializedValues: 0,
+    serializedValueNodes: 0,
+    serializedValueBytes: 0,
+    errorSnapshots: 0,
+    successfulExecutionsDiscarded: 0,
+    truncatedEvents: 0,
+    repeatedCallsSuppressed: 0,
+    activeExecutions: 0,
+    peakActiveExecutions: 0,
+    partialErrorSnapshots: 0,
+    measuredExecutions: 0,
+    totalInlineWallTimeMs: 0,
+    maxInlineWallTimeMs: 0,
+    attributionDegradations: 0
+  };
+  const addPhase = (key, nanoseconds) => {
+    if (phases && nanoseconds > 0n) phases[key] += nanoseconds;
+  };
+  const recordInlineTiming = (recording) => {
+    const inlineWallTimeMs = roundedMilliseconds2(recording.inlineRecorderTimeNs);
+    stats.measuredExecutions++;
+    stats.totalInlineWallTimeMs = Math.round((stats.totalInlineWallTimeMs + inlineWallTimeMs) * 1e4) / 1e4;
+    stats.maxInlineWallTimeMs = Math.max(stats.maxInlineWallTimeMs, inlineWallTimeMs);
+  };
+  const freezeAndCount = (value) => {
+    const frozen = serializer.freeze(value);
+    stats.serializedValues++;
+    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 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;
+  };
+  const preparePlan = (definition) => {
+    const existing = internedPlans.get(definition.functionId);
+    if (existing) return existing;
+    const plan = storePlan({
+      runtimePlanId: nextRuntimePlanId++,
+      definition,
+      functionId: definition.functionId,
+      excluded: excludesSource(definition),
+      estimatedCallBytes: estimatedCallBytesFor(definition.functionId),
+      omitCallValues: false
+    });
+    internedPlans.set(definition.functionId, plan);
+    return plan;
+  };
+  const preparedPlansFor = (plans) => {
+    const cached = preparedModules.get(plans);
+    if (cached) return cached;
+    const prepared = plans.map((encoded) => {
+      const definition = definitionFromEncodedPlan(encoded);
+      return storePlan({
+        runtimePlanId: nextRuntimePlanId++,
+        definition,
+        functionId: definition.functionId,
+        excluded: excludesSource(definition),
+        estimatedCallBytes: estimatedCallBytesFor(definition.functionId),
+        omitCallValues: encodedPlanOmitsCallValues(encoded)
+      });
+    });
+    preparedModules.set(plans, prepared);
+    return prepared;
+  };
+  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;
+      }
+    }
+    return false;
+  };
+  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;
+    if (recording.cachedState) {
+      events = recording.cachedState.events;
+      functions = recording.cachedState.functions;
+      truncated = recording.cachedState.truncated;
+      capture = recording.cachedState.capture;
+    } else {
+      if (recording.journal) {
+        const materialized = recording.journal.materialize(plansByRuntimeId, recording.startedAtNs);
+        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;
+      }
+      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 };
+        journalPool.release(recording.journal);
+        recording.journal = void 0;
+      }
+    }
+    const state = {
+      version: 4,
+      captureProfile: resolveCaptureProfile(recording, events, truncated, capture),
+      executionId: recording.executionId,
+      startedAt: recording.startedAt,
+      durationMs: elapsedMs2(recording.startedAtNs, endedAtNs),
+      recorder: { inlineWallTimeMs: 0 },
+      execution: {
+        ...recording.execution,
+        ...recording.execution.request ? { request: { ...recording.execution.request } } : {}
+      },
+      functions: functions.slice(),
+      events: events.slice(),
+      ...truncated ? { truncated: { ...truncated } } : {},
+      ...capture ? { capture: { ...capture } } : {}
+    };
+    if (phaseTimingEnabled)
+      addPhase("materializeNs", process.hrtime.bigint() - recorderStartedAtNs);
+    const sizeBudgetStartedAtNs = process.hrtime.bigint();
+    addRecorderTime(recording, sizeBudgetStartedAtNs - recorderStartedAtNs);
+    state.recorder = {
+      inlineWallTimeMs: roundedMilliseconds2(recording.inlineRecorderTimeNs)
+    };
+    const boundedState = enforceRuntimeStateSizeBudget(state, runtimeStateSizeBudget);
+    addRecorderTime(recording, process.hrtime.bigint() - sizeBudgetStartedAtNs);
+    boundedState.recorder = {
+      inlineWallTimeMs: roundedMilliseconds2(recording.inlineRecorderTimeNs)
+    };
+    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;
+    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(key, recording);
+  };
+  const countDroppedEvents = (recording, droppedBefore) => {
+    const dropped = recording.journal?.dropped ?? droppedBefore;
+    stats.truncatedEvents += dropped - droppedBefore;
+  };
+  const appendSuppressedPlaceholder = (recording, group) => {
+    if (!recording.journal) return;
+    if (!memoryBudget.reserveStandaloneEvent(recording.memory)) return;
+    const droppedBefore = recording.journal.dropped;
+    recording.journal.appendSuppressed(group);
+    countDroppedEvents(recording, droppedBefore);
+  };
+  const repeatedCallGroup = (recording, plan, parentCallId) => {
+    const slots = recording.repeatedCalls;
+    let slot = slots[plan.runtimePlanId];
+    if (!slot) {
+      slot = {};
+      slots[plan.runtimePlanId] = slot;
+    }
+    if (parentCallId === void 0) {
+      if (!slot.root) slot.root = newRepeatedGroup(plan);
+      return slot.root;
+    }
+    if (slot.lastParentGroup && slot.lastParentCallId === parentCallId) {
+      return slot.lastParentGroup;
+    }
+    if (!slot.byParent) slot.byParent = /* @__PURE__ */ new Map();
+    let group = slot.byParent.get(parentCallId);
+    if (!group) {
+      group = newRepeatedGroup(plan);
+      slot.byParent.set(parentCallId, group);
+    }
+    slot.lastParentCallId = parentCallId;
+    slot.lastParentGroup = group;
+    return group;
+  };
+  const serializedError = (recording, error, callId) => {
+    const key = (typeof error === "object" || typeof error === "function") && error !== null ? error : void 0;
+    const referencedCallId = key ? recording.capturedErrors.get(key) : void 0;
+    if (referencedCallId !== void 0) {
+      return {
+        value: { __rasputin_type: "ErrorReference", callId: referencedCallId },
+        commit: () => {
+        }
+      };
+    }
+    return {
+      // Keep the bounded thrown value even after surrounding capture degrades. A partial
+      // snapshot without the exception itself would not be useful for investigation.
+      value: (() => {
+        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, capturedArgs) => {
+    if (!recording.journal) {
+      rememberError(error, recording);
+      return;
+    }
+    if (!memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes)) {
+      rememberError(error, recording);
+      return;
+    }
+    const callId = ++recording.nextCallId;
+    const capturedError = serializedError(recording, error, callId);
+    const recordedArgs = capturedArgs ?? mapArrayLike(args, (argument) => captureValue(recording, argument));
+    const endedAtNs = process.hrtime.bigint();
+    const droppedBefore = recording.journal.dropped;
+    const retained = recording.journal.forceCompletedCall(
+      plan.runtimePlanId,
+      callId,
+      parentCallId,
+      startedAtNs - recording.startedAtNs,
+      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();
+    }
+    countDroppedEvents(recording, droppedBefore);
+    rememberError(error, recording);
+  };
+  const recordSuppressedCall = (recording, group, parentCallId, startedAtNs, endedAtNs) => {
+    stats.repeatedCallsSuppressed++;
+    if (!group.suppressed) {
+      group.suppressed = newSuppression(group, parentCallId, startedAtNs, endedAtNs);
+      appendSuppressedPlaceholder(recording, group.suppressed);
+      return;
+    }
+    const suppressed = group.suppressed;
+    suppressed.count++;
+    suppressed.lastTimestampNs = endedAtNs;
+    suppressed.totalDurationNs += endedAtNs - startedAtNs;
+    if (suppressed.retainedIndex < 0) {
+      appendSuppressedPlaceholder(recording, suppressed);
+    }
+  };
+  const releaseJournalIfIdle = (recording) => {
+    if (!recording.finished || recording.hasError || recording.inFlightCalls > 0) return;
+    if (!recording.journal) return;
+    journalPool.release(recording.journal);
+    recording.journal = void 0;
+  };
+  const acquireJournal = (recording) => {
+    if (recording.journal) return recording.journal;
+    try {
+      const journal = journalPool.acquire();
+      if (!memoryBudget.reserveStorage(recording.memory, journal.allocatedBytes)) {
+        journalPool.release(journal);
+        return void 0;
+      }
+      journal.onGrow = (deltaBytes) => memoryBudget.reserveStorage(recording.memory, deltaBytes);
+      recording.journal = journal;
+      return journal;
+    } catch {
+      return void 0;
+    }
+  };
+  const settleInFlight = (recording) => {
+    if (recording.inFlightCalls > 0) recording.inFlightCalls--;
+    releaseWhenIdle(recording);
+  };
+  const releaseWhenIdle = (recording) => {
+    try {
+      if (!recording.finished || recording.inFlightCalls > 0) return;
+      memoryBudget.release(recording.memory);
+      releaseJournalIfIdle(recording);
+    } catch {
+    }
+  };
+  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, function __rasputinHandleRun__4() {
+      addPhase("alsNs", process.hrtime.bigint() - alsStartedAtNs);
+      return callback();
+    });
+  };
+  const createScope = (metadata) => {
+    try {
+      const recorderStartedAtNs = process.hrtime.bigint();
+      sweepLongLivedExecutions(recorderStartedAtNs);
+      const recording = {
+        executionId: `${Date.now()}-${process.pid}-${++executionCounter}`,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        startedAtNs: recorderStartedAtNs,
+        inlineRecorderTimeNs: 0n,
+        execution: {
+          ...metadata,
+          ...metadata.request ? { request: { ...metadata.request } } : {}
+        },
+        journal: void 0,
+        repeatedCalls: [],
+        capturedErrors: /* @__PURE__ */ new WeakMap(),
+        nextCallId: 0,
+        inFlightCalls: 0,
+        finished: false,
+        hasError: false,
+        memory: memoryBudget.startExecution(),
+        partialSnapshotCounted: false,
+        sawAutomatic: false,
+        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: 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) => {
+          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)
+      };
+    } catch {
+      return noOpExecution.createScope(metadata);
+    }
+  };
+  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) ?? currentStore()?.recording;
+      if (!recording) return void 0;
+      if (metadata) mergeExecutionMetadata(recording.execution, metadata);
+      rememberError(error, recording);
+      addRecorderTime(recording, process.hrtime.bigint() - getStateStartedAtNs);
+      return stateFrom(recording, recording.finishedAtNs);
+    } catch {
+      return void 0;
+    }
+  };
+  const 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 }, function __rasputinHandleRun__4() {
+        addRecorderTime(store.recording, process.hrtime.bigint() - recorderStartedAtNs);
+        return callback();
+      });
+    }
+    const recording = store.recording;
+    recording.inFlightCalls++;
+    const parentCallId = store.currentCallId;
+    const group = repeatedCallGroup(recording, plan, parentCallId);
+    group.observedCalls++;
+    const journal = acquireJournal(recording);
+    try {
+      if (group.observedCalls === 1) journal?.notePlan(plan.runtimePlanId);
+    } catch {
+    }
+    if (group.observedCalls > maxCapturedCallsPerFunction) {
+      const startedAtNs2 = process.hrtime.bigint();
+      try {
+        const result = runStore(store, function __rasputinHandleRun__4() {
+          return callback();
+        });
+        recordSuppressedCall(recording, group, parentCallId, startedAtNs2, process.hrtime.bigint());
+        settleInFlight(recording);
+        return result;
+      } catch (error) {
+        captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs2, error);
+        settleInFlight(recording);
+        throw error;
+      }
+    }
+    const startedAtNs = process.hrtime.bigint();
+    if (!journal) {
+      memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes);
+      return runStore(store, function __rasputinHandleRun__4() {
+        return observeRecordedCallback(
+          recording,
+          recorderStartedAtNs,
+          callback,
+          () => settleInFlight(recording),
+          (error) => {
+            rememberError(error, recording);
+            settleInFlight(recording);
+          }
+        );
+      });
+    }
+    if (!journal.canStartCall()) {
+      const captureSuccess = () => {
+        const droppedBefore = recording.journal?.dropped ?? 0;
+        recording.journal?.dropCall();
+        countDroppedEvents(recording, droppedBefore);
+        settleInFlight(recording);
+      };
+      return runStore(store, function __rasputinHandleRun__4() {
+        return observeRecordedCallback(
+          recording,
+          recorderStartedAtNs,
+          callback,
+          captureSuccess,
+          (error) => {
+            captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs, error);
+            settleInFlight(recording);
+          }
+        );
+      });
+    }
+    if (!memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes)) {
+      return observeRecordedCallback(
+        recording,
+        recorderStartedAtNs,
+        callback,
+        () => settleInFlight(recording),
+        (error) => {
+          rememberError(error, recording);
+          settleInFlight(recording);
+        }
+      );
+    }
+    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 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, function __rasputinHandleRun__4() {
+      return observeRecordedCallback(
+        recording,
+        recorderStartedAtNs,
+        callback,
+        (value) => {
+          if (recording.journal) {
+            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++;
+          }
+          settleInFlight(recording);
+        },
+        (error) => {
+          if (!recording.journal) {
+            rememberError(error, recording);
+            settleInFlight(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);
+          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 = currentStore();
+    if (store && !store.recording.finished) store.recording.sawManual = true;
+    return runPreparedFunctionFromStore(
+      store,
+      preparePlan(normalizeFunctionDefinition(input)),
+      args,
+      callback
+    );
+  };
+  const runFunctionPlans = (plans, planIndex, args, callback, omitValues) => {
+    const store = currentStore();
+    const plan = preparedPlansFor(plans)[planIndex];
+    if (store && !store.recording.finished && !store.recording.sawAutomatic) {
+      store.recording.sawAutomatic = true;
+    }
+    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 __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 runPreparedFunctionFromStore(store, plan, args, function __rasputinHandleRun__4() {
+        return fn.apply(receiver, args);
+      });
+    };
+  }
+  return {
+    createScope,
+    getErrorState,
+    runFunction,
+    runFunctionPlans,
+    prepareFunctionPlans,
+    runPreparedFunction,
+    enterPreparedFunction,
+    trace,
+    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.v3";
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+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 = 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: passthroughRun, enter: passthroughEnter };
+  const module = { plans, cell };
+  registry.modules.push(module);
+  registry.runtimes.at(-1)?.bind(module);
+  return attachRunner(cell);
+};
+var createRegistry = () => {
+  const registry = {
+    runtimes: [],
+    modules: [],
+    register(plans) {
+      return registerModule(registry, plans);
+    }
+  };
+  return registry;
+};
+var getAutomaticRuntimeRegistry = () => {
+  const existing = Reflect.get(globalThis, runtimeSymbol);
+  if (existing && typeof existing === "object" && isRegistry(existing)) {
+    return existing;
+  }
+  const registry = createRegistry();
+  Reflect.set(globalThis, runtimeSymbol, registry);
+  return registry;
+};
+var installAutomaticExecutionRuntime = (execution) => {
+  const registry = getAutomaticRuntimeRegistry();
+  const runtime = {
+    bind(module) {
+      bindExecution(execution, module);
+    }
+  };
+  registry.runtimes.push(runtime);
+  for (const module of registry.modules) runtime.bind(module);
+  return () => {
+    const index = registry.runtimes.lastIndexOf(runtime);
+    if (index >= 0) registry.runtimes.splice(index, 1);
+    const current = registry.runtimes.at(-1);
+    for (const module of registry.modules) {
+      if (current) current.bind(module);
+      else bindPassthrough(module);
+    }
+  };
+};
+
+// src/install-global-handlers.ts
+var 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 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 {
+      entry.client.captureException(error);
+    } catch {
+    }
+  }
+};
+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) {
+      if (exitOnUncaught && hostListenerCount("uncaughtException") === 0) {
+        process.exit(1);
+      }
+      return;
+    }
+    handlingUncaught = true;
+    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 flushAll(flushTimeoutMs);
+      } catch {
+      }
+      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);
+    if (!unhandledRejectionIsFatal()) {
+      process.on("unhandledRejection", onUnhandledRejection);
+    }
+  } catch {
+    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?.();
+  };
+};
+export {
+  createExecutionRecorder,
+  installAutomaticExecutionRuntime,
+  installGlobalHandlers,
+  scheduleInstrumentationManifestUpload
+};