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

package/dist/index.js

@@ -104,76 +104,38 @@ var runtimeLabel = () => {
 
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
 import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
 import {
   INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
   sourceLocatorFromFile as sourceLocatorFromFile2
 } from "@rasputin-ai/core";
 
-// src/execution-recorder/automatic-runtime.ts
+// src/execution-recorder/function-plan.ts
 import {
   runtimeFunctionId,
   sourceLocatorFromFile
 } from "@rasputin-ai/core";
-var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
-var AUTOMATIC_SOURCE_PREFIX = "rasputin-source-v2:";
-var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
-var decodeAutomaticFunctionSource = (sourceToken) => {
-  if (!sourceToken.startsWith(AUTOMATIC_SOURCE_PREFIX)) return void 0;
-  try {
-    const parsed = JSON.parse(
-      sourceToken.slice(AUTOMATIC_SOURCE_PREFIX.length)
-    );
-    if (typeof parsed.name !== "string" || !parsed.name) return void 0;
-    const definition = {
-      name: parsed.name,
-      ...parsed.source ? { source: parsed.source } : {}
-    };
-    return { ...definition, functionId: runtimeFunctionId(definition) };
-  } catch {
-    return void 0;
-  }
-};
-var getRegistry = () => {
-  const existing = Reflect.get(globalThis, runtimeSymbol);
-  if (existing?.__rasputinRuntimeRegistry && Array.isArray(existing.runtimes)) {
-    return existing;
-  }
-  const runtimes = [];
-  const registry = {
-    __rasputinRuntimeRegistry: true,
-    runtimes,
-    run: (sourceToken, args, callback) => {
-      const runtime = runtimes.at(-1);
-      return runtime ? runtime.run(sourceToken, args, callback) : callback();
-    }
-  };
-  Reflect.set(globalThis, runtimeSymbol, registry);
-  return registry;
-};
-var installAutomaticExecutionRuntime = (execution) => {
-  const registry = getRegistry();
-  const definitions = /* @__PURE__ */ new Map();
-  const runtime = {
-    run: (sourceToken, args, callback) => {
-      let definition = definitions.get(sourceToken);
-      if (!definitions.has(sourceToken)) {
-        definition = decodeAutomaticFunctionSource(sourceToken);
-        definitions.set(sourceToken, definition);
-      }
-      return definition ? execution.runFunction(definition, args, callback) : callback();
-    }
-  };
-  registry.runtimes.push(runtime);
-  return () => {
-    const index = registry.runtimes.lastIndexOf(runtime);
-    if (index >= 0) registry.runtimes.splice(index, 1);
+var EVENT_PAIR_BASE_ESTIMATED_BYTES = 512;
+var definitionFromEncodedPlan = (plan) => {
+  const [functionId, name, packageName, packageRelativePath, line, column] = plan;
+  const source = packageRelativePath ? {
+    ...packageName ? { packageName } : {},
+    packageRelativePath,
+    ...line == null ? {} : { line },
+    ...column == null ? {} : { column }
+  } : void 0;
+  return {
+    functionId,
+    name,
+    ...source ? { source } : {}
   };
 };
+var estimatedCallBytesFor = (functionId) => EVENT_PAIR_BASE_ESTIMATED_BYTES + Buffer.byteLength(functionId, "utf8") * 2;
 
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
-var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v2";
+var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v3";
 var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
-var getRegistry2 = () => {
+var getRegistry = () => {
   const existing = Reflect.get(globalThis, registrySymbol);
   if (existing?.__rasputinManifestRegistry && existing.files instanceof Map && typeof existing.generation === "number" && typeof existing.uploadedGeneration === "number") {
     return existing;
@@ -192,20 +154,47 @@ var sourceAt = (filePath, line, column) => {
   return source ? { ...source, line, column } : void 0;
 };
 var stableId = (kind, ...parts) => `${kind}_${createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 24)}`;
+var recordPrebuiltInstrumentationManifest = (manifest) => {
+  const registry = getRegistry();
+  registry.prebuilt = manifest;
+  registry.generation += 1;
+  registry.onDirty?.();
+};
+var loadInstrumentationManifestFile = (path) => {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.schema_version !== INSTRUMENTATION_MANIFEST_SCHEMA_VERSION) return false;
+    if (!Array.isArray(parsed.functions)) return false;
+    recordPrebuiltInstrumentationManifest(parsed);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var loadInstrumentationManifestIfPresent = (path) => {
+  if (!path || !existsSync(path)) return;
+  loadInstrumentationManifestFile(path);
+};
 var isInstrumentationManifestDirty = () => {
-  const registry = getRegistry2();
-  return registry.generation !== registry.uploadedGeneration && registry.files.size > 0;
+  const registry = getRegistry();
+  return registry.generation !== registry.uploadedGeneration && (registry.files.size > 0 || registry.prebuilt !== void 0);
+};
+var instrumentationManifestGeneration = () => getRegistry().generation;
+var instrumentationManifestModuleCount = () => {
+  const registry = getRegistry();
+  if (registry.files.size > 0) return registry.files.size;
+  if (!registry.prebuilt) return 0;
+  return new Set(registry.prebuilt.functions.map((fn) => fn.source.packageRelativePath)).size;
 };
-var instrumentationManifestGeneration = () => getRegistry2().generation;
-var instrumentationManifestModuleCount = () => getRegistry2().files.size;
 var snapshotInstrumentationManifest = (options = {}) => {
   const functions = [];
   const callSites = [];
   const destructures = [];
-  for (const delta of getRegistry2().files.values()) {
+  const derivationPlans = [];
+  for (const delta of getRegistry().files.values()) {
     for (const fn of delta.functions) {
-      const definition = decodeAutomaticFunctionSource(fn.sourceToken);
-      if (!definition?.source) continue;
+      const definition = definitionFromEncodedPlan(fn.plan);
+      if (!definition.source) continue;
       functions.push({
         functionId: definition.functionId,
         source: definition.source,
@@ -218,19 +207,18 @@ var snapshotInstrumentationManifest = (options = {}) => {
       });
     }
     for (const site of delta.callSites) {
-      const caller = decodeAutomaticFunctionSource(site.callerSourceToken);
       const source = sourceAt(site.filePath, site.line, site.column);
-      if (!caller || !source) continue;
+      if (!source) continue;
       callSites.push({
         id: stableId(
           "cs",
-          caller.functionId,
+          site.callerFunctionId,
           source.packageName ?? "",
           source.packageRelativePath,
           site.line,
           site.column
         ),
-        callerFunctionId: caller.functionId,
+        callerFunctionId: site.callerFunctionId,
         calleeName: site.calleeName,
         calleeText: site.calleeText,
         source,
@@ -243,11 +231,10 @@ var snapshotInstrumentationManifest = (options = {}) => {
       });
     }
     for (const destructure of delta.destructures) {
-      const caller = decodeAutomaticFunctionSource(destructure.callerSourceToken);
       const source = sourceAt(destructure.filePath, destructure.line, destructure.column);
-      if (!caller || !source) continue;
+      if (!source) continue;
       destructures.push({
-        callerFunctionId: caller.functionId,
+        callerFunctionId: destructure.callerFunctionId,
         sourceParam: destructure.sourceParam,
         source,
         line: destructure.line,
@@ -255,6 +242,19 @@ var snapshotInstrumentationManifest = (options = {}) => {
         binding: destructure.binding
       });
     }
+    derivationPlans.push(...delta.derivationPlans ?? []);
+  }
+  const registry = getRegistry();
+  if (registry.prebuilt && registry.files.size === 0) {
+    const prebuilt = registry.prebuilt;
+    if (!options.sourceRoot && !options.sourceRoots) return prebuilt;
+    return {
+      ...prebuilt,
+      sourceRoots: {
+        ...options.sourceRoot ? { default: options.sourceRoot } : {},
+        packages: { ...options.sourceRoots ?? {} }
+      }
+    };
   }
   if (functions.length === 0 && callSites.length === 0 && destructures.length === 0) {
     return void 0;
@@ -270,15 +270,16 @@ var snapshotInstrumentationManifest = (options = {}) => {
     } : {},
     functions,
     callSites,
-    destructures
+    destructures,
+    derivationPlans
   };
 };
 var markInstrumentationManifestUploaded = (generation) => {
-  const registry = getRegistry2();
+  const registry = getRegistry();
   if (registry.generation === generation) registry.uploadedGeneration = generation;
 };
 var setInstrumentationManifestOnDirty = (onDirty) => {
-  getRegistry2().onDirty = onDirty;
+  getRegistry().onDirty = onDirty;
 };
 
 // src/auto-instrumentation/schedule-instrumentation-manifest-upload.ts
@@ -386,92 +387,397 @@ var scheduleInstrumentationManifestUpload = (options) => {
 
 // src/execution-recorder/execution-recorder.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import { runtimeFunctionId as runtimeFunctionId2 } from "@rasputin-ai/core";
+import {
+  capturedValueCompleteness,
+  hashInstrumentationManifest,
+  rasputinOmitted,
+  rasputinTagKind,
+  runtimeFunctionId as runtimeFunctionId2
+} from "@rasputin-ai/core";
 
-// src/execution-recorder/call-aware-event-buffer.ts
-var CallAwareEventBuffer = class {
+// 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.capacity = 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;
   }
-  items = [];
-  openCallIds = /* @__PURE__ */ new Set();
-  dropped = 0;
   canStartCall() {
-    return this.items.length + this.openCallIds.size + 2 <= this.capacity;
+    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);
   }
-  startCall(event) {
-    this.items.push(event);
-    this.openCallIds.add(event.callId);
+  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
+    )) {
+      return;
+    }
+    this.openCallIds.add(callId);
   }
-  finishCall(event) {
-    if (event.type !== "function_exit" && event.type !== "function_throw") return;
-    if (!this.openCallIds.delete(event.callId)) return;
-    this.items.push(event);
+  finishCall(kind, callId, timestampNs, durationNs, payload) {
+    if (!this.openCallIds.delete(callId)) return;
+    this.write(kind, 0, callId, void 0, timestampNs, durationNs, payload, NO_SUPPRESSION);
   }
   dropCall() {
     this.dropped += 2;
   }
-  append(event) {
-    if (this.items.length + this.openCallIds.size + 1 > this.capacity) {
+  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;
     }
-    this.items.push(event);
     return true;
   }
-  forceCompletedCall(enter, terminal) {
-    while (this.items.length + this.openCallIds.size + 2 > this.capacity) {
+  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;
       }
     }
-    this.items.push(enter, terminal);
+    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;
   }
-  values() {
-    return [...this.items];
+  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;
   }
-  contains(target) {
-    return this.items.includes(target);
+  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() {
-    const summaryIndex = this.items.findIndex(
-      (event) => event.type === "function_calls_suppressed"
-    );
-    if (summaryIndex >= 0) {
-      this.items.splice(summaryIndex, 1);
+    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 (const event of this.items) {
-      if ((event.type === "function_enter" || event.type === "function_calls_suppressed") && event.parentCallId !== void 0) {
-        parentCallIds.add(event.parentCallId);
-      }
+    for (let index = 0; index < this.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.items.length; index++) {
-      const event = this.items[index];
-      if (event?.type !== "function_enter" || this.openCallIds.has(event.callId) || parentCallIds.has(event.callId)) {
-        continue;
+    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;
+        }
       }
-      const terminalIndex = this.items.findIndex(
-        (candidate) => (candidate.type === "function_exit" || candidate.type === "function_throw") && candidate.callId === event.callId
-      );
       if (terminalIndex < 0) continue;
-      this.items.splice(Math.max(index, terminalIndex), 1);
-      this.items.splice(Math.min(index, terminalIndex), 1);
+      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
-import { Buffer } from "node:buffer";
 var EXECUTION_BASE_ESTIMATED_BYTES = 1024;
-var EVENT_PAIR_BASE_ESTIMATED_BYTES = 512;
 var SUMMARY_EVENT_BASE_ESTIMATED_BYTES = 256;
 var VALUE_HEAP_ESTIMATE_MULTIPLIER = 2;
 var MEMORY_BUDGET_VALUE_MARKER = {
@@ -525,12 +831,11 @@ var RecorderMemoryBudget = class {
     }
     return serialized.value;
   }
-  reserveCall(allocation, functionId) {
+  reserveCall(allocation, estimatedBytes) {
     if (allocation.mode === "metadata-only") {
       this.dropEvents(allocation, 2);
       return false;
     }
-    const estimatedBytes = EVENT_PAIR_BASE_ESTIMATED_BYTES + Buffer.byteLength(functionId, "utf8") * 2;
     if (this.reserve(allocation, estimatedBytes)) return true;
     this.markPressure(allocation, "metadata-only");
     this.dropEvents(allocation, 2);
@@ -546,6 +851,12 @@ var RecorderMemoryBudget = class {
     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;
+  }
   release(allocation) {
     if (allocation.released) return;
     allocation.released = true;
@@ -590,7 +901,7 @@ var RecorderMemoryBudget = class {
 
 // src/execution-recorder/safe-serialize.ts
 import { Buffer as Buffer2 } from "node:buffer";
-var DEFAULT_REDACT_KEYS = /* @__PURE__ */ new Set([
+var DEFAULT_REDACT_KEYS = [
   "password",
   "token",
   "authorization",
@@ -598,7 +909,7 @@ var DEFAULT_REDACT_KEYS = /* @__PURE__ */ new Set([
   "secret",
   "apikey",
   "creditcard"
-]);
+];
 var defaults = {
   maxDepth: 3,
   maxObjectKeys: 30,
@@ -606,6 +917,7 @@ var defaults = {
   maxStringLength: 500,
   maxSerializedValueBytes: 8 * 1024
 };
+var REDACTED = "[RASPUTIN_REDACTED]";
 var truncation = (reason, extra = {}) => ({
   __rasputin_truncated: true,
   __reason: reason,
@@ -615,135 +927,436 @@ var typeMarker = (type, value) => ({
   __rasputin_type: type,
   ...value === void 0 ? {} : { value }
 });
-var redact = (item, redactKeys, seen) => {
-  if (!item || typeof item !== "object") return item;
-  if (seen.has(item)) return item;
-  seen.add(item);
-  if (Array.isArray(item)) {
-    return item.map((entry) => redact(entry, redactKeys, seen));
+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;
   }
-  for (const [key, child] of Object.entries(item)) {
-    item[key] = redactKeys.has(key.toLowerCase()) ? "[RASPUTIN_REDACTED]" : redact(child, redactKeys, seen);
+  return bytes;
+};
+var jsonLiteralUtf8Bytes = (value) => {
+  if (value === null) return 4;
+  switch (typeof value) {
+    case "boolean":
+      return value ? 4 : 5;
+    case "number":
+      if (!Number.isFinite(value)) return 4;
+      if (Object.is(value, -0)) return 1;
+      return String(value).length;
+    case "string":
+      return jsonStringUtf8Bytes(value);
+    case "object": {
+      if (Array.isArray(value)) {
+        let bytes2 = 2;
+        for (let index = 0; index < value.length; index++) {
+          if (index > 0) bytes2 += 1;
+          bytes2 += jsonLiteralUtf8Bytes(value[index]);
+        }
+        return bytes2;
+      }
+      const record = value;
+      let bytes = 2;
+      let first = true;
+      for (const key of Object.keys(record)) {
+        if (!first) bytes += 1;
+        first = false;
+        bytes += jsonStringUtf8Bytes(key) + 1;
+        bytes += jsonLiteralUtf8Bytes(record[key]);
+      }
+      return bytes;
+    }
+    default:
+      return Buffer2.byteLength(JSON.stringify(value) ?? "null", "utf8");
   }
-  return item;
 };
-var errorValue = (error, depth, seen, limits) => ({
-  __rasputin_type: "Error",
-  name: error.name,
-  message: serializeInner(error.message, depth + 1, seen, limits),
-  ...error.stack ? { stack: serializeInner(error.stack, depth + 1, seen, limits) } : {}
+var compileLimits = (options) => ({
+  maxDepth: options.maxDepth ?? defaults.maxDepth,
+  maxObjectKeys: options.maxObjectKeys ?? defaults.maxObjectKeys,
+  maxArrayElements: options.maxArrayElements ?? defaults.maxArrayElements,
+  maxStringLength: options.maxStringLength ?? defaults.maxStringLength,
+  maxSerializedValueBytes: options.maxSerializedValueBytes ?? defaults.maxSerializedValueBytes
 });
-var serializeInner = (value, depth, seen, limits) => {
-  if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+var compileRedactKeys = (options) => {
+  if (!options.redactKeys?.length) return new Set(DEFAULT_REDACT_KEYS);
+  return /* @__PURE__ */ new Set([...DEFAULT_REDACT_KEYS, ...options.redactKeys.map((key) => key.toLowerCase())]);
+};
+var keyNeedsCaseFold = (key) => {
+  for (let index = 0; index < key.length; index++) {
+    const code = key.charCodeAt(index);
+    if (code > 127 || code >= 65 && code <= 90) return true;
+  }
+  return false;
+};
+var isJsonSafeString = (value) => {
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 32 || code === 34 || code === 92) return false;
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (index + 1 >= value.length || next < 56320 || next > 57343) return false;
+      index++;
+      continue;
+    }
+    if (code >= 56320 && code <= 57343) return false;
+  }
+  return true;
+};
+var primitiveFastPath = (value, maxStringLength) => {
+  if (value === null) return { value: null, bytes: 4, visitedNodes: 1 };
+  if (typeof value === "boolean") return { value, bytes: value ? 4 : 5, visitedNodes: 1 };
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return { value, bytes: 4, visitedNodes: 1 };
+    if (Object.is(value, -0)) return { value, bytes: 1, visitedNodes: 1 };
+    return { value, bytes: String(value).length, visitedNodes: 1 };
+  }
   if (typeof value === "string") {
-    if (value.length <= limits.maxStringLength) return value;
-    return truncation("max_string_length", {
-      __original_length: value.length,
-      value: value.slice(0, limits.maxStringLength)
-    });
+    if (value.length > maxStringLength || !isJsonSafeString(value)) return void 0;
+    return { value, bytes: 2 + Buffer2.byteLength(value, "utf8"), visitedNodes: 1 };
   }
-  if (typeof value === "undefined") return typeMarker("undefined");
-  if (typeof value === "bigint") return typeMarker("bigint", value.toString());
-  if (typeof value === "symbol") return typeMarker("symbol", String(value));
-  if (typeof value === "function") return typeMarker("function", value.name || "anonymous");
-  if (depth >= limits.maxDepth) return truncation("max_depth");
-  if (typeof value !== "object") return typeMarker(typeof value);
-  if (seen.has(value)) return typeMarker("circular");
-  seen.add(value);
-  try {
-    if (value instanceof Error) return errorValue(value, depth, seen, limits);
-    if (value instanceof Date) return typeMarker("Date", value.toISOString());
-    if (Buffer2.isBuffer(value)) {
-      return typeMarker("Buffer", {
-        byteLength: value.byteLength,
-        base64: value.subarray(0, limits.maxStringLength).toString("base64"),
-        ...value.byteLength > limits.maxStringLength ? { __rasputin_truncated: true } : {}
-      });
+  if (typeof value === "undefined") {
+    const serialized = typeMarker("undefined");
+    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
+  }
+  if (typeof value === "bigint") {
+    const serialized = typeMarker("bigint", value.toString());
+    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
+  }
+  if (typeof value === "symbol") {
+    const text = String(value);
+    if (!isJsonSafeString(text)) return void 0;
+    const serialized = typeMarker("symbol", text);
+    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
+  }
+  if (typeof value === "function") {
+    const name = value.name || "anonymous";
+    if (!isJsonSafeString(name)) return void 0;
+    const serialized = typeMarker("function", name);
+    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
+  }
+  return void 0;
+};
+var createSafeSerializer = (options = {}) => {
+  const limits = compileLimits(options);
+  const redactKeys = compileRedactKeys(options);
+  const sharedPath = /* @__PURE__ */ new Set();
+  let serializing = false;
+  const isRedactedKey = (key) => {
+    if (redactKeys.has(key)) return true;
+    if (!keyNeedsCaseFold(key)) return false;
+    return redactKeys.has(key.toLowerCase());
+  };
+  const addBytes = (metrics, count) => {
+    metrics.bytes += count;
+    if (metrics.bytes > limits.maxSerializedValueBytes) metrics.oversize = true;
+  };
+  const boundedOversize = (bytes, visitedNodes) => {
+    const bounded = truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
+    return { value: bounded, bytes: jsonLiteralUtf8Bytes(bounded), visitedNodes };
+  };
+  const openObject = (metrics, allocate) => {
+    addBytes(metrics, 2);
+    return {
+      target: allocate && !metrics.oversize ? {} : void 0,
+      first: true
+    };
+  };
+  const openArray = (metrics, allocate) => {
+    addBytes(metrics, 2);
+    return {
+      items: allocate && !metrics.oversize ? [] : void 0,
+      first: true
+    };
+  };
+  const beginField = (metrics, object, key) => {
+    if (!object.first) addBytes(metrics, 1);
+    object.first = false;
+    addBytes(metrics, jsonStringUtf8Bytes(key) + 1);
+  };
+  const assignField = (object, key, fieldValue) => {
+    if (object.target) object.target[key] = fieldValue;
+  };
+  const writeLiteralField = (metrics, object, key, jsonValue) => {
+    beginField(metrics, object, key);
+    addBytes(metrics, jsonLiteralUtf8Bytes(jsonValue));
+    assignField(object, key, jsonValue);
+  };
+  const writeTypeMarker = (metrics, allocate, type, nestedValue) => {
+    const object = openObject(metrics, allocate);
+    writeLiteralField(metrics, object, "__rasputin_type", type);
+    if (nestedValue !== void 0) writeLiteralField(metrics, object, "value", nestedValue);
+    return object.target;
+  };
+  const writeTruncation = (metrics, allocate, reason, extra = {}) => {
+    const object = openObject(metrics, allocate);
+    writeLiteralField(metrics, object, "__rasputin_truncated", true);
+    writeLiteralField(metrics, object, "__reason", reason);
+    for (const key of Object.keys(extra)) writeLiteralField(metrics, object, key, extra[key]);
+    return object.target;
+  };
+  const serializeInner = (value, depth, path, allocate, metrics) => {
+    metrics.visitedNodes++;
+    const store = allocate && !metrics.oversize;
+    if (value === null) {
+      addBytes(metrics, 4);
+      return store ? null : void 0;
     }
-    if (value instanceof Promise) return typeMarker("Promise");
-    if (value instanceof Map) {
-      const entries = [];
-      for (const entry of value.entries()) {
-        if (entries.length >= limits.maxArrayElements) break;
-        entries.push([
-          serializeInner(entry[0], depth + 1, seen, limits),
-          serializeInner(entry[1], depth + 1, seen, limits)
-        ]);
-      }
-      return {
-        __rasputin_type: "Map",
-        entries,
-        ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __original_length: value.size }) : {}
-      };
+    if (typeof value === "boolean") {
+      addBytes(metrics, value ? 4 : 5);
+      return store ? value : void 0;
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) addBytes(metrics, 4);
+      else if (Object.is(value, -0)) addBytes(metrics, 1);
+      else addBytes(metrics, String(value).length);
+      return store ? value : void 0;
     }
-    if (value instanceof Set) {
-      const items = [];
-      for (const item of value.values()) {
-        if (items.length >= limits.maxArrayElements) break;
-        items.push(serializeInner(item, depth + 1, seen, limits));
+    if (typeof value === "string") {
+      if (value.length <= limits.maxStringLength) {
+        addBytes(metrics, jsonStringUtf8Bytes(value));
+        return store ? value : void 0;
       }
-      return {
-        __rasputin_type: "Set",
-        values: items,
-        ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __original_length: value.size }) : {}
-      };
+      return writeTruncation(metrics, store, "max_string_length", {
+        __original_length: value.length,
+        value: value.slice(0, limits.maxStringLength)
+      });
+    }
+    if (typeof value === "undefined") return writeTypeMarker(metrics, store, "undefined");
+    if (typeof value === "bigint") {
+      return writeTypeMarker(metrics, store, "bigint", value.toString());
     }
-    if (Array.isArray(value)) {
-      const maxItems = value.length > limits.maxArrayElements ? limits.maxArrayElements - 1 : value.length;
-      const items = value.slice(0, maxItems).map((item) => serializeInner(item, depth + 1, seen, limits));
-      if (value.length > limits.maxArrayElements) {
-        items.push(truncation("max_array_elements", { __original_length: value.length }));
+    if (typeof value === "symbol") {
+      return writeTypeMarker(metrics, store, "symbol", String(value));
+    }
+    if (typeof value === "function") {
+      return writeTypeMarker(metrics, store, "function", value.name || "anonymous");
+    }
+    if (depth >= limits.maxDepth) return writeTruncation(metrics, store, "max_depth");
+    if (typeof value !== "object") return writeTypeMarker(metrics, store, typeof value);
+    if (path.has(value)) return writeTypeMarker(metrics, store, "circular");
+    path.add(value);
+    const bytesBefore = metrics.bytes;
+    const oversizeBefore = metrics.oversize;
+    try {
+      const childAllocate = allocate && !metrics.oversize;
+      if (value instanceof Error) {
+        const object2 = openObject(metrics, childAllocate);
+        writeLiteralField(metrics, object2, "__rasputin_type", "Error");
+        writeLiteralField(metrics, object2, "name", value.name);
+        beginField(metrics, object2, "message");
+        assignField(
+          object2,
+          "message",
+          serializeInner(value.message, depth + 1, path, childAllocate, metrics)
+        );
+        if (value.stack) {
+          beginField(metrics, object2, "stack");
+          assignField(
+            object2,
+            "stack",
+            serializeInner(value.stack, depth + 1, path, childAllocate, metrics)
+          );
+        }
+        return object2.target;
+      }
+      if (value instanceof Date) {
+        return writeTypeMarker(metrics, childAllocate, "Date", value.toISOString());
+      }
+      if (Buffer2.isBuffer(value)) {
+        return writeTypeMarker(metrics, childAllocate, "Buffer", {
+          byteLength: value.byteLength,
+          base64: value.subarray(0, limits.maxStringLength).toString("base64"),
+          ...value.byteLength > limits.maxStringLength ? { __rasputin_truncated: true } : {}
+        });
+      }
+      if (value instanceof Promise) return writeTypeMarker(metrics, childAllocate, "Promise");
+      if (value instanceof Map) {
+        const object2 = openObject(metrics, childAllocate);
+        writeLiteralField(metrics, object2, "__rasputin_type", "Map");
+        beginField(metrics, object2, "entries");
+        const entries = openArray(metrics, childAllocate);
+        let counted2 = 0;
+        for (const entry of value.entries()) {
+          if (counted2 >= limits.maxArrayElements) break;
+          if (!entries.first) addBytes(metrics, 1);
+          entries.first = false;
+          addBytes(metrics, 2);
+          const key = serializeInner(entry[0], depth + 1, path, childAllocate, metrics);
+          addBytes(metrics, 1);
+          const mapped = serializeInner(entry[1], depth + 1, path, childAllocate, metrics);
+          entries.items?.push([key, mapped]);
+          counted2++;
+        }
+        assignField(object2, "entries", entries.items ?? []);
+        if (value.size > limits.maxArrayElements) {
+          writeLiteralField(metrics, object2, "__rasputin_truncated", true);
+          writeLiteralField(metrics, object2, "__reason", "max_array_elements");
+          writeLiteralField(metrics, object2, "__original_length", value.size);
+        }
+        return object2.target;
+      }
+      if (value instanceof Set) {
+        const object2 = openObject(metrics, childAllocate);
+        writeLiteralField(metrics, object2, "__rasputin_type", "Set");
+        beginField(metrics, object2, "values");
+        const items = openArray(metrics, childAllocate);
+        let counted2 = 0;
+        for (const item of value.values()) {
+          if (counted2 >= limits.maxArrayElements) break;
+          if (!items.first) addBytes(metrics, 1);
+          items.first = false;
+          const serializedItem = serializeInner(item, depth + 1, path, childAllocate, metrics);
+          items.items?.push(serializedItem);
+          counted2++;
+        }
+        assignField(object2, "values", items.items ?? []);
+        if (value.size > limits.maxArrayElements) {
+          writeLiteralField(metrics, object2, "__rasputin_truncated", true);
+          writeLiteralField(metrics, object2, "__reason", "max_array_elements");
+          writeLiteralField(metrics, object2, "__original_length", value.size);
+        }
+        return object2.target;
+      }
+      if (Array.isArray(value)) {
+        const items = openArray(metrics, childAllocate);
+        const maxItems = value.length > limits.maxArrayElements ? limits.maxArrayElements - 1 : value.length;
+        for (let index = 0; index < maxItems; index++) {
+          if (!items.first) addBytes(metrics, 1);
+          items.first = false;
+          items.items?.push(serializeInner(value[index], depth + 1, path, childAllocate, metrics));
+        }
+        if (value.length > limits.maxArrayElements) {
+          if (!items.first) addBytes(metrics, 1);
+          items.first = false;
+          items.items?.push(
+            writeTruncation(metrics, childAllocate, "max_array_elements", {
+              __original_length: value.length
+            })
+          );
+        }
+        return items.items;
+      }
+      const object = openObject(metrics, childAllocate);
+      const prototype = Object.getPrototypeOf(value);
+      if (prototype && prototype !== Object.prototype) {
+        writeLiteralField(
+          metrics,
+          object,
+          "__rasputin_type",
+          prototype.constructor?.name ?? "instance"
+        );
       }
-      return items;
+      const keys = Object.keys(value);
+      const maxKeys = keys.length > limits.maxObjectKeys ? limits.maxObjectKeys - 1 : keys.length;
+      for (let index = 0; index < maxKeys; index++) {
+        const key = keys[index];
+        if (key === void 0) continue;
+        if (isRedactedKey(key)) {
+          writeLiteralField(metrics, object, key, REDACTED);
+          continue;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor && "value" in descriptor) {
+          beginField(metrics, object, key);
+          assignField(
+            object,
+            key,
+            serializeInner(descriptor.value, depth + 1, path, childAllocate, metrics)
+          );
+        } else {
+          beginField(metrics, object, key);
+          assignField(object, key, writeTypeMarker(metrics, childAllocate, "accessor"));
+        }
+      }
+      if (keys.length > limits.maxObjectKeys) {
+        writeLiteralField(metrics, object, "__rasputin_truncated", true);
+        writeLiteralField(metrics, object, "__reason", "max_object_keys");
+        writeLiteralField(metrics, object, "__original_length", keys.length);
+      }
+      return object.target;
+    } catch (error) {
+      metrics.bytes = bytesBefore;
+      metrics.oversize = oversizeBefore;
+      return writeTypeMarker(
+        metrics,
+        allocate && !metrics.oversize,
+        "unserializable",
+        error instanceof Error ? error.message : void 0
+      );
+    } finally {
+      path.delete(value);
     }
-    const prototype = Object.getPrototypeOf(value);
-    const serialized = {};
-    if (prototype && prototype !== Object.prototype) {
-      serialized.__rasputin_type = prototype.constructor?.name ?? "instance";
+  };
+  const serializeWithBytes = (value) => {
+    const fast = primitiveFastPath(value, limits.maxStringLength);
+    if (fast) {
+      return fast.bytes <= limits.maxSerializedValueBytes ? fast : boundedOversize(fast.bytes, fast.visitedNodes);
     }
-    const keys = Object.keys(value);
-    const maxKeys = keys.length > limits.maxObjectKeys ? limits.maxObjectKeys - 1 : keys.length;
-    for (const key of keys.slice(0, maxKeys)) {
-      const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      serialized[key] = descriptor && "value" in descriptor ? serializeInner(descriptor.value, depth + 1, seen, limits) : typeMarker("accessor");
+    const metrics = { visitedNodes: 0, bytes: 0, oversize: false };
+    const reentrant = serializing;
+    const path = reentrant ? /* @__PURE__ */ new Set() : sharedPath;
+    if (!reentrant) {
+      serializing = true;
+      sharedPath.clear();
     }
-    if (keys.length > limits.maxObjectKeys) {
-      Object.assign(serialized, truncation("max_object_keys", { __original_length: keys.length }));
+    try {
+      const serialized = serializeInner(value, 0, path, true, metrics);
+      if (metrics.bytes > limits.maxSerializedValueBytes) {
+        return boundedOversize(metrics.bytes, metrics.visitedNodes);
+      }
+      return { value: serialized, bytes: metrics.bytes, visitedNodes: metrics.visitedNodes };
+    } catch {
+      const failed = typeMarker("unserializable");
+      return {
+        value: failed,
+        bytes: jsonLiteralUtf8Bytes(failed),
+        visitedNodes: metrics.visitedNodes
+      };
+    } finally {
+      path.clear();
+      if (!reentrant) serializing = false;
     }
-    return serialized;
-  } catch (error) {
-    return typeMarker("unserializable", error instanceof Error ? error.message : void 0);
-  } finally {
-    seen.delete(value);
-  }
-};
-var safeSerializeWithBytes = (value, options = {}) => {
-  const limits = {
-    maxDepth: options.maxDepth ?? defaults.maxDepth,
-    maxObjectKeys: options.maxObjectKeys ?? defaults.maxObjectKeys,
-    maxArrayElements: options.maxArrayElements ?? defaults.maxArrayElements,
-    maxStringLength: options.maxStringLength ?? defaults.maxStringLength,
-    maxSerializedValueBytes: options.maxSerializedValueBytes ?? defaults.maxSerializedValueBytes
   };
-  try {
-    const redactKeys = /* @__PURE__ */ new Set([
-      ...DEFAULT_REDACT_KEYS,
-      ...(options.redactKeys ?? []).map((key) => key.toLowerCase())
-    ]);
-    const serialized = serializeInner(value, 0, /* @__PURE__ */ new WeakSet(), limits);
-    const redacted = redact(serialized, redactKeys, /* @__PURE__ */ new WeakSet());
-    const bytes = Buffer2.byteLength(JSON.stringify(redacted), "utf8");
-    const bounded = bytes <= limits.maxSerializedValueBytes ? redacted : truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
-    return {
-      value: bounded,
-      bytes: bounded === redacted ? bytes : Buffer2.byteLength(JSON.stringify(bounded), "utf8")
-    };
-  } catch {
-    const value2 = typeMarker("unserializable");
-    return { value: value2, bytes: Buffer2.byteLength(JSON.stringify(value2), "utf8") };
-  }
+  return {
+    serialize: (value) => serializeWithBytes(value).value,
+    serializeWithBytes
+  };
 };
-var safeSerialize = (value, options = {}) => safeSerializeWithBytes(value, options).value;
+var defaultSerializer = createSafeSerializer();
 
 // src/execution-recorder/source-exclusions.ts
 var sourcePathFrom = (definition) => definition.source?.packageRelativePath.replaceAll("\\", "/") ?? definition.name;
@@ -811,6 +1424,8 @@ var createSourceExclusionMatcher = (exclusions) => {
 
 // src/execution-recorder/execution-recorder.ts
 var DEFAULT_MAX_ACTIVE_MEMORY_BYTES = 64 * 1024 * 1024;
+var DERIVATION_ROOT_RECORD_BYTES = 64;
+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);
@@ -825,8 +1440,8 @@ var manualFunctionDefinition = (value) => {
   return { ...definition, functionId: runtimeFunctionId2(definition) };
 };
 var normalizeFunctionDefinition = (value) => typeof value === "string" ? manualFunctionDefinition(value) : value;
-var elapsedMs = (startedAtNs, endedAtNs = process.hrtime.bigint()) => Number(endedAtNs - startedAtNs) / 1e6;
-var roundedMilliseconds = (nanoseconds) => Math.round(Number(nanoseconds) / 1e6 * 1e4) / 1e4;
+var elapsedMs2 = (startedAtNs, endedAtNs = process.hrtime.bigint()) => Number(endedAtNs - startedAtNs) / 1e6;
+var roundedMilliseconds2 = (nanoseconds) => Math.round(Number(nanoseconds) / 1e6 * 1e4) / 1e4;
 var addRecorderTime = (recording, nanoseconds) => {
   if (nanoseconds > 0n) recording.inlineRecorderTimeNs += nanoseconds;
 };
@@ -896,6 +1511,43 @@ var observeRecordedCallback = (recording, recorderStartedAtNs, callback, onRetur
   recordExitWork(callbackEndedAtNs);
   return result;
 };
+var emptyStats = {
+  functionCallsObserved: 0,
+  functionCallsCaptured: 0,
+  functionCallsExcluded: 0,
+  serializedValues: 0,
+  serializedValueNodes: 0,
+  serializedValueBytes: 0,
+  errorSnapshots: 0,
+  successfulExecutionsDiscarded: 0,
+  truncatedEvents: 0,
+  repeatedCallsSuppressed: 0,
+  activeExecutions: 0,
+  peakActiveExecutions: 0,
+  memoryPressureExecutions: 0,
+  memoryPressureDegradations: 0,
+  valuesDroppedByMemoryBudget: 0,
+  eventsDroppedByMemoryBudget: 0,
+  partialErrorSnapshots: 0,
+  measuredExecutions: 0,
+  totalInlineWallTimeMs: 0,
+  maxInlineWallTimeMs: 0,
+  activeEstimatedBytes: 0,
+  peakActiveEstimatedBytes: 0,
+  journalPoolHits: 0,
+  journalPoolMisses: 0,
+  journalPoolSize: 0,
+  journalAllocatedCapacity: 0,
+  derivationCandidateFunctions: 0,
+  derivationElidedFunctionCalls: 0,
+  derivationRootsCaptured: 0,
+  derivationControlFactsCaptured: 0,
+  derivationValuesAvoided: 0,
+  derivationFallbackFunctions: 0,
+  derivationFallbackExpressions: 0,
+  derivationFallbackReasons: {},
+  derivationRootBytes: 0
+};
 var noOpExecution = {
   createScope: () => ({
     run: (callback) => callback(),
@@ -906,35 +1558,38 @@ var noOpExecution = {
   run: (_metadata, callback) => callback(),
   getErrorState: () => void 0,
   runFunction: (_functionId, _args, callback) => callback(),
+  runFunctionPlans: (_plans, _planIndex, _args, callback) => callback(),
+  prepareFunctionPlans: () => [],
+  runPreparedFunction: (_plan, _args, callback) => callback(),
   trace: (_functionId, fn) => fn,
-  getStats: () => ({
-    errorSnapshots: 0,
-    successfulExecutionsDiscarded: 0,
-    truncatedEvents: 0,
-    repeatedCallsSuppressed: 0,
-    activeExecutions: 0,
-    peakActiveExecutions: 0,
-    activeEstimatedBytes: 0,
-    peakActiveEstimatedBytes: 0,
-    memoryPressureExecutions: 0,
-    memoryPressureDegradations: 0,
-    valuesDroppedByMemoryBudget: 0,
-    eventsDroppedByMemoryBudget: 0,
-    partialErrorSnapshots: 0,
-    measuredExecutions: 0,
-    totalInlineWallTimeMs: 0,
-    maxInlineWallTimeMs: 0
-  })
+  getStats: () => ({ ...emptyStats, derivationFallbackReasons: {} }),
+  captureDerivationRoot: (_rootId, value) => value
 };
 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;
   const storage = new AsyncLocalStorage();
-  const maxEventsPerExecution = Math.max(2, Math.floor(options.maxEventsPerExecution ?? 500));
+  const maxEventsPerExecution = sanitizeJournalCapacity(options.maxEventsPerExecution);
   const maxCapturedCallsPerFunction = Math.max(
     1,
     Math.floor(options.maxCapturedCallsPerFunction ?? 3)
@@ -947,10 +1602,23 @@ var createExecutionRecorder = (options) => {
     maxActiveMemoryBytes,
     options.maxSerializedValueBytes ?? 8 * 1024
   );
+  const serializer = createSafeSerializer(options);
   const excludesSource = createSourceExclusionMatcher(options.excludeSources);
+  const journalPool = new ExecutionJournalPool(maxEventsPerExecution);
+  const plansByRuntimeId = [];
   let executionCounter = 0;
+  let nextRuntimePlanId = 1;
+  const internedPlans = /* @__PURE__ */ new Map();
+  const preparedModules = /* @__PURE__ */ new WeakMap();
   const errorExecutions = /* @__PURE__ */ new WeakMap();
+  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,
@@ -960,49 +1628,185 @@ var createExecutionRecorder = (options) => {
     partialErrorSnapshots: 0,
     measuredExecutions: 0,
     totalInlineWallTimeMs: 0,
-    maxInlineWallTimeMs: 0
+    maxInlineWallTimeMs: 0,
+    derivationCandidateFunctions: 0,
+    derivationElidedFunctionCalls: 0,
+    derivationRootsCaptured: 0,
+    derivationControlFactsCaptured: 0,
+    derivationValuesAvoided: 0,
+    derivationFallbackFunctions: 0,
+    derivationFallbackExpressions: 0,
+    derivationFallbackReasons: {},
+    derivationRootBytes: 0
+  };
+  const addPhase = (key, nanoseconds) => {
+    if (phases && nanoseconds > 0n) phases[key] += nanoseconds;
   };
   const recordInlineTiming = (recording) => {
-    const inlineWallTimeMs = roundedMilliseconds(recording.inlineRecorderTimeNs);
+    const inlineWallTimeMs = roundedMilliseconds2(recording.inlineRecorderTimeNs);
     stats.measuredExecutions++;
     stats.totalInlineWallTimeMs = Math.round((stats.totalInlineWallTimeMs + inlineWallTimeMs) * 1e4) / 1e4;
     stats.maxInlineWallTimeMs = Math.max(stats.maxInlineWallTimeMs, inlineWallTimeMs);
   };
-  const captureValue = (recording, value) => memoryBudget.captureValue(recording.memory, () => safeSerializeWithBytes(value, options));
+  const serializeAndCount = (value) => {
+    const serialized = serializer.serializeWithBytes(value);
+    stats.serializedValues++;
+    stats.serializedValueNodes += serialized.visitedNodes;
+    stats.serializedValueBytes += serialized.bytes;
+    return serialized;
+  };
+  const captureValue = (recording, value) => memoryBudget.captureValue(recording.memory, () => serializeAndCount(value));
+  const 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)
+    });
+    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)
+      });
+    });
+    preparedModules.set(plans, prepared);
+    return prepared;
+  };
+  const derivationMetrics = (recording) => {
+    const manifest = snapshotInstrumentationManifest();
+    const plans = manifest?.derivationPlans ?? [];
+    const reasons = { ...stats.derivationFallbackReasons };
+    return {
+      derivationCandidateFunctions: plans.filter((plan) => !plan.fallbackReason).length,
+      derivationElidedFunctionCalls: stats.derivationElidedFunctionCalls,
+      derivationRootsCaptured: recording.derivationRoots.length,
+      derivationControlFactsCaptured: stats.derivationControlFactsCaptured,
+      derivationValuesAvoided: stats.derivationValuesAvoided,
+      derivationFallbackFunctions: plans.filter((plan) => plan.fallbackReason).length,
+      derivationFallbackExpressions: recording.derivationRoots.length,
+      derivationFallbackReasons: reasons,
+      derivationRootBytes: recording.derivationRootBytes
+    };
+  };
+  const 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, derivation) => {
+    const source = recording.sawAutomatic ? "automatic" : recording.sawManual ? "manual" : "scope-only";
+    if (source === "scope-only") {
+      return {
+        source,
+        functionBoundaries: "none",
+        functionValues: "none",
+        timings: "none",
+        derivation: derivation ? "available" : "none"
+      };
+    }
+    const droppedEvents = Boolean(truncated?.eventsDropped || capture?.eventsDropped);
+    return {
+      source,
+      functionBoundaries: droppedEvents ? "partial" : "full",
+      functionValues: eventsHaveOmittedValues(events) ? "selective" : "full",
+      timings: droppedEvents ? "partial" : "full",
+      derivation: derivation ? "available" : "none"
+    };
+  };
+  const derivationCapture = (recording, functions) => {
+    const manifest = snapshotInstrumentationManifest();
+    if (!manifest) return void 0;
+    const plans = manifest.derivationPlans ?? [];
+    const recordedIds = new Set(functions.map((fn) => fn.functionId));
+    if (!plans.some((plan) => recordedIds.has(plan.functionId))) {
+      return void 0;
+    }
+    return {
+      manifestHash: hashInstrumentationManifest(manifest),
+      roots: recording.derivationRoots.slice(),
+      controlFacts: []
+    };
+  };
   const stateFrom = (recording, endedAtNs = process.hrtime.bigint()) => {
     const recorderStartedAtNs = process.hrtime.bigint();
-    const events = recording.events.values().map((event) => event.type === "function_calls_suppressed" ? { ...event } : event);
-    const referencedFunctionIds = new Set(
-      events.flatMap(
-        (event) => event.type === "function_enter" || event.type === "function_calls_suppressed" ? [event.functionId] : []
-      )
-    );
+    let events = [];
+    let functions = [];
+    let truncated;
+    let capture;
+    let derivation;
+    if (recording.cachedState) {
+      events = recording.cachedState.events;
+      functions = recording.cachedState.functions;
+      truncated = recording.cachedState.truncated;
+      capture = recording.cachedState.capture;
+      derivation = recording.cachedState.derivation;
+    } else {
+      if (recording.journal) {
+        const materialized = recording.journal.materialize(plansByRuntimeId, recording.startedAtNs);
+        events = materialized.events;
+        functions = materialized.functions;
+        truncated = recording.journal.dropped > 0 ? { eventsDropped: recording.journal.dropped } : void 0;
+      }
+      capture = recording.memory.underPressure ? {
+        completeness: "partial",
+        reason: "process_memory_budget",
+        valuesDropped: recording.memory.valuesDropped,
+        eventsDropped: recording.memory.eventsDropped
+      } : void 0;
+      derivation = derivationCapture(recording, functions);
+      if (recording.finished && recording.inFlightCalls === 0 && recording.journal) {
+        recording.cachedState = { events, functions, truncated, capture, derivation };
+        journalPool.release(recording.journal);
+        recording.journal = void 0;
+      }
+    }
     const state = {
-      version: 2,
+      version: 4,
+      captureProfile: resolveCaptureProfile(recording, events, truncated, capture, derivation),
       executionId: recording.executionId,
       startedAt: recording.startedAt,
-      durationMs: elapsedMs(recording.startedAtNs, endedAtNs),
-      recorder: { inlineWallTimeMs: 0 },
+      durationMs: elapsedMs2(recording.startedAtNs, endedAtNs),
+      recorder: { inlineWallTimeMs: 0, derivation: derivationMetrics(recording) },
       execution: {
         ...recording.execution,
         ...recording.execution.request ? { request: { ...recording.execution.request } } : {}
       },
-      functions: [...recording.functions.values()].filter(
-        (definition) => referencedFunctionIds.has(definition.functionId)
-      ),
-      events,
-      ...recording.events.dropped > 0 ? { truncated: { eventsDropped: recording.events.dropped } } : {},
-      ...recording.memory.underPressure ? {
-        capture: {
-          completeness: "partial",
-          reason: "process_memory_budget",
-          valuesDropped: recording.memory.valuesDropped,
-          eventsDropped: recording.memory.eventsDropped
-        }
-      } : {}
+      functions: functions.slice(),
+      events: events.slice(),
+      ...truncated ? { truncated: { ...truncated } } : {},
+      ...capture ? { capture: { ...capture } } : {},
+      ...derivation ? { derivation: { ...derivation, roots: derivation.roots.slice() } } : {}
     };
+    if (phaseTimingEnabled)
+      addPhase("materializeNs", process.hrtime.bigint() - recorderStartedAtNs);
     addRecorderTime(recording, process.hrtime.bigint() - recorderStartedAtNs);
-    state.recorder = { inlineWallTimeMs: roundedMilliseconds(recording.inlineRecorderTimeNs) };
+    state.recorder = {
+      inlineWallTimeMs: roundedMilliseconds2(recording.inlineRecorderTimeNs),
+      derivation: derivationMetrics(recording)
+    };
     return state;
   };
   const rememberError = (error, recording) => {
@@ -1018,25 +1822,38 @@ var createExecutionRecorder = (options) => {
     errorExecutions.set(error, recording);
   };
   const countDroppedEvents = (recording, droppedBefore) => {
-    stats.truncatedEvents += recording.events.dropped - droppedBefore;
+    const dropped = recording.journal?.dropped ?? droppedBefore;
+    stats.truncatedEvents += dropped - droppedBefore;
   };
-  const appendStandaloneEvent = (recording, event) => {
+  const appendSuppressedPlaceholder = (recording, group) => {
+    if (!recording.journal) return;
     if (!memoryBudget.reserveStandaloneEvent(recording.memory)) return;
-    const droppedBefore = recording.events.dropped;
-    recording.events.append(event);
+    const droppedBefore = recording.journal.dropped;
+    recording.journal.appendSuppressed(group);
     countDroppedEvents(recording, droppedBefore);
   };
-  const repeatedCallGroup = (recording, functionId, parentCallId) => {
-    let byParent = recording.repeatedCalls.get(functionId);
-    if (!byParent) {
-      byParent = /* @__PURE__ */ new Map();
-      recording.repeatedCalls.set(functionId, byParent);
+  const repeatedCallGroup = (recording, 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;
     }
-    let group = byParent.get(parentCallId);
+    if (!slot.byParent) slot.byParent = /* @__PURE__ */ new Map();
+    let group = slot.byParent.get(parentCallId);
     if (!group) {
-      group = { observedCalls: 0 };
-      byParent.set(parentCallId, group);
+      group = newRepeatedGroup(plan);
+      slot.byParent.set(parentCallId, group);
     }
+    slot.lastParentCallId = parentCallId;
+    slot.lastParentGroup = group;
     return group;
   };
   const serializedError = (recording, error, callId) => {
@@ -1052,60 +1869,83 @@ var createExecutionRecorder = (options) => {
     return {
       // Keep the bounded thrown value even after surrounding capture degrades. A partial
       // snapshot without the exception itself would not be useful for investigation.
-      value: safeSerialize(error, options),
+      value: serializeAndCount(error).value,
       commit: () => {
         if (key) recording.capturedErrors.set(key, callId);
       }
     };
   };
-  const captureCompletedThrow = (recording, functionId, args, parentCallId, startedAtNs, startedAtMs, error) => {
-    if (!memoryBudget.reserveCall(recording.memory, functionId)) {
+  const captureCompletedThrow = (recording, plan, args, parentCallId, startedAtNs, error) => {
+    if (!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 enter = {
-      type: "function_enter",
+    const capturedArgs = Array.from(args, (argument) => captureValue(recording, argument));
+    const endedAtNs = process.hrtime.bigint();
+    const droppedBefore = recording.journal.dropped;
+    const retained = recording.journal.forceCompletedCall(
+      plan.runtimePlanId,
       callId,
-      functionId,
-      timestampMs: startedAtMs,
-      args: Array.from(args, (argument) => captureValue(recording, argument)),
-      ...parentCallId === void 0 ? {} : { parentCallId }
-    };
-    const terminal = {
-      type: "function_throw",
-      callId,
-      timestampMs: elapsedMs(recording.startedAtNs),
-      durationMs: elapsedMs(startedAtNs),
-      error: capturedError.value
-    };
-    const droppedBefore = recording.events.dropped;
-    const retained = recording.events.forceCompletedCall(enter, terminal);
-    if (retained) capturedError.commit();
+      parentCallId,
+      startedAtNs - recording.startedAtNs,
+      capturedArgs,
+      KIND_THROW,
+      endedAtNs - recording.startedAtNs,
+      endedAtNs - startedAtNs,
+      capturedError.value
+    );
+    if (retained) {
+      stats.functionCallsCaptured++;
+      capturedError.commit();
+    }
     countDroppedEvents(recording, droppedBefore);
     rememberError(error, recording);
   };
-  const recordSuppressedCall = (recording, group, functionId, parentCallId, startedAtMs, durationMs) => {
+  const recordSuppressedCall = (recording, group, parentCallId, startedAtNs, endedAtNs) => {
     stats.repeatedCallsSuppressed++;
-    const endedAtMs = startedAtMs + durationMs;
-    if (!group.summary) {
-      group.summary = {
-        type: "function_calls_suppressed",
-        functionId,
-        timestampMs: startedAtMs,
-        lastTimestampMs: endedAtMs,
-        suppressedCallCount: 1,
-        totalDurationMs: durationMs,
-        ...parentCallId === void 0 ? {} : { parentCallId }
-      };
-      appendStandaloneEvent(recording, group.summary);
+    if (!group.suppressed) {
+      group.suppressed = newSuppression(group, parentCallId, startedAtNs, endedAtNs);
+      appendSuppressedPlaceholder(recording, group.suppressed);
       return;
     }
-    group.summary.lastTimestampMs = endedAtMs;
-    group.summary.suppressedCallCount++;
-    group.summary.totalDurationMs = Math.round((group.summary.totalDurationMs + durationMs) * 1e4) / 1e4;
-    if (!recording.events.contains(group.summary)) appendStandaloneEvent(recording, group.summary);
+    const suppressed = group.suppressed;
+    suppressed.count++;
+    suppressed.lastTimestampNs = endedAtNs;
+    suppressed.totalDurationNs += 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--;
+    releaseJournalIfIdle(recording);
   };
   const finish = (store, metadata) => {
     const { recording } = store;
@@ -1115,11 +1955,22 @@ var createExecutionRecorder = (options) => {
     if (metadata) mergeExecutionMetadata(recording.execution, metadata);
     memoryBudget.release(recording.memory);
     stats.activeExecutions = Math.max(0, stats.activeExecutions - 1);
-    if (!recording.hasError) stats.successfulExecutionsDiscarded++;
+    if (!recording.hasError) {
+      stats.successfulExecutionsDiscarded++;
+      releaseJournalIfIdle(recording);
+    }
     recording.finishedAtNs = process.hrtime.bigint();
     addRecorderTime(recording, recording.finishedAtNs - recorderStartedAtNs);
     recordInlineTiming(recording);
   };
+  const runStore = (store, callback) => {
+    if (!phaseTimingEnabled) return storage.run(store, callback);
+    const alsStartedAtNs = process.hrtime.bigint();
+    return storage.run(store, () => {
+      addPhase("alsNs", process.hrtime.bigint() - alsStartedAtNs);
+      return callback();
+    });
+  };
   const createScope = (metadata) => {
     const recorderStartedAtNs = process.hrtime.bigint();
     try {
@@ -1132,15 +1983,19 @@ var createExecutionRecorder = (options) => {
           ...metadata,
           ...metadata.request ? { request: { ...metadata.request } } : {}
         },
-        events: new CallAwareEventBuffer(maxEventsPerExecution),
-        functions: /* @__PURE__ */ new Map(),
-        repeatedCalls: /* @__PURE__ */ new Map(),
+        journal: void 0,
+        repeatedCalls: [],
         capturedErrors: /* @__PURE__ */ new WeakMap(),
         nextCallId: 0,
+        inFlightCalls: 0,
         finished: false,
         hasError: false,
         memory: memoryBudget.startExecution(),
-        partialSnapshotCounted: false
+        partialSnapshotCounted: false,
+        derivationRoots: [],
+        derivationRootBytes: 0,
+        sawAutomatic: false,
+        sawManual: false
       };
       stats.activeExecutions++;
       stats.peakActiveExecutions = Math.max(stats.peakActiveExecutions, stats.activeExecutions);
@@ -1149,7 +2004,7 @@ var createExecutionRecorder = (options) => {
       return {
         run: (callback) => {
           const runStartedAtNs = process.hrtime.bigint();
-          return storage.run(store, () => {
+          return runStore(store, () => {
             addRecorderTime(recording, process.hrtime.bigint() - runStartedAtNs);
             return callback();
           });
@@ -1202,140 +2057,295 @@ var createExecutionRecorder = (options) => {
       return void 0;
     }
   };
-  const runFunction = (input, args, callback) => {
+  const runPreparedFunction = (plan, args, callback, omitValues) => {
     const store = storage.getStore();
     if (!store || store.recording.finished) return callback();
-    const definition = normalizeFunctionDefinition(input);
-    const functionId = definition.functionId;
+    stats.functionCallsObserved++;
     const recorderStartedAtNs = process.hrtime.bigint();
-    if (store.suppressCapture || excludesSource(definition)) {
-      return storage.run({ ...store, suppressCapture: true }, () => {
+    if (store.suppressCapture || plan.excluded) {
+      stats.functionCallsExcluded++;
+      return runStore({ ...store, suppressCapture: true }, () => {
         addRecorderTime(store.recording, process.hrtime.bigint() - recorderStartedAtNs);
         return callback();
       });
     }
-    store.recording.functions.set(functionId, definition);
+    const recording = store.recording;
+    recording.inFlightCalls++;
     const parentCallId = store.currentCallId;
-    const group = repeatedCallGroup(store.recording, functionId, parentCallId);
+    const group = repeatedCallGroup(recording, plan, parentCallId);
     group.observedCalls++;
+    const journal = acquireJournal(recording);
+    if (group.observedCalls === 1) journal?.notePlan(plan.runtimePlanId);
     if (group.observedCalls > maxCapturedCallsPerFunction) {
       const startedAtNs2 = process.hrtime.bigint();
-      const startedAtMs = elapsedMs(store.recording.startedAtNs, startedAtNs2);
-      const captureSuccess = () => recordSuppressedCall(
-        store.recording,
-        group,
-        functionId,
-        parentCallId,
-        startedAtMs,
-        elapsedMs(startedAtNs2)
-      );
-      return observeRecordedCallback(
-        store.recording,
-        recorderStartedAtNs,
-        callback,
-        captureSuccess,
-        (error) => captureCompletedThrow(
-          store.recording,
-          functionId,
-          args,
-          parentCallId,
-          startedAtNs2,
-          startedAtMs,
-          error
+      try {
+        const result = callback();
+        if (isPromiseLike(result)) {
+          addRecorderTime(recording, startedAtNs2 - recorderStartedAtNs);
+          return result.then(
+            (value) => {
+              const callbackEndedAtNs2 = process.hrtime.bigint();
+              recordSuppressedCall(recording, group, parentCallId, startedAtNs2, callbackEndedAtNs2);
+              addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              settleInFlight(recording);
+              return value;
+            },
+            (error) => {
+              const callbackEndedAtNs2 = process.hrtime.bigint();
+              captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs2, error);
+              addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              settleInFlight(recording);
+              throw error;
+            }
+          );
+        }
+        const callbackEndedAtNs = process.hrtime.bigint();
+        recordSuppressedCall(recording, group, parentCallId, startedAtNs2, callbackEndedAtNs);
+        addRecorderTime(recording, startedAtNs2 - recorderStartedAtNs);
+        addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs);
+        settleInFlight(recording);
+        return result;
+      } catch (error) {
+        const callbackEndedAtNs = process.hrtime.bigint();
+        captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs2, error);
+        addRecorderTime(recording, startedAtNs2 - recorderStartedAtNs);
+        addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs);
+        settleInFlight(recording);
+        throw error;
+      }
+    }
+    const startedAtNs = process.hrtime.bigint();
+    if (!journal) {
+      memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes);
+      return runStore(
+        store,
+        () => observeRecordedCallback(
+          recording,
+          recorderStartedAtNs,
+          callback,
+          () => settleInFlight(recording),
+          (error) => {
+            rememberError(error, recording);
+            settleInFlight(recording);
+          }
         )
       );
     }
-    const startedAtNs = process.hrtime.bigint();
-    if (!store.recording.events.canStartCall()) {
-      const startedAtMs = elapsedMs(store.recording.startedAtNs, startedAtNs);
+    if (!journal.canStartCall()) {
       const captureSuccess = () => {
-        const droppedBefore = store.recording.events.dropped;
-        store.recording.events.dropCall();
-        countDroppedEvents(store.recording, droppedBefore);
+        const droppedBefore = recording.journal?.dropped ?? 0;
+        recording.journal?.dropCall();
+        countDroppedEvents(recording, droppedBefore);
+        settleInFlight(recording);
       };
-      return storage.run(
+      return runStore(
         store,
         () => observeRecordedCallback(
-          store.recording,
+          recording,
           recorderStartedAtNs,
           callback,
           captureSuccess,
-          (error) => captureCompletedThrow(
-            store.recording,
-            functionId,
-            args,
-            parentCallId,
-            startedAtNs,
-            startedAtMs,
-            error
-          )
+          (error) => {
+            captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs, error);
+            settleInFlight(recording);
+          }
         )
       );
     }
-    if (!memoryBudget.reserveCall(store.recording.memory, functionId)) {
+    if (!memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes)) {
       return observeRecordedCallback(
-        store.recording,
+        recording,
         recorderStartedAtNs,
         callback,
-        () => {
-        },
-        (error) => rememberError(error, store.recording)
+        () => settleInFlight(recording),
+        (error) => {
+          rememberError(error, recording);
+          settleInFlight(recording);
+        }
       );
     }
-    const callId = ++store.recording.nextCallId;
-    const enter = {
-      type: "function_enter",
-      callId,
-      functionId,
-      timestampMs: elapsedMs(store.recording.startedAtNs),
-      args: Array.from(args, (argument) => captureValue(store.recording, argument)),
-      ...parentCallId === void 0 ? {} : { parentCallId }
-    };
-    store.recording.events.startCall(enter);
-    const callStore = { recording: store.recording, currentCallId: callId };
-    return storage.run(
+    const callId = ++recording.nextCallId;
+    const enterTimestampNs = process.hrtime.bigint() - recording.startedAtNs;
+    const capturedArgs = omitValues ? Array.from(args, () => rasputinOmitted()) : Array.from(args, (argument) => captureValue(recording, argument));
+    journal.startCall(plan.runtimePlanId, callId, parentCallId, enterTimestampNs, capturedArgs);
+    const callStore = { recording, currentCallId: callId };
+    return runStore(
       callStore,
       () => observeRecordedCallback(
-        store.recording,
+        recording,
         recorderStartedAtNs,
         callback,
         (value) => {
-          store.recording.events.finishCall({
-            type: "function_exit",
-            callId,
-            timestampMs: elapsedMs(store.recording.startedAtNs),
-            durationMs: elapsedMs(startedAtNs),
-            returnValue: captureValue(store.recording, value)
-          });
+          if (recording.journal) {
+            const timestampNs = process.hrtime.bigint() - recording.startedAtNs;
+            const durationNs = process.hrtime.bigint() - startedAtNs;
+            const returnValue = omitValues ? rasputinOmitted() : captureValue(recording, value);
+            recording.journal.finishCall(KIND_EXIT, callId, timestampNs, durationNs, returnValue);
+            stats.functionCallsCaptured++;
+          }
+          settleInFlight(recording);
         },
         (error) => {
-          const capturedError = serializedError(store.recording, error, callId);
-          store.recording.events.finishCall({
-            type: "function_throw",
+          if (!recording.journal) {
+            rememberError(error, recording);
+            settleInFlight(recording);
+            return;
+          }
+          const capturedError = serializedError(recording, error, callId);
+          recording.journal.finishCall(
+            KIND_THROW,
             callId,
-            timestampMs: elapsedMs(store.recording.startedAtNs),
-            durationMs: elapsedMs(startedAtNs),
-            error: capturedError.value
-          });
+            process.hrtime.bigint() - recording.startedAtNs,
+            process.hrtime.bigint() - startedAtNs,
+            capturedError.value
+          );
+          stats.functionCallsCaptured++;
           capturedError.commit();
-          rememberError(error, store.recording);
+          rememberError(error, recording);
+          settleInFlight(recording);
         }
       )
     );
   };
+  const runFunction = (input, args, callback) => {
+    const store = storage.getStore();
+    if (store && !store.recording.finished) store.recording.sawManual = true;
+    return runPreparedFunction(preparePlan(normalizeFunctionDefinition(input)), args, callback);
+  };
+  const runFunctionPlans = (plans, planIndex, args, callback, omitValues) => {
+    const store = storage.getStore();
+    const plan = preparedPlansFor(plans)[planIndex];
+    if (store && !store.recording.finished) store.recording.sawAutomatic = true;
+    return plan ? runPreparedFunction(plan, args, callback, omitValues) : callback();
+  };
+  const prepareFunctionPlans = (plans) => preparedPlansFor(plans);
   function trace(input, fn) {
     const definition = typeof input === "string" ? manualFunctionDefinition(input) : { ...input, functionId: runtimeFunctionId2(input) };
+    const plan = preparePlan(definition);
     return function traced(...args) {
-      return runFunction(definition, args, () => fn.apply(this, args));
+      const store = storage.getStore();
+      if (store && !store.recording.finished) store.recording.sawManual = true;
+      return runPreparedFunction(plan, args, () => fn.apply(this, args));
     };
   }
+  const captureDerivationRoot = (rootId, value) => {
+    const store = storage.getStore();
+    if (!store || store.recording.finished || store.suppressCapture) return value;
+    const recording = store.recording;
+    if (recording.memory.mode !== "full") return value;
+    if (recording.derivationRoots.length >= maxEventsPerExecution) return value;
+    const recorderStartedAtNs = process.hrtime.bigint();
+    try {
+      const serialized = captureValue(recording, value);
+      if (recording.memory.mode !== "full") return value;
+      if (!memoryBudget.reserveStorage(recording.memory, DERIVATION_ROOT_RECORD_BYTES)) {
+        return value;
+      }
+      const completeness = capturedValueCompleteness(serialized);
+      const bytes = jsonLiteralUtf8Bytes(serialized);
+      recording.derivationRoots.push({
+        rootId,
+        callId: store.currentCallId ?? 0,
+        value: serialized,
+        completeness
+      });
+      recording.derivationRootBytes += bytes;
+      stats.derivationRootsCaptured++;
+      stats.derivationRootBytes += bytes;
+      stats.derivationFallbackExpressions++;
+      return value;
+    } finally {
+      addRecorderTime(recording, process.hrtime.bigint() - recorderStartedAtNs);
+    }
+  };
   return {
     createScope,
     run,
     getErrorState,
     runFunction,
+    runFunctionPlans,
+    prepareFunctionPlans,
+    runPreparedFunction,
     trace,
-    getStats: () => ({ ...stats, ...memoryBudget.getStats() })
+    captureDerivationRoot,
+    getStats: () => {
+      const manifest = snapshotInstrumentationManifest();
+      const plans = manifest?.derivationPlans ?? [];
+      return {
+        ...stats,
+        ...memoryBudget.getStats(),
+        ...journalPool.stats(),
+        derivationCandidateFunctions: plans.filter((plan) => !plan.fallbackReason).length,
+        derivationFallbackFunctions: plans.filter((plan) => plan.fallbackReason).length,
+        derivationFallbackReasons: { ...stats.derivationFallbackReasons },
+        ...phases ? {
+          phaseAlsNs: Number(phases.alsNs),
+          phaseMaterializeNs: Number(phases.materializeNs)
+        } : {}
+      };
+    }
+  };
+};
+
+// src/execution-recorder/automatic-runtime.ts
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+var passthroughCapture = (_rootId, value) => value;
+var passthrough = (_planIndex, _args, callback) => callback();
+var bindPassthrough = (module) => {
+  module.cell.run = passthrough;
+};
+var isRegistry = (value) => Array.isArray(Reflect.get(value, "runtimes")) && Array.isArray(Reflect.get(value, "modules")) && typeof Reflect.get(value, "register") === "function";
+var registerModule = (registry, plans) => {
+  const cell = { run: passthrough };
+  const module = { plans, cell };
+  registry.modules.push(module);
+  registry.runtimes.at(-1)?.bind(module);
+  return (planIndex, args, callback, omitValues) => cell.run(planIndex, args, callback, omitValues);
+};
+var createRegistry = () => {
+  const registry = {
+    runtimes: [],
+    modules: [],
+    captureRoot: passthroughCapture,
+    register(plans) {
+      return registerModule(registry, plans);
+    }
+  };
+  return registry;
+};
+var getAutomaticRuntimeRegistry = () => {
+  const existing = Reflect.get(globalThis, runtimeSymbol);
+  if (existing && typeof existing === "object" && isRegistry(existing)) {
+    if (typeof existing.captureRoot !== "function") {
+      existing.captureRoot = passthroughCapture;
+    }
+    return existing;
+  }
+  const registry = createRegistry();
+  Reflect.set(globalThis, runtimeSymbol, registry);
+  return registry;
+};
+var installAutomaticExecutionRuntime = (execution) => {
+  const registry = getAutomaticRuntimeRegistry();
+  const runtime = {
+    bind(module) {
+      module.cell.run = (planIndex, args, callback, omitValues) => execution.runFunctionPlans(module.plans, planIndex, args, callback, omitValues);
+    },
+    captureRoot: (rootId, value) => execution.captureDerivationRoot(rootId, value)
+  };
+  registry.runtimes.push(runtime);
+  registry.captureRoot = runtime.captureRoot;
+  for (const module of registry.modules) runtime.bind(module);
+  return () => {
+    const index = registry.runtimes.lastIndexOf(runtime);
+    if (index >= 0) registry.runtimes.splice(index, 1);
+    const current = registry.runtimes.at(-1);
+    registry.captureRoot = current?.captureRoot ?? passthroughCapture;
+    for (const module of registry.modules) {
+      if (current) current.bind(module);
+      else bindPassthrough(module);
+    }
   };
 };
 
@@ -1388,6 +2398,7 @@ var installGlobalHandlers = (client, options = {}) => {
 };
 
 // src/rasputin-init.ts
+import { join } from "node:path";
 import {
   createClient,
   isClientEnabled
@@ -1395,7 +2406,7 @@ import {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/node";
-var SDK_VERSION = "0.4.1";
+var SDK_VERSION = "0.5.0-alpha.10";
 
 // src/rasputin-init.ts
 var withExecution = (client, execution, installRuntime, manifest) => {
@@ -1436,6 +2447,9 @@ var RasputinInit = (options) => {
       ...options.executionRecorder,
       enabled: recorderEnabled
     });
+    loadInstrumentationManifestIfPresent(
+      options.instrumentationManifestPath ?? process.env.RASPUTIN_INSTRUMENTATION_MANIFEST ?? join(process.cwd(), ".rasputin", "instrumentation-manifest.json")
+    );
     const wrappedClient = withExecution(client, execution, recorderEnabled, {
       projectApiKey: options.projectApiKey,
       release: options.release,