@rasputin-ai/node 0.5.0-alpha.1 → 0.5.0-alpha.11

package/dist/index.js

@@ -133,7 +133,7 @@ var definitionFromEncodedPlan = (plan) => {
 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 getRegistry = () => {
   const existing = Reflect.get(globalThis, registrySymbol);
@@ -190,6 +190,7 @@ var snapshotInstrumentationManifest = (options = {}) => {
   const functions = [];
   const callSites = [];
   const destructures = [];
+  const derivationPlans = [];
   for (const delta of getRegistry().files.values()) {
     for (const fn of delta.functions) {
       const definition = definitionFromEncodedPlan(fn.plan);
@@ -241,6 +242,7 @@ var snapshotInstrumentationManifest = (options = {}) => {
         binding: destructure.binding
       });
     }
+    derivationPlans.push(...delta.derivationPlans ?? []);
   }
   const registry = getRegistry();
   if (registry.prebuilt && registry.files.size === 0) {
@@ -268,7 +270,8 @@ var snapshotInstrumentationManifest = (options = {}) => {
     } : {},
     functions,
     callSites,
-    destructures
+    destructures,
+    derivationPlans
   };
 };
 var markInstrumentationManifestUploaded = (generation) => {
@@ -384,90 +387,393 @@ 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();
-  retainedSummaries = /* @__PURE__ */ new WeakSet();
-  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);
   }
-  startCall(event) {
-    this.items.push(event);
-    this.openCallIds.add(event.callId);
+  notePlan(runtimePlanId) {
+    if (this.notedPlanSet.has(runtimePlanId)) return;
+    this.notedPlanSet.add(runtimePlanId);
+    this.notedPlanIds.push(runtimePlanId);
   }
-  finishCall(event) {
-    if (event.type !== "function_exit" && event.type !== "function_throw") return;
-    if (!this.openCallIds.delete(event.callId)) return;
-    this.items.push(event);
+  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(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);
-    if (event.type === "function_calls_suppressed") this.retainedSummaries.add(event);
     return true;
   }
-  hasSummary(event) {
-    return this.retainedSummaries.has(event);
-  }
-  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;
+  }
+  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) {
-      const summary = this.items[summaryIndex];
-      if (summary) this.retainedSummaries.delete(summary);
-      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
@@ -545,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;
@@ -605,6 +917,7 @@ var defaults = {
   maxStringLength: 500,
   maxSerializedValueBytes: 8 * 1024
 };
+var REDACTED = "[RASPUTIN_REDACTED]";
 var truncation = (reason, extra = {}) => ({
   __rasputin_truncated: true,
   __reason: reason,
@@ -614,7 +927,83 @@ var typeMarker = (type, value) => ({
   __rasputin_type: type,
   ...value === void 0 ? {} : { value }
 });
-var REDACTED = "[RASPUTIN_REDACTED]";
+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 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");
+  }
+};
 var compileLimits = (options) => ({
   maxDepth: options.maxDepth ?? defaults.maxDepth,
   maxObjectKeys: options.maxObjectKeys ?? defaults.maxObjectKeys,
@@ -626,135 +1015,340 @@ 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 > maxStringLength || !isJsonSafeString(value)) return void 0;
+    return { value, bytes: 2 + Buffer2.byteLength(value, "utf8"), visitedNodes: 1 };
+  }
+  if (typeof value === "undefined") {
+    const serialized = typeMarker("undefined");
+    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
+  }
+  if (typeof value === "bigint") {
+    const serialized = typeMarker("bigint", value.toString());
+    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
+  }
+  if (typeof value === "symbol") {
+    const text = String(value);
+    if (!isJsonSafeString(text)) return void 0;
+    const serialized = typeMarker("symbol", text);
+    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
+  }
+  if (typeof value === "function") {
+    const name = value.name || "anonymous";
+    if (!isJsonSafeString(name)) return void 0;
+    const serialized = typeMarker("function", name);
+    return { value: serialized, bytes: jsonLiteralUtf8Bytes(serialized), visitedNodes: 1 };
+  }
+  return void 0;
+};
 var createSafeSerializer = (options = {}) => {
   const limits = compileLimits(options);
   const redactKeys = compileRedactKeys(options);
-  const serializeInner = (value, depth, seen, metrics) => {
+  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++;
-    if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+    const store = allocate && !metrics.oversize;
+    if (value === null) {
+      addBytes(metrics, 4);
+      return store ? null : void 0;
+    }
+    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 (typeof value === "string") {
-      if (value.length <= limits.maxStringLength) return value;
-      return truncation("max_string_length", {
+      if (value.length <= limits.maxStringLength) {
+        addBytes(metrics, jsonStringUtf8Bytes(value));
+        return store ? value : void 0;
+      }
+      return writeTruncation(metrics, store, "max_string_length", {
         __original_length: value.length,
         value: value.slice(0, limits.maxStringLength)
       });
     }
-    if (typeof value === "undefined") return typeMarker("undefined");
-    if (typeof value === "bigint") return typeMarker("bigint", value.toString());
-    if (typeof value === "symbol") return typeMarker("symbol", String(value));
-    if (typeof value === "function") return typeMarker("function", value.name || "anonymous");
-    if (depth >= limits.maxDepth) return truncation("max_depth");
-    if (typeof value !== "object") return typeMarker(typeof value);
-    const tracking = seen ?? /* @__PURE__ */ new WeakSet();
-    if (tracking.has(value)) return typeMarker("circular");
-    tracking.add(value);
+    if (typeof value === "undefined") return writeTypeMarker(metrics, store, "undefined");
+    if (typeof value === "bigint") {
+      return writeTypeMarker(metrics, store, "bigint", value.toString());
+    }
+    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) {
-        return {
-          __rasputin_type: "Error",
-          name: value.name,
-          message: serializeInner(value.message, depth + 1, tracking, metrics),
-          ...value.stack ? { stack: serializeInner(value.stack, depth + 1, tracking, metrics) } : {}
-        };
+        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 (value instanceof Date) return typeMarker("Date", value.toISOString());
       if (Buffer2.isBuffer(value)) {
-        return typeMarker("Buffer", {
+        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 typeMarker("Promise");
+      if (value instanceof Promise) return writeTypeMarker(metrics, childAllocate, "Promise");
       if (value instanceof Map) {
-        const entries = [];
+        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 (entries.length >= limits.maxArrayElements) break;
-          entries.push([
-            serializeInner(entry[0], depth + 1, tracking, metrics),
-            serializeInner(entry[1], depth + 1, tracking, metrics)
-          ]);
+          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++;
         }
-        return {
-          __rasputin_type: "Map",
-          entries,
-          ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __original_length: value.size }) : {}
-        };
+        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 items = [];
+        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 (items.length >= limits.maxArrayElements) break;
-          items.push(serializeInner(item, depth + 1, tracking, metrics));
+          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 {
-          __rasputin_type: "Set",
-          values: items,
-          ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __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;
-        const items = [];
         for (let index = 0; index < maxItems; index++) {
-          items.push(serializeInner(value[index], depth + 1, tracking, metrics));
+          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) {
-          items.push(truncation("max_array_elements", { __original_length: value.length }));
+          if (!items.first) addBytes(metrics, 1);
+          items.first = false;
+          items.items?.push(
+            writeTruncation(metrics, childAllocate, "max_array_elements", {
+              __original_length: value.length
+            })
+          );
         }
-        return items;
+        return items.items;
       }
+      const object = openObject(metrics, childAllocate);
       const prototype = Object.getPrototypeOf(value);
-      const serialized = {};
       if (prototype && prototype !== Object.prototype) {
-        serialized.__rasputin_type = prototype.constructor?.name ?? "instance";
+        writeLiteralField(
+          metrics,
+          object,
+          "__rasputin_type",
+          prototype.constructor?.name ?? "instance"
+        );
       }
       const keys = Object.keys(value);
       const maxKeys = keys.length > limits.maxObjectKeys ? limits.maxObjectKeys - 1 : keys.length;
       for (let index = 0; index < maxKeys; index++) {
         const key = keys[index];
         if (key === void 0) continue;
-        if (redactKeys.has(key.toLowerCase())) {
-          serialized[key] = REDACTED;
+        if (isRedactedKey(key)) {
+          writeLiteralField(metrics, object, key, REDACTED);
           continue;
         }
         const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        serialized[key] = descriptor && "value" in descriptor ? serializeInner(descriptor.value, depth + 1, tracking, metrics) : typeMarker("accessor");
+        if (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) {
-        Object.assign(
-          serialized,
-          truncation("max_object_keys", { __original_length: keys.length })
-        );
+        writeLiteralField(metrics, object, "__rasputin_truncated", true);
+        writeLiteralField(metrics, object, "__reason", "max_object_keys");
+        writeLiteralField(metrics, object, "__original_length", keys.length);
       }
-      return serialized;
+      return object.target;
     } catch (error) {
-      return typeMarker("unserializable", error instanceof Error ? error.message : void 0);
+      metrics.bytes = bytesBefore;
+      metrics.oversize = oversizeBefore;
+      return writeTypeMarker(
+        metrics,
+        allocate && !metrics.oversize,
+        "unserializable",
+        error instanceof Error ? error.message : void 0
+      );
     } finally {
-      tracking.delete(value);
+      path.delete(value);
     }
   };
   const serializeWithBytes = (value) => {
-    const metrics = { visitedNodes: 0 };
+    const fast = primitiveFastPath(value, limits.maxStringLength);
+    if (fast) {
+      return fast.bytes <= limits.maxSerializedValueBytes ? fast : boundedOversize(fast.bytes, fast.visitedNodes);
+    }
+    const metrics = { visitedNodes: 0, bytes: 0, oversize: false };
+    const reentrant = serializing;
+    const path = reentrant ? /* @__PURE__ */ new Set() : sharedPath;
+    if (!reentrant) {
+      serializing = true;
+      sharedPath.clear();
+    }
     try {
-      const serialized = serializeInner(value, 0, void 0, metrics);
-      const bytes = Buffer2.byteLength(JSON.stringify(serialized), "utf8");
-      if (bytes <= limits.maxSerializedValueBytes) {
-        return { value: serialized, bytes, visitedNodes: metrics.visitedNodes };
+      const serialized = serializeInner(value, 0, path, true, metrics);
+      if (metrics.bytes > limits.maxSerializedValueBytes) {
+        return boundedOversize(metrics.bytes, metrics.visitedNodes);
       }
-      const bounded = truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
-      return {
-        value: bounded,
-        bytes: Buffer2.byteLength(JSON.stringify(bounded), "utf8"),
-        visitedNodes: metrics.visitedNodes
-      };
+      return { value: serialized, bytes: metrics.bytes, visitedNodes: metrics.visitedNodes };
     } catch {
       const failed = typeMarker("unserializable");
       return {
         value: failed,
-        bytes: Buffer2.byteLength(JSON.stringify(failed), "utf8"),
+        bytes: jsonLiteralUtf8Bytes(failed),
         visitedNodes: metrics.visitedNodes
       };
+    } finally {
+      path.clear();
+      if (!reentrant) serializing = false;
     }
   };
   return {
@@ -830,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);
@@ -844,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;
 };
@@ -937,7 +1533,20 @@ var emptyStats = {
   totalInlineWallTimeMs: 0,
   maxInlineWallTimeMs: 0,
   activeEstimatedBytes: 0,
-  peakActiveEstimatedBytes: 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: () => ({
@@ -950,19 +1559,37 @@ var noOpExecution = {
   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: () => ({ ...emptyStats })
+  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)
@@ -977,11 +1604,14 @@ var createExecutionRecorder = (options) => {
   );
   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,
@@ -998,10 +1628,22 @@ 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);
@@ -1014,16 +1656,20 @@ var createExecutionRecorder = (options) => {
     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 = {
+    const plan = storePlan({
       runtimePlanId: nextRuntimePlanId++,
       definition,
       functionId: definition.functionId,
       excluded: excludesSource(definition),
       estimatedCallBytes: estimatedCallBytesFor(definition.functionId)
-    };
+    });
     internedPlans.set(definition.functionId, plan);
     return plan;
   };
@@ -1032,58 +1678,135 @@ var createExecutionRecorder = (options) => {
     if (cached) return cached;
     const prepared = plans.map((encoded) => {
       const definition = definitionFromEncodedPlan(encoded);
-      return {
+      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();
-    for (const byParent of recording.repeatedCalls.values()) {
-      for (const group of byParent.values()) {
-        if (group.summary) {
-          group.summary.totalDurationMs = roundedMilliseconds(group.totalDurationNs);
-        }
+    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 events = recording.events.values().map((event) => event.type === "function_calls_suppressed" ? { ...event } : event);
-    const referencedFunctionIds = new Set(
-      events.flatMap(
-        (event) => event.type === "function_enter" || event.type === "function_calls_suppressed" ? [event.functionId] : []
-      )
-    );
     const state = {
-      version: 2,
+      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) => {
@@ -1099,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, runtimePlanId, parentCallId) => {
-    let byParent = recording.repeatedCalls.get(runtimePlanId);
-    if (!byParent) {
-      byParent = /* @__PURE__ */ new Map();
-      recording.repeatedCalls.set(runtimePlanId, 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, totalDurationNs: 0n };
-      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) => {
@@ -1139,30 +1875,31 @@ var createExecutionRecorder = (options) => {
       }
     };
   };
-  const captureCompletedThrow = (recording, plan, args, parentCallId, startedAtNs, startedAtMs, error) => {
+  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: plan.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);
+      parentCallId,
+      startedAtNs - recording.startedAtNs,
+      capturedArgs,
+      KIND_THROW,
+      endedAtNs - recording.startedAtNs,
+      endedAtNs - startedAtNs,
+      capturedError.value
+    );
     if (retained) {
       stats.functionCallsCaptured++;
       capturedError.commit();
@@ -1170,29 +1907,46 @@ var createExecutionRecorder = (options) => {
     countDroppedEvents(recording, droppedBefore);
     rememberError(error, recording);
   };
-  const recordSuppressedCall = (recording, group, functionId, parentCallId, startedAtMs, startedAtNs, endedAtNs) => {
+  const recordSuppressedCall = (recording, group, parentCallId, startedAtNs, endedAtNs) => {
     stats.repeatedCallsSuppressed++;
-    group.totalDurationNs += endedAtNs - startedAtNs;
-    const endedAtMs = elapsedMs(recording.startedAtNs, endedAtNs);
-    if (!group.summary) {
-      group.summary = {
-        type: "function_calls_suppressed",
-        functionId,
-        timestampMs: startedAtMs,
-        lastTimestampMs: endedAtMs,
-        suppressedCallCount: 1,
-        totalDurationMs: 0,
-        ...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++;
-    if (!recording.events.hasSummary(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;
     if (recording.finished) return;
@@ -1201,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 {
@@ -1218,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);
@@ -1235,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();
           });
@@ -1288,215 +2057,282 @@ var createExecutionRecorder = (options) => {
       return void 0;
     }
   };
-  const runPreparedFunction = (plan, args, callback) => {
-    const store = storage.getStore();
+  const runPreparedFunctionFromStore = (store, plan, args, callback, omitValues) => {
     if (!store || store.recording.finished) return callback();
     stats.functionCallsObserved++;
     const recorderStartedAtNs = process.hrtime.bigint();
     if (store.suppressCapture || plan.excluded) {
       stats.functionCallsExcluded++;
-      return storage.run({ ...store, suppressCapture: true }, () => {
+      return runStore({ ...store, suppressCapture: true }, () => {
         addRecorderTime(store.recording, process.hrtime.bigint() - recorderStartedAtNs);
         return callback();
       });
     }
+    const recording = store.recording;
+    recording.inFlightCalls++;
     const parentCallId = store.currentCallId;
-    const group = repeatedCallGroup(store.recording, plan.runtimePlanId, parentCallId);
+    const group = repeatedCallGroup(recording, plan, parentCallId);
     group.observedCalls++;
-    if (group.observedCalls === 1) {
-      store.recording.functions.set(plan.functionId, plan.definition);
-    }
+    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);
       try {
         const result = callback();
         if (isPromiseLike(result)) {
-          addRecorderTime(store.recording, startedAtNs2 - recorderStartedAtNs);
+          addRecorderTime(recording, startedAtNs2 - recorderStartedAtNs);
           return result.then(
             (value) => {
               const callbackEndedAtNs2 = process.hrtime.bigint();
-              recordSuppressedCall(
-                store.recording,
-                group,
-                plan.functionId,
-                parentCallId,
-                startedAtMs,
-                startedAtNs2,
-                callbackEndedAtNs2
-              );
-              addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              recordSuppressedCall(recording, group, parentCallId, startedAtNs2, callbackEndedAtNs2);
+              addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              settleInFlight(recording);
               return value;
             },
             (error) => {
               const callbackEndedAtNs2 = process.hrtime.bigint();
-              captureCompletedThrow(
-                store.recording,
-                plan,
-                args,
-                parentCallId,
-                startedAtNs2,
-                startedAtMs,
-                error
-              );
-              addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs2, error);
+              addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs2);
+              settleInFlight(recording);
               throw error;
             }
           );
         }
         const callbackEndedAtNs = process.hrtime.bigint();
-        recordSuppressedCall(
-          store.recording,
-          group,
-          plan.functionId,
-          parentCallId,
-          startedAtMs,
-          startedAtNs2,
-          callbackEndedAtNs
-        );
-        addRecorderTime(store.recording, startedAtNs2 - recorderStartedAtNs);
-        addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs);
+        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(
-          store.recording,
-          plan,
-          args,
-          parentCallId,
-          startedAtNs2,
-          startedAtMs,
-          error
-        );
-        addRecorderTime(store.recording, startedAtNs2 - recorderStartedAtNs);
-        addRecorderTime(store.recording, process.hrtime.bigint() - callbackEndedAtNs);
+        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 (!store.recording.events.canStartCall()) {
-      const startedAtMs = elapsedMs(store.recording.startedAtNs, startedAtNs);
+    if (!journal) {
+      memoryBudget.reserveCall(recording.memory, plan.estimatedCallBytes);
+      return runStore(
+        store,
+        () => observeRecordedCallback(
+          recording,
+          recorderStartedAtNs,
+          callback,
+          () => settleInFlight(recording),
+          (error) => {
+            rememberError(error, recording);
+            settleInFlight(recording);
+          }
+        )
+      );
+    }
+    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,
-            plan,
-            args,
-            parentCallId,
-            startedAtNs,
-            startedAtMs,
-            error
-          )
+          (error) => {
+            captureCompletedThrow(recording, plan, args, parentCallId, startedAtNs, error);
+            settleInFlight(recording);
+          }
         )
       );
     }
-    if (!memoryBudget.reserveCall(store.recording.memory, plan.estimatedCallBytes)) {
+    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: plan.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)
-          });
-          stats.functionCallsCaptured++;
+          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) => runPreparedFunction(preparePlan(normalizeFunctionDefinition(input)), args, callback);
-  const runFunctionPlans = (plans, planIndex, args, callback) => {
+  const runPreparedFunction = (plan, args, callback, omitValues) => {
+    const store = storage.getStore();
+    if (store && !store.recording.finished && !store.recording.sawAutomatic) {
+      store.recording.sawAutomatic = true;
+    }
+    return runPreparedFunctionFromStore(store, plan, args, callback, omitValues);
+  };
+  const runFunction = (input, args, callback) => {
+    const store = storage.getStore();
+    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 = storage.getStore();
     const plan = preparedPlansFor(plans)[planIndex];
-    return plan ? runPreparedFunction(plan, args, callback) : callback();
+    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 traced(...args) {
-      return runPreparedFunction(plan, args, () => fn.apply(this, args));
+      const store = storage.getStore();
+      if (store && !store.recording.finished) store.recording.sawManual = true;
+      return runPreparedFunctionFromStore(store, 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 runtimes = [];
-  return {
-    __rasputinRuntimeRegistry: true,
-    runtimes,
+  const registry = {
+    runtimes: [],
+    modules: [],
+    captureRoot: passthroughCapture,
     register(plans) {
-      return (planIndex, args, callback) => {
-        const runtime = runtimes.at(-1);
-        return runtime ? runtime.run(plans, planIndex, args, callback) : callback();
-      };
+      return registerModule(registry, plans);
     }
   };
+  return registry;
 };
 var getAutomaticRuntimeRegistry = () => {
   const existing = Reflect.get(globalThis, runtimeSymbol);
-  if (existing && Array.isArray(existing.runtimes) && typeof existing.register === "function") {
-    existing.__rasputinRuntimeRegistry = true;
+  if (existing && typeof existing === "object" && isRegistry(existing)) {
+    if (typeof existing.captureRoot !== "function") {
+      existing.captureRoot = passthroughCapture;
+    }
     return existing;
   }
   const registry = createRegistry();
@@ -1506,12 +2342,27 @@ var getAutomaticRuntimeRegistry = () => {
 var installAutomaticExecutionRuntime = (execution) => {
   const registry = getAutomaticRuntimeRegistry();
   const runtime = {
-    run: (plans, planIndex, args, callback) => execution.runFunctionPlans(plans, planIndex, args, callback)
+    bind(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();
+      };
+    },
+    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);
+    }
   };
 };
 
@@ -1572,7 +2423,7 @@ import {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/node";
-var SDK_VERSION = "0.5.0-alpha.1";
+var SDK_VERSION = "0.5.0-alpha.11";
 
 // src/rasputin-init.ts
 var withExecution = (client, execution, installRuntime, manifest) => {