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

package/dist/index.js

@@ -1,27 +1,122 @@
+// src/transport/node-http-fetch.ts
+import * as http from "node:http";
+import * as https from "node:https";
+var headerRecord = (headers) => {
+  const view = new Headers(headers);
+  const record = {};
+  view.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+};
+var writeBody = (req, body) => {
+  if (body == null) {
+    req.end();
+    return;
+  }
+  if (typeof body === "string" || body instanceof Uint8Array) {
+    req.end(body);
+    return;
+  }
+  req.end();
+};
+var nodeHttpFetch = (input, init) => new Promise((resolve4, reject) => {
+  let parsed;
+  try {
+    parsed = new URL(String(input));
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  const lib = parsed.protocol === "https:" ? https : http;
+  const req = lib.request(
+    {
+      protocol: parsed.protocol,
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: `${parsed.pathname}${parsed.search}`,
+      method: init?.method ?? "GET",
+      headers: headerRecord(init?.headers)
+    },
+    (response) => {
+      const chunks = [];
+      response.on("data", (chunk) => {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      response.on("end", () => {
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(response.headers)) {
+          if (value === void 0) continue;
+          if (Array.isArray(value)) {
+            for (const item of value) headers.append(key, item);
+          } else {
+            headers.set(key, value);
+          }
+        }
+        resolve4(
+          new Response(Buffer.concat(chunks), {
+            status: response.statusCode ?? 0,
+            headers
+          })
+        );
+      });
+    }
+  );
+  const abort = () => {
+    req.destroy();
+    reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
+  };
+  if (init?.signal) {
+    if (init.signal.aborted) {
+      abort();
+      return;
+    }
+    init.signal.addEventListener("abort", abort, { once: true });
+  }
+  req.setTimeout(1e4, abort);
+  req.on("error", reject);
+  writeBody(req, init?.body ?? null);
+});
+var defaultIngestFetch = () => process.versions.bun ? globalThis.fetch : nodeHttpFetch;
+
 // src/announce-deploy/announce-deploy.ts
+var trimmedString = (value) => typeof value === "string" ? value.trim() : "";
 var announceDeploy = async (options) => {
-  if (options.enabled === false) return "skipped";
-  const release = options.release?.trim() ?? "";
-  const environment = options.environment.trim();
-  if (!environment) return "skipped";
-  const fetchFn = options.fetch ?? globalThis.fetch;
   try {
-    const response = await fetchFn(options.deployUrl, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${options.projectApiKey}`,
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      },
-      body: JSON.stringify({ release, environment })
-    });
-    if (response.ok) return "ok";
-    return "failed";
+    if (options.enabled === false) return "skipped";
+    const release = trimmedString(options.release);
+    const environment = trimmedString(options.environment);
+    if (!environment) return "skipped";
+    const fetchFn = options.fetch ?? defaultIngestFetch();
+    const timeout = new AbortController();
+    const timer = setTimeout(() => timeout.abort(), 2e3);
+    timer.unref?.();
+    try {
+      const response = await fetchFn(options.deployUrl, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${options.projectApiKey}`,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify({ release, environment }),
+        signal: timeout.signal
+      });
+      if (response.ok) return "ok";
+      return "failed";
+    } catch {
+      return "failed";
+    } finally {
+      clearTimeout(timer);
+    }
   } catch {
     return "failed";
   }
 };
 
+// src/create-client/create-client.ts
+import { Buffer as Buffer2 } from "node:buffer";
+
 // src/create-ingest-event/truncate-ingest-message.ts
 var MAX_MESSAGE_BYTES = 8 * 1024;
 var utf8Bytes = (value) => Buffer.byteLength(value, "utf8");
@@ -213,74 +308,41 @@ var finalizeResolution = (resolution, stackFrames) => {
   return "exact";
 };
 
-// src/detect-release/detect-release.ts
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-var ENV_KEYS = [
-  "RASPUTIN_RELEASE",
-  "VERCEL_GIT_COMMIT_SHA",
-  "RAILWAY_GIT_COMMIT_SHA",
-  "RENDER_GIT_COMMIT",
-  "COMMIT_REF",
-  "CF_PAGES_COMMIT_SHA",
-  "HEROKU_SLUG_COMMIT",
-  "GIT_COMMIT",
-  "COMMIT_SHA",
-  "GIT_SHA"
-];
-var SHA_RE = /^[0-9a-f]{7,40}$/i;
-var isSha = (value) => SHA_RE.test(value);
-var warnInvalid = (source, value) => {
-  console.warn(
-    `[rasputin] Ignoring invalid release from ${source}: "${value}". Expected a git commit SHA (7\u201340 hex characters).`
-  );
-};
-var readGitHead = (cwd) => {
-  try {
-    const gitDir = join(cwd, ".git");
-    const head = readFileSync(join(gitDir, "HEAD"), "utf8").trim();
-    if (isSha(head)) return head;
-    const ref = head.replace(/^ref:\s*/, "");
-    try {
-      const sha = readFileSync(join(gitDir, ref), "utf8").trim();
-      return isSha(sha) ? sha : void 0;
-    } catch {
-      const packed = readFileSync(join(gitDir, "packed-refs"), "utf8");
-      const match = packed.match(new RegExp(`^([0-9a-f]{40}) ${ref}$`, "m"));
-      return match?.[1];
-    }
-  } catch {
-    return void 0;
-  }
-};
-var detectRelease = (options = {}) => {
-  const explicit = options.release?.trim();
-  if (explicit) {
-    if (isSha(explicit)) return explicit;
-    warnInvalid("release option", explicit);
-  }
-  const env = options.env ?? process.env;
-  for (const key of ENV_KEYS) {
-    const value = env[key]?.trim();
-    if (!value) continue;
-    if (isSha(value)) return value;
-    warnInvalid(key, value);
-  }
-  const fromGit = readGitHead(options.cwd ?? process.cwd());
-  if (fromGit) return fromGit;
-  console.warn(
-    "[rasputin] No release detected. Set `RASPUTIN_RELEASE` to your git commit SHA, pass `release` in RasputinInit, or deploy on a platform that exposes a commit SHA env var (e.g. VERCEL_GIT_COMMIT_SHA). Events are not sent without a release."
-  );
-  return void 0;
-};
-
 // src/normalize-frames/normalize-frames.ts
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
+// src/parse-stack/fold-synthetic-frames.ts
+var RASPUTIN_SHELL_PREFIX = "__rasputinShell__";
+var RASPUTIN_HANDLE_RUN_PREFIX = "__rasputinHandleRun__";
+var frameFile = (frame) => (frame.file ?? frame.generated?.file ?? "").replaceAll("\\", "/");
+var functionName = (frame) => frame.function ?? "";
+var coreFunctionName = (name) => name.trim().replace(/^(async|new|get|set|bound)\s+/, "").replace(/^Object\./, "");
+var isRasputinShellFrame = (name) => typeof name === "string" && coreFunctionName(name).startsWith(RASPUTIN_SHELL_PREFIX);
+var isRasputinHandleRunFrame = (name) => typeof name === "string" && coreFunctionName(name).startsWith(RASPUTIN_HANDLE_RUN_PREFIX);
+var isEngineAsyncStoreFile = (file) => /^(node:|bun:)/i.test(file) && /async[_-]?hooks|async_local_storage|async_context_frame/i.test(file);
+var isInternalAsyncStoreFrame = (frame) => {
+  const name = functionName(frame);
+  const file = frameFile(frame);
+  if (name === "AsyncLocalStorage.run") return true;
+  if ((name === "run" || name === "Object.run") && isEngineAsyncStoreFile(file)) return true;
+  return false;
+};
+var isSyntheticRasputinFrame = (frame) => {
+  const name = functionName(frame);
+  if (isRasputinShellFrame(name) || isRasputinHandleRunFrame(name)) return true;
+  return isInternalAsyncStoreFrame(frame);
+};
+var foldSyntheticFrames = (frames) => {
+  const filtered = frames.filter((frame) => !isSyntheticRasputinFrame(frame));
+  if (filtered.length > 0) return filtered;
+  const withoutInternals = frames.filter((frame) => !isInternalAsyncStoreFrame(frame));
+  return withoutInternals.length > 0 ? withoutInternals : [...frames];
+};
+
 // src/source-identity/source-identity.ts
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 var packageBoundaryByDirectory = /* @__PURE__ */ new Map();
@@ -307,7 +369,7 @@ var readPackageBoundary = (directory) => {
     if (existsSync(packageJson)) {
       let name;
       try {
-        const parsed = JSON.parse(readFileSync2(packageJson, "utf8"));
+        const parsed = JSON.parse(readFileSync(packageJson, "utf8"));
         if (typeof parsed.name === "string" && parsed.name.trim()) name = parsed.name.trim();
       } catch {
       }
@@ -390,7 +452,7 @@ var isInApp = (file, absolute, underRoot, source) => {
 };
 var normalizeFrames = (frames, options) => {
   const appRoot = options.appRoot;
-  return frames.map((frame) => {
+  return foldSyntheticFrames(frames).map((frame) => {
     const generated = normalizeFile(frame.generated.file, appRoot);
     const original = frame.original ? normalizeFile(frame.original.file, appRoot) : void 0;
     const generatedSource = generated.absolute ? sourceLocatorFromFile(generated.absolute) : void 0;
@@ -481,10 +543,10 @@ var parseStack = (stack) => {
 
 // src/repo-root/repo-root-from.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname2, join as join2, resolve as resolve3 } from "node:path";
+import { dirname as dirname2, join, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-var isGitRoot = (dir) => existsSync2(join2(dir, ".git"));
-var hasPackageJson = (dir) => existsSync2(join2(dir, "package.json"));
+var isGitRoot = (dir) => existsSync2(join(dir, ".git"));
+var hasPackageJson = (dir) => existsSync2(join(dir, "package.json"));
 var repoRootFrom = (moduleUrl) => {
   let current = resolve3(dirname2(fileURLToPath3(moduleUrl)));
   let packageRoot;
@@ -542,12 +604,39 @@ Or set repoRoot yourself.
 
 // src/resolve-source-maps/resolve-source-maps.ts
 import { readFile } from "node:fs/promises";
-import { dirname as dirname3, isAbsolute as isAbsolute3, join as join3 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join2 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { LEAST_UPPER_BOUND, originalPositionFor, TraceMap } from "@jridgewell/trace-mapping";
 var SOURCE_EXT2 = /\.(ts|tsx|mts|cts)$/i;
 var SOURCEMAP_COMMENT = /(?:\/\/[#@][ \t]*sourceMappingURL=([^\s'"]+)|\/\*[#@][ \t]*sourceMappingURL=([^\s*'"]+)[ \t]*\*\/)\s*$/;
+var MAX_MAP_CACHE = 64;
+var MAX_MAP_CACHE_BYTES = 8 * 1024 * 1024;
 var mapCache = /* @__PURE__ */ new Map();
+var mapCacheBytesByPath = /* @__PURE__ */ new Map();
+var mapCacheBytes = 0;
+var evictOldestMap = () => {
+  const oldest = mapCache.keys().next().value;
+  if (oldest === void 0) return false;
+  mapCache.delete(oldest);
+  mapCacheBytes = Math.max(0, mapCacheBytes - (mapCacheBytesByPath.get(oldest) ?? 0));
+  mapCacheBytesByPath.delete(oldest);
+  return true;
+};
+var setMapCache = (generatedPath, map, bytes) => {
+  const previous = mapCacheBytesByPath.get(generatedPath) ?? 0;
+  if (mapCache.has(generatedPath)) {
+    mapCache.delete(generatedPath);
+    mapCacheBytes = Math.max(0, mapCacheBytes - previous);
+    mapCacheBytesByPath.delete(generatedPath);
+  }
+  if (bytes > MAX_MAP_CACHE_BYTES) return;
+  while ((mapCache.size >= MAX_MAP_CACHE || mapCacheBytes + bytes > MAX_MAP_CACHE_BYTES) && evictOldestMap()) {
+  }
+  if (mapCacheBytes + bytes > MAX_MAP_CACHE_BYTES) return;
+  mapCache.set(generatedPath, map);
+  mapCacheBytesByPath.set(generatedPath, bytes);
+  mapCacheBytes += bytes;
+};
 var toPath = (file) => {
   if (file.startsWith("file://")) {
     try {
@@ -592,7 +681,7 @@ var readMapPayload = async (generatedPath) => {
   if (comment?.startsWith("data:")) return decodeDataUrl(comment);
   if (comment) {
     try {
-      return await readFile(join3(dirname3(generatedPath), comment), "utf8");
+      return await readFile(join2(dirname3(generatedPath), comment), "utf8");
     } catch {
     }
   }
@@ -604,18 +693,25 @@ var readMapPayload = async (generatedPath) => {
 };
 var loadTraceMap = async (generatedPath) => {
   const cached = mapCache.get(generatedPath);
-  if (cached !== void 0) return cached;
+  if (cached !== void 0) {
+    const bytes = mapCacheBytesByPath.get(generatedPath) ?? 0;
+    mapCache.delete(generatedPath);
+    mapCacheBytesByPath.delete(generatedPath);
+    mapCache.set(generatedPath, cached);
+    mapCacheBytesByPath.set(generatedPath, bytes);
+    return cached;
+  }
   const payload = await readMapPayload(generatedPath);
   if (!payload) {
-    mapCache.set(generatedPath, null);
+    setMapCache(generatedPath, null, 0);
     return null;
   }
   try {
     const map = new TraceMap(payload);
-    mapCache.set(generatedPath, map);
+    setMapCache(generatedPath, map, payload.length);
     return map;
   } catch {
-    mapCache.set(generatedPath, null);
+    setMapCache(generatedPath, null, payload.length);
     return null;
   }
 };
@@ -639,7 +735,7 @@ var resolveFrame = async (raw) => {
   return {
     ...base,
     original: {
-      file: isAbsolute3(pos.source) ? pos.source : join3(dirname3(generatedPath), pos.source),
+      file: isAbsolute3(pos.source) ? pos.source : join2(dirname3(generatedPath), pos.source),
       line: pos.line,
       column: pos.column ?? void 0,
       name: pos.name ?? void 0
@@ -659,7 +755,7 @@ var resolveSourceMaps = async (frames) => {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/core";
-var SDK_VERSION = "0.5.0-alpha.9";
+var SDK_VERSION = "0.5.1";
 
 // src/suppression/identity-needs-message-template.ts
 var identityNeedsMessageTemplate = (type, code) => {
@@ -798,7 +894,8 @@ var computeBurstKey = (errorType, message, code, frames) => {
 var DEFAULTS = {
   windowMs: 6e4,
   capPerWindow: 5,
-  maxBurstBuckets: 1e3
+  maxBurstBuckets: 1e3,
+  maxPendingSummaries: 1e3
 };
 var sameDim = (a, b) => (a ?? null) === (b ?? null);
 var captureIdentity = (input) => ({
@@ -813,8 +910,14 @@ var createSuppression = (options = {}) => {
   const windowMs = options.windowMs ?? DEFAULTS.windowMs;
   const capPerWindow = options.capPerWindow ?? DEFAULTS.capPerWindow;
   const maxBurstBuckets = options.maxBurstBuckets ?? DEFAULTS.maxBurstBuckets;
+  const maxPendingSummaries = options.maxPendingSummaries ?? DEFAULTS.maxPendingSummaries;
   const burstBuckets = /* @__PURE__ */ new Map();
   const pending = [];
+  const pushPending = (draft) => {
+    pending.push(draft);
+    if (pending.length > maxPendingSummaries)
+      pending.splice(0, pending.length - maxPendingSummaries);
+  };
   const touch = (burstKey, bucket) => {
     burstBuckets.delete(burstKey);
     burstBuckets.set(burstKey, bucket);
@@ -825,7 +928,7 @@ var createSuppression = (options = {}) => {
       if (oldest === void 0) break;
       const bucket = burstBuckets.get(oldest);
       if (bucket && bucket.suppressed > 0) {
-        pending.push(toDraft(bucket, Date.now()));
+        pushPending(toDraft(bucket, Date.now()));
       }
       burstBuckets.delete(oldest);
     }
@@ -849,7 +952,7 @@ var createSuppression = (options = {}) => {
   });
   const flushSuppressed = (bucket, windowEndMs) => {
     if (bucket.suppressed <= 0) return;
-    pending.push(toDraft(bucket, windowEndMs));
+    pushPending(toDraft(bucket, windowEndMs));
     bucket.suppressed = 0;
   };
   const decide = (input) => {
@@ -939,14 +1042,75 @@ var createSuppression = (options = {}) => {
   };
 };
 
+// src/transport/process-shutdown-hooks.ts
+var SIGNAL_EXIT_CODES = { SIGTERM: 143, SIGINT: 130 };
+var RASPUTIN_PROCESS_LISTENER = Symbol.for("rasputin.process.listener.v1");
+var removeProcessListener = process.off.bind(process);
+var tagListener = (listener) => {
+  Object.defineProperty(listener, RASPUTIN_PROCESS_LISTENER, { value: true });
+  return listener;
+};
+var hostProcessListenerCount = (event) => {
+  const listeners = event === "beforeExit" ? process.listeners("beforeExit") : process.listeners(event);
+  return listeners.filter((listener) => !(RASPUTIN_PROCESS_LISTENER in listener)).length;
+};
+var exitAfterFlush = (done, code) => {
+  void done.finally(() => {
+    process.exit(code);
+  });
+};
+var participants = /* @__PURE__ */ new Set();
+var installed = false;
+var shuttingDown = false;
+var onBeforeExit = tagListener(() => {
+  for (const participant of participants) participant.onBeforeExit();
+});
+var handleSignal = (signal) => {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  const hostOwns = hostProcessListenerCount(signal) > 0;
+  const snapshot = [...participants];
+  const done = Promise.all(snapshot.map((participant) => participant.onSignal().catch(() => {
+  }))).then(() => {
+    for (const participant of snapshot) participant.dropRemaining();
+  }).then(() => {
+  });
+  if (!hostOwns) exitAfterFlush(done, SIGNAL_EXIT_CODES[signal] ?? 143);
+};
+var onTerm = tagListener(() => {
+  handleSignal("SIGTERM");
+});
+var onInt = tagListener(() => {
+  handleSignal("SIGINT");
+});
+var registerProcessShutdownHooks = (participant) => {
+  participants.add(participant);
+  if (!installed) {
+    process.on("beforeExit", onBeforeExit);
+    process.on("SIGTERM", onTerm);
+    process.on("SIGINT", onInt);
+    installed = true;
+  }
+  return () => {
+    participants.delete(participant);
+    if (participants.size > 0 || !installed) return;
+    removeProcessListener("beforeExit", onBeforeExit);
+    removeProcessListener("SIGTERM", onTerm);
+    removeProcessListener("SIGINT", onInt);
+    installed = false;
+    shuttingDown = false;
+  };
+};
+
 // src/transport/send-batch.ts
 import { gzipSync } from "node:zlib";
 var sleep = (ms, signal) => new Promise((resolve4) => {
-  if (signal?.aborted) {
+  if (ms <= 0 || signal?.aborted) {
     resolve4();
     return;
   }
   const timer = setTimeout(resolve4, ms);
+  timer.unref?.();
   signal?.addEventListener(
     "abort",
     () => {
@@ -960,6 +1124,25 @@ var backoffMs = (attempt) => {
   const base = Math.min(3e4, 500 * 2 ** attempt);
   return Math.floor(base * (0.5 + Math.random()));
 };
+var abortError = () => Object.assign(new Error("aborted"), { name: "AbortError" });
+var fetchUntilAborted = (fetchFn, url, init) => new Promise((resolve4, reject) => {
+  if (init.signal.aborted) {
+    reject(abortError());
+    return;
+  }
+  const onAbort = () => reject(abortError());
+  init.signal.addEventListener("abort", onAbort, { once: true });
+  void fetchFn(url, init).then(
+    (value) => {
+      init.signal.removeEventListener("abort", onAbort);
+      resolve4(value);
+    },
+    (error) => {
+      init.signal.removeEventListener("abort", onAbort);
+      reject(error);
+    }
+  );
+});
 var retryAfterMs = (response) => {
   const header = response.headers.get("retry-after");
   if (!header) return null;
@@ -994,14 +1177,22 @@ var sendBatch = async (options) => {
     failureKind,
     statusCode
   });
+  const abortAfter = (ms) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), ms);
+    timer.unref?.();
+    return { signal: controller.signal, cancel: () => clearTimeout(timer) };
+  };
+  const requestTimeoutMs = options.requestTimeoutMs ?? 2e3;
   const json = JSON.stringify(payload);
+  const jsonBytes = Buffer.byteLength(json, "utf8");
   const headers = {
     Authorization: `Bearer ${options.projectApiKey}`,
     "Content-Type": "application/json",
     Accept: "application/json"
   };
   let body = json;
-  if (Buffer.byteLength(json, "utf8") >= options.gzipThresholdBytes) {
+  if (jsonBytes >= options.gzipThresholdBytes) {
     const compressed = gzipSync(json);
     const bytes = new Uint8Array(compressed.byteLength);
     bytes.set(compressed);
@@ -1010,13 +1201,15 @@ var sendBatch = async (options) => {
   }
   for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
     if (options.signal?.aborted) return result("failed", "aborted");
+    attempts++;
+    const timeout = abortAfter(requestTimeoutMs);
+    const signal = options.signal ? AbortSignal.any([options.signal, timeout.signal]) : timeout.signal;
     try {
-      attempts++;
-      const response = await options.fetch(options.ingestUrl, {
+      const response = await fetchUntilAborted(options.fetch, options.ingestUrl, {
         method: "POST",
         headers,
         body,
-        signal: options.signal
+        signal
       });
       if (response.ok) return result("ok");
       if (response.status === 429) {
@@ -1038,6 +1231,8 @@ var sendBatch = async (options) => {
       networkErrors++;
       if (attempt === options.maxRetries) return result("failed", "network_error");
       await sleep(backoffMs(attempt), options.signal);
+    } finally {
+      timeout.cancel();
     }
   }
   return result("failed", options.signal?.aborted ? "aborted" : "network_error");
@@ -1049,11 +1244,40 @@ var RANK = {
   summary: 1,
   first: 2
 };
-var createQueue = (maxSize) => {
+var createQueue = (maxSize, maxBytes = 8 * 1024 * 1024) => {
   const items = [];
+  const itemBytes = [];
   let enqueued = 0;
   let droppedIncoming = 0;
   let droppedQueued = 0;
+  let queuedBytes = 0;
+  let reservedBytes = 0;
+  const estimateBytes = (item) => {
+    let bytes = 256;
+    try {
+      bytes = Buffer.byteLength(
+        JSON.stringify(item.kind === "event" ? item.event : item.summary),
+        "utf8"
+      );
+    } catch {
+      bytes = 256;
+    }
+    for (const frame of item.rawFrames) {
+      try {
+        bytes += Buffer.byteLength(JSON.stringify(frame), "utf8");
+      } catch {
+        bytes += 64;
+      }
+    }
+    return bytes;
+  };
+  const dropAt = (index) => {
+    const bytes = itemBytes[index] ?? 0;
+    items.splice(index, 1);
+    itemBytes.splice(index, 1);
+    queuedBytes = Math.max(0, queuedBytes - bytes);
+    droppedQueued++;
+  };
   const oldestLowestIndex = () => {
     let best = 0;
     for (let i = 1; i < items.length; i++) {
@@ -1065,7 +1289,17 @@ var createQueue = (maxSize) => {
     return best;
   };
   const enqueue = (item) => {
-    while (items.length >= maxSize) {
+    const bytes = item.encodedBytes ?? estimateBytes(item);
+    item.encodedBytes = bytes;
+    if (bytes > maxBytes) {
+      droppedIncoming++;
+      return;
+    }
+    while (items.length >= maxSize || queuedBytes + reservedBytes + bytes > maxBytes) {
+      if (items.length === 0) {
+        droppedIncoming++;
+        return;
+      }
       const victimIndex = oldestLowestIndex();
       const victim = items[victimIndex];
       if (!victim) break;
@@ -1073,16 +1307,25 @@ var createQueue = (maxSize) => {
         droppedIncoming++;
         return;
       }
-      items.splice(victimIndex, 1);
-      droppedQueued++;
+      dropAt(victimIndex);
     }
     items.push(item);
+    itemBytes.push(bytes);
+    queuedBytes += bytes;
     enqueued++;
   };
-  const drain = (count) => items.splice(0, count);
+  const drain = (count) => {
+    const drained = items.splice(0, count);
+    const drainedBytes = itemBytes.splice(0, count);
+    for (const size of drainedBytes) queuedBytes = Math.max(0, queuedBytes - size);
+    return drained;
+  };
   return {
     enqueue,
     drain,
+    setReservedBytes: (bytes) => {
+      reservedBytes = Math.max(0, bytes);
+    },
     size: () => items.length,
     getStats: () => ({
       queued: items.length,
@@ -1093,6 +1336,8 @@ var createQueue = (maxSize) => {
     }),
     clear: () => {
       items.length = 0;
+      itemBytes.length = 0;
+      queuedBytes = 0;
     }
   };
 };
@@ -1101,25 +1346,15 @@ var createQueue = (maxSize) => {
 var DEFAULTS2 = {
   enabled: true,
   maxQueueSize: 500,
+  maxQueueBytes: 8 * 1024 * 1024,
   batchSize: 30,
   flushIntervalMs: 5e3,
   gzipThresholdBytes: 10 * 1024,
   maxRetries: 5,
-  installSignalHandlers: true
-};
-var removeProcessListener = process.off.bind(process);
-var holdProcessExitUntil = (done) => {
-  const nativeExit = process.exit.bind(process);
-  let heldCode;
-  const restore = () => {
-    process.exit = nativeExit;
-    if (heldCode !== void 0) nativeExit(heldCode);
-  };
-  const holdExit = ((code) => {
-    heldCode = code ?? 0;
-  });
-  process.exit = holdExit;
-  void done.finally(restore);
+  installSignalHandlers: true,
+  maxBatchReplays: 8,
+  maxRetryBatchAgeMs: 6e4,
+  shutdownFlushMs: 2e3
 };
 var createTransport = (options) => {
   const enabled = options.enabled ?? DEFAULTS2.enabled;
@@ -1127,12 +1362,16 @@ var createTransport = (options) => {
   const flushIntervalMs = options.flushIntervalMs ?? DEFAULTS2.flushIntervalMs;
   const gzipThresholdBytes = options.gzipThresholdBytes ?? DEFAULTS2.gzipThresholdBytes;
   const maxRetries = options.maxRetries ?? DEFAULTS2.maxRetries;
-  const fetchFn = options.fetch ?? globalThis.fetch;
-  const queue = createQueue(options.maxQueueSize ?? DEFAULTS2.maxQueueSize);
+  const requestTimeoutMs = options.requestTimeoutMs ?? 2e3;
+  const fetchFn = options.fetch ?? defaultIngestFetch();
+  const queue = createQueue(
+    options.maxQueueSize ?? DEFAULTS2.maxQueueSize,
+    options.maxQueueBytes ?? DEFAULTS2.maxQueueBytes
+  );
   let timer;
   let flushing;
   let closed = false;
-  let shuttingDown = false;
+  let shuttingDown2 = false;
   let retryBatch = null;
   let flushesStarted = 0;
   let flushesJoined = 0;
@@ -1148,10 +1387,45 @@ var createTransport = (options) => {
   let serverErrorResponses = 0;
   let lastFailureKind = null;
   let lastFailureStatusCode = null;
+  let flushAbort;
+  let flushAbortTimer;
+  let flushDeadlineMs = 0;
+  let inFlightBytes = 0;
+  let retryBytes = 0;
+  const estimateItemsBytes = (items) => {
+    let bytes = 0;
+    for (const item of items) {
+      bytes += item.encodedBytes ?? 256;
+    }
+    return bytes;
+  };
+  const syncReservedBytes = () => {
+    queue.setReservedBytes(inFlightBytes + retryBytes);
+  };
+  const setFlushDeadline = (timeoutMs, holdProcess = false) => {
+    const nextDeadline = timeoutMs > 0 ? Date.now() + timeoutMs : Number.POSITIVE_INFINITY;
+    if (flushAbort && nextDeadline >= flushDeadlineMs) return;
+    flushDeadlineMs = nextDeadline;
+    if (!flushAbort) flushAbort = new AbortController();
+    if (flushAbortTimer) clearTimeout(flushAbortTimer);
+    if (Number.isFinite(nextDeadline)) {
+      flushAbortTimer = setTimeout(
+        () => flushAbort?.abort(),
+        Math.max(0, nextDeadline - Date.now())
+      );
+      if (!holdProcess) flushAbortTimer.unref?.();
+    }
+  };
+  const clearFlushDeadline = () => {
+    if (flushAbortTimer) clearTimeout(flushAbortTimer);
+    flushAbortTimer = void 0;
+    flushAbort = void 0;
+    flushDeadlineMs = 0;
+  };
   const schedule = () => {
-    if (timer || !enabled || closed) return;
+    if (timer || !enabled || closed || shuttingDown2) return;
     timer = setInterval(() => {
-      void flush();
+      void kickBackgroundFlush();
     }, flushIntervalMs);
     timer.unref?.();
   };
@@ -1169,40 +1443,81 @@ var createTransport = (options) => {
       return item.summary;
     }
   };
-  const performFlush = async (timeoutMs) => {
-    const controller = new AbortController();
-    const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
+  const whenAborted = (signal) => new Promise((_, reject) => {
+    const abort = () => reject(signal.reason ?? new Error("aborted"));
+    if (signal.aborted) {
+      abort();
+      return;
+    }
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  const performFlush = async () => {
+    options.beforeFlush?.();
+    const controller = flushAbort ?? new AbortController();
     try {
       while (queue.size() > 0 || retryBatch) {
         if (controller.signal.aborted) break;
         const replaying = retryBatch !== null;
         const batch = retryBatch?.items ?? queue.drain(batchSize);
         const idempotencyKey = retryBatch?.idempotencyKey ?? crypto.randomUUID();
+        const retryCreatedAt = retryBatch?.createdAt ?? Date.now();
+        const retryReplays = retryBatch?.replays ?? 0;
         retryBatch = null;
+        retryBytes = 0;
+        inFlightBytes = estimateItemsBytes(batch);
+        syncReservedBytes();
         if (batch.length === 0) break;
         if (replaying) batchReplays++;
         const events = [];
         const summaries = [];
         for (const item of batch) {
+          if (controller.signal.aborted) break;
           if (item.kind === "summary") {
-            summaries.push(await prepareSummary(item));
+            try {
+              summaries.push(
+                await Promise.race([prepareSummary(item), whenAborted(controller.signal)])
+              );
+            } catch {
+              if (controller.signal.aborted) break;
+              summaries.push(item.summary);
+            }
             continue;
           }
           if (options.prepareEvent && item.rawFrames.length > 0) {
             try {
               events.push(
-                await options.prepareEvent({
-                  event: item.event,
-                  rawFrames: item.rawFrames
-                })
+                await Promise.race([
+                  options.prepareEvent({
+                    event: item.event,
+                    rawFrames: item.rawFrames
+                  }),
+                  whenAborted(controller.signal)
+                ])
               );
             } catch {
+              if (controller.signal.aborted) break;
               events.push(item.event);
             }
           } else {
             events.push(item.event);
           }
         }
+        const retainOrDrop = (nextReplays, createdAt) => {
+          if (nextReplays >= DEFAULTS2.maxBatchReplays || Date.now() - createdAt >= DEFAULTS2.maxRetryBatchAgeMs) {
+            batchesDropped++;
+            retryBatch = null;
+            retryBytes = 0;
+          } else {
+            retryBatch = { items: batch, idempotencyKey, createdAt, replays: nextReplays };
+            retryBytes = inFlightBytes;
+          }
+          inFlightBytes = 0;
+          syncReservedBytes();
+        };
+        if (controller.signal.aborted) {
+          retainOrDrop((replaying ? retryReplays : 0) + 1, replaying ? retryCreatedAt : Date.now());
+          break;
+        }
         const result = await sendBatch({
           ingestUrl: options.ingestUrl,
           projectApiKey: options.projectApiKey,
@@ -1212,7 +1527,8 @@ var createTransport = (options) => {
           sdkVersion: options.sdkVersion,
           sdkName: options.sdkName,
           gzipThresholdBytes,
-          maxRetries,
+          maxRetries: shuttingDown2 ? 0 : maxRetries,
+          requestTimeoutMs,
           fetch: fetchFn,
           signal: controller.signal
         });
@@ -1230,70 +1546,120 @@ var createTransport = (options) => {
           else batchesFailed++;
         }
         if (result.outcome === "failed") {
-          retryBatch = { items: batch, idempotencyKey };
+          retainOrDrop(
+            result.aborted ? (replaying ? retryReplays : 0) + 1 : replaying ? retryReplays + 1 : 0,
+            replaying ? retryCreatedAt : Date.now()
+          );
           break;
         }
+        inFlightBytes = 0;
+        syncReservedBytes();
       }
     } finally {
-      if (timeout) clearTimeout(timeout);
+      clearFlushDeadline();
       if (queue.size() === 0 && !retryBatch) stopTimer();
     }
   };
+  const startFlushWorker = () => {
+    if (flushing) return flushing;
+    flushesStarted++;
+    let settle;
+    const activeFlush = new Promise((resolve4, reject) => {
+      settle = (work) => {
+        void work.then(resolve4, reject);
+      };
+    });
+    flushing = activeFlush;
+    settle(performFlush());
+    void activeFlush.finally(() => {
+      if (flushing === activeFlush) flushing = void 0;
+    });
+    return activeFlush;
+  };
+  const kickBackgroundFlush = () => {
+    if (!enabled || closed || shuttingDown2) return;
+    setFlushDeadline(1e4, false);
+    if (flushing) return;
+    startFlushWorker();
+  };
   const flush = async (timeoutMs = 1e4) => {
     if (!enabled || closed) {
       queue.clear();
       retryBatch = null;
       return;
     }
+    setFlushDeadline(timeoutMs, true);
     if (flushing) {
       flushesJoined++;
       return flushing;
     }
-    flushesStarted++;
-    const activeFlush = performFlush(timeoutMs);
-    flushing = activeFlush;
-    try {
-      await activeFlush;
-    } finally {
-      if (flushing === activeFlush) flushing = void 0;
-    }
+    await startFlushWorker();
   };
-  const enqueue = (event, priority = "first", rawFrames = []) => {
+  const enqueue = (event, priority = "first", rawFrames = [], encodedBytes) => {
     if (!enabled || closed) return;
-    queue.enqueue({ kind: "event", event, priority, rawFrames });
+    queue.enqueue({ kind: "event", event, priority, rawFrames, encodedBytes });
     schedule();
-    if (queue.size() >= batchSize) void flush();
+    if (queue.size() >= batchSize) kickBackgroundFlush();
   };
   const enqueueSummary = (summary, rawFrames = []) => {
     if (!enabled || closed) return;
     queue.enqueue({ kind: "summary", summary, priority: "summary", rawFrames });
     schedule();
-    if (queue.size() >= batchSize) void flush();
+    if (queue.size() >= batchSize) kickBackgroundFlush();
+  };
+  const dropRemainingOnExit = () => {
+    const remaining = queue.size() + (retryBatch?.items.length ?? 0);
+    if (remaining === 0) return;
+    queue.clear();
+    retryBatch = null;
+    retryBytes = 0;
+    inFlightBytes = 0;
+    syncReservedBytes();
+    console.error(
+      `[rasputin] Dropped ${remaining} telemetry event${remaining === 1 ? "" : "s"} on exit because ingest did not accept them in time.`
+    );
   };
-  const onBeforeExit = () => {
-    if (closed || shuttingDown) return;
+  const onBeforeExit2 = () => {
+    if (closed || shuttingDown2) return;
     if (queue.size() === 0 && !retryBatch && !flushing) return;
-    void flush(2e3).catch(() => {
-    });
+    shuttingDown2 = true;
+    stopTimer();
+    options.beforeFlush?.();
+    void flush(DEFAULTS2.shutdownFlushMs).catch(() => {
+    }).finally(dropRemainingOnExit);
   };
-  const onSignal = () => {
-    if (shuttingDown) return;
-    shuttingDown = true;
+  const onSignal = async () => {
+    if (shuttingDown2) return;
+    shuttingDown2 = true;
     stopTimer();
-    holdProcessExitUntil(flush(2e3).catch(() => {
-    }));
+    options.beforeFlush?.();
+    await flush(DEFAULTS2.shutdownFlushMs).catch(() => {
+    });
+  };
+  const unregisterSignals = enabled && (options.installSignalHandlers ?? DEFAULTS2.installSignalHandlers) ? registerProcessShutdownHooks({
+    onBeforeExit: onBeforeExit2,
+    onSignal,
+    dropRemaining: dropRemainingOnExit
+  }) : () => {
   };
-  if (enabled && (options.installSignalHandlers ?? DEFAULTS2.installSignalHandlers)) {
-    process.on("beforeExit", onBeforeExit);
-    process.on("SIGTERM", onSignal);
-    process.on("SIGINT", onSignal);
-  }
   const close = async () => {
     stopTimer();
-    removeProcessListener("beforeExit", onBeforeExit);
-    removeProcessListener("SIGTERM", onSignal);
-    removeProcessListener("SIGINT", onSignal);
-    await flush(2e3);
+    unregisterSignals();
+    shuttingDown2 = true;
+    await new Promise((resolve4, reject) => {
+      const timer2 = setTimeout(resolve4, DEFAULTS2.shutdownFlushMs + 250);
+      void flush(DEFAULTS2.shutdownFlushMs).then(
+        () => {
+          clearTimeout(timer2);
+          resolve4();
+        },
+        (error) => {
+          clearTimeout(timer2);
+          reject(error);
+        }
+      );
+    });
+    dropRemainingOnExit();
     closed = true;
     queue.clear();
     retryBatch = null;
@@ -1328,55 +1694,126 @@ var createTransport = (options) => {
   };
 };
 
-// src/create-client/is-client-enabled.ts
-var isClientEnabled = (options) => options.enabled ?? true;
-var noopClient = () => ({
-  captureException: () => {
-  },
-  flush: async () => {
-  },
-  close: async () => {
-  },
-  getStats: () => ({
-    transport: {
-      queued: 0,
-      enqueued: 0,
-      droppedIncoming: 0,
-      droppedQueued: 0,
-      droppedTotal: 0,
-      flushesStarted: 0,
-      flushesJoined: 0,
-      sendAttempts: 0,
-      sendRetries: 0,
-      batchReplays: 0,
-      batchesSucceeded: 0,
-      batchesDropped: 0,
-      batchesFailed: 0,
-      flushTimeouts: 0,
-      networkErrors: 0,
-      rateLimitedResponses: 0,
-      serverErrorResponses: 0,
-      lastFailureKind: null,
-      lastFailureStatusCode: null
-    }
-  })
-});
-
-// src/create-client/resolve-endpoint-urls.ts
-var DEFAULT_API_URL = "https://api.rasputinai.dev";
-var resolveEndpointUrls = (apiUrl = DEFAULT_API_URL) => {
-  const base = apiUrl.replace(/\/+$/, "");
-  return {
-    ingestUrl: `${base}/ingest`,
-    deployUrl: `${base}/deploy`,
-    instrumentationManifestUrl: `${base}/instrumentationManifest`
-  };
-};
-
-// src/create-client/create-client.ts
-var warnedUnresolvedMaps = false;
-var warnedPartialResolution = false;
-var warnUnresolvedMaps = (unresolved) => {
+// src/detect-release/detect-release.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var ENV_KEYS = [
+  "RASPUTIN_RELEASE",
+  "VERCEL_GIT_COMMIT_SHA",
+  "RAILWAY_GIT_COMMIT_SHA",
+  "RENDER_GIT_COMMIT",
+  "COMMIT_REF",
+  "CF_PAGES_COMMIT_SHA",
+  "HEROKU_SLUG_COMMIT",
+  "GIT_COMMIT",
+  "COMMIT_SHA",
+  "GIT_SHA"
+];
+var SHA_RE = /^[0-9a-f]{7,40}$/i;
+var isSha = (value) => SHA_RE.test(value);
+var warnInvalid = (source, value) => {
+  console.warn(
+    `[rasputin] Ignoring invalid release from ${source}: "${value}". Expected a git commit SHA (7\u201340 hex characters).`
+  );
+};
+var readGitHead = (cwd) => {
+  try {
+    const gitDir = join3(cwd, ".git");
+    const head = readFileSync2(join3(gitDir, "HEAD"), "utf8").trim();
+    if (isSha(head)) return head;
+    const ref = head.replace(/^ref:\s*/, "");
+    try {
+      const sha = readFileSync2(join3(gitDir, ref), "utf8").trim();
+      return isSha(sha) ? sha : void 0;
+    } catch {
+      const packed = readFileSync2(join3(gitDir, "packed-refs"), "utf8");
+      const match = packed.match(new RegExp(`^([0-9a-f]{40}) ${ref}$`, "m"));
+      return match?.[1];
+    }
+  } catch {
+    return void 0;
+  }
+};
+var detectRelease = (options = {}) => {
+  const explicit = options.release?.trim();
+  if (explicit) {
+    if (isSha(explicit)) return explicit;
+    warnInvalid("release option", explicit);
+  }
+  const env = options.env ?? process.env;
+  for (const key of ENV_KEYS) {
+    const value = env[key]?.trim();
+    if (!value) continue;
+    if (isSha(value)) return value;
+    warnInvalid(key, value);
+  }
+  const fromGit = readGitHead(options.cwd ?? process.cwd());
+  if (fromGit) return fromGit;
+  console.warn(
+    "[rasputin] No release detected. Set `RASPUTIN_RELEASE` to your git commit SHA, pass `release` in RasputinInit, or deploy on a platform that exposes a commit SHA env var (e.g. VERCEL_GIT_COMMIT_SHA). Events are not sent without a release."
+  );
+  return void 0;
+};
+
+// src/create-client/is-client-enabled.ts
+var resolveClientActivation = (options) => {
+  if (options.enabled === false) return { enabled: false };
+  const projectApiKey = typeof options.projectApiKey === "string" ? options.projectApiKey.trim() : "";
+  if (!projectApiKey) return { enabled: false };
+  const explicit = typeof options.release === "string" ? options.release.trim() : "";
+  if (!explicit) return { enabled: false };
+  const release = detectRelease({ release: explicit });
+  if (!release) return { enabled: false };
+  return { enabled: true, projectApiKey, release };
+};
+var isClientEnabled = (options) => resolveClientActivation(options).enabled;
+var noopClient = () => ({
+  captureException: () => {
+  },
+  flush: async () => {
+  },
+  close: async () => {
+  },
+  getStats: () => ({
+    transport: {
+      queued: 0,
+      enqueued: 0,
+      droppedIncoming: 0,
+      droppedQueued: 0,
+      droppedTotal: 0,
+      flushesStarted: 0,
+      flushesJoined: 0,
+      sendAttempts: 0,
+      sendRetries: 0,
+      batchReplays: 0,
+      batchesSucceeded: 0,
+      batchesDropped: 0,
+      batchesFailed: 0,
+      flushTimeouts: 0,
+      networkErrors: 0,
+      rateLimitedResponses: 0,
+      serverErrorResponses: 0,
+      lastFailureKind: null,
+      lastFailureStatusCode: null
+    }
+  })
+});
+
+// src/create-client/resolve-endpoint-urls.ts
+var DEFAULT_API_URL = "https://api.rasputinai.dev";
+var resolveEndpointUrls = (apiUrl = DEFAULT_API_URL) => {
+  const base = apiUrl.replace(/\/+$/, "");
+  return {
+    ingestUrl: `${base}/ingest`,
+    deployUrl: `${base}/deploy`,
+    instrumentationManifestUrl: `${base}/instrumentationManifest`
+  };
+};
+
+// src/create-client/create-client.ts
+var warnedUnresolvedMaps = false;
+var warnedPartialResolution = false;
+var warnUnresolvedMaps = (unresolved) => {
   if (!unresolved || warnedUnresolvedMaps) return;
   warnedUnresolvedMaps = true;
   console.warn(
@@ -1400,22 +1837,11 @@ var stackOf = (error) => {
 };
 var createClient = (options, hooks = {}) => {
   try {
-    if (!isClientEnabled(options)) return noopClient();
-    const projectApiKey = options.projectApiKey.trim();
-    const release = detectRelease({ release: options.release });
+    const activation = resolveClientActivation(options);
+    if (!activation.enabled) return noopClient();
+    const { projectApiKey, release } = activation;
     const environment = options.environment;
     const { ingestUrl, deployUrl } = resolveEndpointUrls(options.apiUrl);
-    if (!release) {
-      if (hooks.announceDeploy ?? true) {
-        void announceDeploy({
-          deployUrl,
-          projectApiKey,
-          environment,
-          fetch: hooks.fetch
-        });
-      }
-      return noopClient();
-    }
     const repoRoot = resolveRepoRoot(options);
     if (repoRoot) warnIfSuspiciousRepoRoot(repoRoot);
     const MAX_STACK_RESOLVE_CACHE = 32;
@@ -1441,6 +1867,9 @@ var createClient = (options, hooks = {}) => {
       }
       return pending;
     };
+    const suppression = createSuppression();
+    let enqueuePendingSummaries = () => {
+    };
     const transport = createTransport({
       ingestUrl,
       projectApiKey,
@@ -1449,6 +1878,7 @@ var createClient = (options, hooks = {}) => {
       installSignalHandlers: hooks.installTransportSignalHandlers,
       sdkVersion: hooks.sdkVersion ?? SDK_VERSION,
       sdkName: hooks.sdkName ?? SDK_NAME,
+      beforeFlush: () => enqueuePendingSummaries(),
       prepareEvent: async ({ event, rawFrames }) => {
         const prepared = await resolveStack(rawFrames);
         return withResolvedFrames(event, prepared.frames, prepared.resolution);
@@ -1458,7 +1888,6 @@ var createClient = (options, hooks = {}) => {
         return { stack_frames: prepared.stack_frames, resolution: prepared.resolution };
       }
     });
-    const suppression = createSuppression();
     if (hooks.announceDeploy ?? true) {
       void announceDeploy({
         deployUrl,
@@ -1467,11 +1896,12 @@ var createClient = (options, hooks = {}) => {
         release,
         enabled: true,
         fetch: hooks.fetch
+      }).catch(() => {
       });
     }
     const captureException = (error, context) => {
       try {
-        const rawFrames = parseStack(stackOf(error));
+        const rawFrames = foldSyntheticFrames(parseStack(stackOf(error)));
         const frames = normalizeFrames(toResolvedFrames(rawFrames), { appRoot: repoRoot });
         const event = createIngestEvent({
           error,
@@ -1480,8 +1910,7 @@ var createClient = (options, hooks = {}) => {
           release,
           origin: "server",
           resolution: "none",
-          request: context?.request,
-          runtimeState: context?.runtimeState
+          request: context?.request
         });
         const decision = suppression.decide({
           errorType: event.type,
@@ -1494,13 +1923,20 @@ var createClient = (options, hooks = {}) => {
           release,
           route: context?.request?.route
         });
-        if (decision.action === "send") {
-          transport.enqueue(event, decision.priority, rawFrames);
+        if (decision.action !== "send") return;
+        const runtimeState = context?.runtimeState ?? hooks.resolveRuntimeState?.(error, context);
+        if (runtimeState) event.runtime_state = runtimeState;
+        let encodedBytes;
+        try {
+          encodedBytes = Buffer2.byteLength(JSON.stringify(event), "utf8");
+        } catch {
+          encodedBytes = void 0;
         }
+        transport.enqueue(event, decision.priority, rawFrames, encodedBytes);
       } catch {
       }
     };
-    const enqueuePendingSummaries = () => {
+    enqueuePendingSummaries = () => {
       for (const { summary, rawFrames } of suppression.drainSummaries()) {
         transport.enqueueSummary(summary, rawFrames);
       }
@@ -1530,68 +1966,6 @@ var createClient = (options, hooks = {}) => {
   }
 };
 
-// src/derivation/rasputin-wire-tag.ts
-var RASPUTIN_WIRE_TAG = "\0rasputin";
-var rasputinUnknown = () => [RASPUTIN_WIRE_TAG, "unknown"];
-var rasputinUnavailable = (reason) => [
-  RASPUTIN_WIRE_TAG,
-  "unavailable",
-  reason
-];
-var rasputinOmitted = () => [RASPUTIN_WIRE_TAG, "omitted"];
-var rasputinRedacted = () => [RASPUTIN_WIRE_TAG, "redacted"];
-var rasputinTruncated = (payload) => [
-  RASPUTIN_WIRE_TAG,
-  "truncated",
-  payload
-];
-var isRasputinTaggedValue = (value) => {
-  if (!Array.isArray(value) || value.length < 2 || value[0] !== RASPUTIN_WIRE_TAG) return false;
-  const kind = value[1];
-  return kind === "unknown" || kind === "unavailable" || kind === "omitted" || kind === "redacted" || kind === "truncated";
-};
-var rasputinTagKind = (value) => isRasputinTaggedValue(value) ? value[1] : void 0;
-
-// src/derivation/captured-value-markers.ts
-var REDACTED = "[RASPUTIN_REDACTED]";
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var capturedValueCompleteness = (value) => {
-  if (value === REDACTED) return "partial";
-  const tagged = rasputinTagKind(value);
-  if (tagged === "unknown" || tagged === "truncated" || tagged === "unavailable" || tagged === "omitted") {
-    return "partial";
-  }
-  if (tagged === "redacted") return "partial";
-  if (isRasputinTaggedValue(value)) return "partial";
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      if (capturedValueCompleteness(item) === "partial") return "partial";
-    }
-    return "exact";
-  }
-  if (!isRecord(value)) return "exact";
-  if (value.__rasputin_truncated === true) return "partial";
-  if (value.__rasputin_type === "omitted" || value.__rasputin_type === "accessor") return "partial";
-  if (value.__rasputin_type === "unserializable") return "partial";
-  for (const key of Object.keys(value)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (!descriptor || descriptor.get || descriptor.set) return "partial";
-    if (capturedValueCompleteness(descriptor.value) === "partial") return "partial";
-  }
-  return "exact";
-};
-var isRedactedCapturedValue = (value) => {
-  if (value === REDACTED) return true;
-  if (rasputinTagKind(value) === "redacted") return true;
-  if (isRecord(value) && value.__rasputin_type === "omitted") return true;
-  return false;
-};
-var isSerializerMarker = (value) => {
-  if (isRasputinTaggedValue(value)) return true;
-  if (!isRecord(value)) return false;
-  return value.__rasputin_truncated === true || typeof value.__rasputin_type === "string";
-};
-
 // src/derivation/canonical-json.ts
 var sortedKeys = (value) => Object.keys(value).sort();
 var canonicalJson = (value) => {
@@ -1622,967 +1996,214 @@ var canonicalJson = (value) => {
 };
 
 // src/derivation/sha256.ts
-var K = [
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-];
-var rotr = (value, bits) => value >>> bits | value << 32 - bits;
-var sha256Hex = (input) => {
-  const encoded = new TextEncoder().encode(input);
-  const bitLen = encoded.length * 8;
-  const paddedLen = encoded.length + 9 + 63 >> 6 << 6 >>> 0;
-  const bytes = new Uint8Array(paddedLen);
-  bytes.set(encoded);
-  bytes[encoded.length] = 128;
-  const view = new DataView(bytes.buffer);
-  view.setUint32(paddedLen - 4, bitLen, false);
-  let h0 = 1779033703;
-  let h1 = 3144134277;
-  let h2 = 1013904242;
-  let h3 = 2773480762;
-  let h4 = 1359893119;
-  let h5 = 2600822924;
-  let h6 = 528734635;
-  let h7 = 1541459225;
-  const w = new Uint32Array(64);
-  for (let offset = 0; offset < paddedLen; offset += 64) {
-    for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4, false);
-    for (let i = 16; i < 64; i++) {
-      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
-      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
-      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
-    }
-    let a = h0;
-    let b = h1;
-    let c = h2;
-    let d = h3;
-    let e = h4;
-    let f = h5;
-    let g = h6;
-    let h = h7;
-    for (let i = 0; i < 64; i++) {
-      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
-      const ch = e & f ^ ~e & g;
-      const temp1 = h + S1 + ch + K[i] + w[i] >>> 0;
-      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
-      const maj = a & b ^ a & c ^ b & c;
-      const temp2 = S0 + maj >>> 0;
-      h = g;
-      g = f;
-      f = e;
-      e = d + temp1 >>> 0;
-      d = c;
-      c = b;
-      b = a;
-      a = temp1 + temp2 >>> 0;
-    }
-    h0 = h0 + a >>> 0;
-    h1 = h1 + b >>> 0;
-    h2 = h2 + c >>> 0;
-    h3 = h3 + d >>> 0;
-    h4 = h4 + e >>> 0;
-    h5 = h5 + f >>> 0;
-    h6 = h6 + g >>> 0;
-    h7 = h7 + h >>> 0;
-  }
-  return [h0, h1, h2, h3, h4, h5, h6, h7].map((word) => word.toString(16).padStart(8, "0")).join("");
-};
+import { createHash as createHash2 } from "node:crypto";
+var sha256Hex = (input) => createHash2("sha256").update(input).digest("hex");
 
 // src/derivation/hash-instrumentation-manifest.ts
+var hashCache = /* @__PURE__ */ new WeakMap();
 var hashableSource = (source) => {
   const { repositoryPath: _repositoryPath, ...rest } = source;
   return rest;
 };
 var hashableLocated = (items) => items.map((item) => ({ ...item, source: hashableSource(item.source) }));
 var hashInstrumentationManifest = (manifest) => {
-  return sha256Hex(
+  const cached = hashCache.get(manifest);
+  if (cached) return cached;
+  const hash = sha256Hex(
     canonicalJson({
       schema_version: manifest.schema_version,
       functions: hashableLocated(manifest.functions),
       callSites: hashableLocated(manifest.callSites),
-      destructures: hashableLocated(manifest.destructures),
-      derivationPlans: manifest.derivationPlans ?? []
+      destructures: hashableLocated(manifest.destructures)
     })
   );
+  hashCache.set(manifest, hash);
+  return hash;
 };
 
-// src/derivation/wire-values-equal.ts
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var arraysEqual = (left, right) => {
-  if (left.length !== right.length) return false;
-  for (let index = 0; index < left.length; index++) {
-    if (Object.hasOwn(left, index) !== Object.hasOwn(right, index)) return false;
-    if (!wireValuesEqual(left[index], right[index])) return false;
-  }
-  return true;
-};
-var wireValuesEqual = (left, right) => {
-  if (Object.is(left, right)) return true;
-  if (typeof left === "bigint" && typeof right === "bigint") return left === right;
-  if (isRasputinTaggedValue(left) || isRasputinTaggedValue(right)) {
-    if (!Array.isArray(left) || !Array.isArray(right)) return false;
-    return arraysEqual(left, right);
-  }
-  if (Array.isArray(left) && Array.isArray(right)) return arraysEqual(left, right);
-  if (!isRecord2(left) || !isRecord2(right)) return false;
-  const leftKeys = Object.keys(left).sort();
-  const rightKeys = Object.keys(right).sort();
-  if (leftKeys.length !== rightKeys.length) return false;
-  return leftKeys.every((key, index) => {
-    if (key !== rightKeys[index]) return false;
-    const leftDesc = Object.getOwnPropertyDescriptor(left, key);
-    const rightDesc = Object.getOwnPropertyDescriptor(right, key);
-    if (!leftDesc || !rightDesc) return false;
-    if (leftDesc.get || leftDesc.set || rightDesc.get || rightDesc.set) return false;
-    return wireValuesEqual(leftDesc.value, rightDesc.value);
-  });
+// src/derivation/rasputin-wire-tag.ts
+var RASPUTIN_WIRE_TAG = "\uE000rasputin";
+var rasputinUnknown = () => [RASPUTIN_WIRE_TAG, "unknown"];
+var rasputinUnavailable = (reason) => [
+  RASPUTIN_WIRE_TAG,
+  "unavailable",
+  reason
+];
+var rasputinOmitted = () => [RASPUTIN_WIRE_TAG, "omitted"];
+var rasputinRedacted = () => [RASPUTIN_WIRE_TAG, "redacted"];
+var rasputinTruncated = (payload) => [
+  RASPUTIN_WIRE_TAG,
+  "truncated",
+  payload
+];
+var isRasputinTaggedValue = (value) => {
+  if (!Array.isArray(value) || value.length < 2 || value[0] !== RASPUTIN_WIRE_TAG) return false;
+  const kind = value[1];
+  return kind === "unknown" || kind === "unavailable" || kind === "omitted" || kind === "redacted" || kind === "truncated";
 };
+var rasputinTagKind = (value) => isRasputinTaggedValue(value) ? value[1] : void 0;
 
-// src/derivation/evaluate-derivation-plan.ts
-var MAX_INSTRUCTIONS = 1e4;
-var MAX_DEPTH = 64;
-var MAX_OUTPUT_BYTES = 256 * 1024;
-var MAX_WALL_MS = 50;
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var primitiveFromConst = (value) => {
-  switch (value.type) {
-    case "null":
-      return null;
-    case "undefined":
-      return void 0;
-    case "boolean":
-      return value.value;
-    case "number":
-      return value.negativeZero ? -0 : value.value;
-    case "string":
-      return value.value;
-    case "bigint":
-      try {
-        return BigInt(value.value);
-      } catch {
-        return rasputinUnavailable("invalid_bigint_const");
-      }
-  }
-};
-var estimateBytes = (value, depth = 0) => {
-  if (value === null || value === void 0) return 4;
-  switch (typeof value) {
-    case "boolean":
-      return 4;
-    case "number":
-      return 8;
-    case "string":
-      return value.length;
-    case "bigint":
-      return value.toString().length;
-    case "object": {
-      if (depth > 8) return 8;
-      if (Array.isArray(value)) {
-        let total2 = 2;
-        for (const item of value) total2 += estimateBytes(item, depth + 1);
-        return total2;
-      }
-      let total = 2;
-      for (const key of Object.keys(value)) {
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (!descriptor || descriptor.get || descriptor.set) {
-          total += key.length + 8;
-          continue;
-        }
-        total += key.length + estimateBytes(descriptor.value, depth + 1);
-      }
-      return total;
-    }
-    default:
-      return 8;
-  }
-};
-var capturedFromWire = (value) => {
-  if (rasputinTagKind(value) === "omitted") {
-    return { origin: "unavailable", reason: "omitted_value" };
-  }
-  if (isRedactedCapturedValue(value)) {
-    return { origin: "captured", completeness: "partial", value: rasputinRedacted() };
-  }
-  return { origin: "captured", completeness: capturedValueCompleteness(value), value };
-};
-var checkpointRank = (value) => {
-  if (!value || value.origin === "unavailable") return 5;
-  if (value.origin === "captured" && value.completeness === "exact") return 1;
-  if (value.origin === "derived" && value.completeness === "exact") return 2;
-  if (value.origin === "captured") return 3;
-  return 4;
-};
-var resolveCheckpoint = (captured, derived, expressionId) => {
-  const capturedRank = checkpointRank(captured);
-  const derivedRank = checkpointRank(derived);
-  if (capturedRank === 1 && derivedRank === 2 && captured?.origin === "captured" && derived?.origin === "derived") {
-    if (!wireValuesEqual(captured.value, derived.value)) {
-      return {
-        origin: "captured",
-        completeness: "exact",
-        value: captured.value,
-        derivationValidation: {
-          status: "mismatch",
-          derivedValue: derived.value,
-          expressionId,
-          dependencies: derived.dependencies
-        }
-      };
-    }
-    return {
-      origin: "captured",
-      completeness: "exact",
-      value: captured.value,
-      derivationValidation: { status: "verified" }
-    };
-  }
-  if (capturedRank <= derivedRank) {
-    return captured ?? derived ?? { origin: "unavailable", reason: "no_checkpoint" };
-  }
-  return derived ?? { origin: "unavailable", reason: "no_checkpoint" };
-};
-var exactOperandsOrUnavailable = (parts) => {
-  const completeness = mergeCompleteness(parts);
-  if (completeness === "unavailable")
-    return { origin: "unavailable", reason: "partial_dependency" };
-  if (completeness === "partial") return { origin: "unavailable", reason: "partial_operand" };
-  return void 0;
-};
-var capturedResult = (root) => {
-  if (isRedactedCapturedValue(root.value)) {
-    return { origin: "captured", completeness: "partial", value: rasputinRedacted() };
-  }
-  const completeness = root.completeness === "partial" ? "partial" : capturedValueCompleteness(root.value);
-  return { origin: "captured", completeness, value: root.value };
-};
-var mergeCompleteness = (parts) => {
-  let partial = false;
-  for (const part of parts) {
-    if (part.origin === "unavailable") return "unavailable";
-    if (part.completeness === "partial") partial = true;
-  }
-  return partial ? "partial" : "exact";
-};
-var unwrapExactPrimitive = (result) => {
-  if (result.origin === "unavailable") return rasputinUnavailable(result.reason);
-  return result.value;
-};
-var isNumericPrimitive = (value) => typeof value === "number" && !isRasputinTaggedValue(value);
-var isPrimitiveOperand = (value) => {
-  if (isRasputinTaggedValue(value)) return false;
-  return value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string" || typeof value === "bigint" || typeof value === "undefined";
-};
-var omittedCallKey = (parentCallId, functionId) => `${parentCallId}\0${functionId}`;
-var argsIncludeOmitted = (args) => args.some((arg) => rasputinTagKind(arg) === "omitted");
-var recordReconstructedCallArgs = (queue, parentCallId, functionId, args) => {
-  const key = omittedCallKey(parentCallId, functionId);
-  const pending = queue.get(key);
-  if (pending) pending.push(args);
-  else queue.set(key, [args]);
-};
-var takeReconstructedCallArgs = (queue, parentCallId, functionId) => {
-  if (parentCallId == null) return void 0;
-  const pending = queue.get(omittedCallKey(parentCallId, functionId));
-  if (!pending || pending.length === 0) return void 0;
-  return pending.shift();
-};
-var resolveEnterArgs = (enter, queue) => {
-  if (!argsIncludeOmitted(enter.args)) return enter.args;
-  return takeReconstructedCallArgs(queue, enter.parentCallId, enter.functionId) ?? enter.args;
-};
-var takeChildCapturedReturn = (state, calleeFunctionId) => {
-  if (state.recordingCallId == null) return void 0;
-  const children = (state.childrenByParent.get(state.recordingCallId) ?? []).filter(
-    (child2) => child2.functionId === calleeFunctionId
-  );
-  const key = omittedCallKey(state.recordingCallId, calleeFunctionId);
-  const index = state.childCursor.get(key) ?? 0;
-  state.childCursor.set(key, index + 1);
-  const child = children[index];
-  if (!child) return void 0;
-  if (state.throwCallIds.has(child.callId)) return { threw: true };
-  return state.exitByCallId.get(child.callId);
-};
-var readOwnDataProperty = (object, key) => {
-  const descriptor = Object.getOwnPropertyDescriptor(object, key);
-  if (!descriptor) return { ok: false, reason: "missing_property" };
-  if (descriptor.get !== void 0 || descriptor.set !== void 0) {
-    return { ok: false, reason: "accessor_property" };
-  }
-  return { ok: true, value: descriptor.value };
-};
-var budgetExceeded = (state) => {
-  if (state.instructions > MAX_INSTRUCTIONS) return "instruction_budget";
-  if (state.depth > MAX_DEPTH) return "depth_budget";
-  if (state.outputBytes > MAX_OUTPUT_BYTES) return "output_size_budget";
-  if (Date.now() - state.startedAt > MAX_WALL_MS) return "wall_time_budget";
-  return void 0;
-};
-var evaluateExpression = (expressionId, plan, byId, cells, args, rootsById, factsById, calleeReturns, state, evaluateCallee) => {
-  const over = budgetExceeded(state);
-  if (over) return { origin: "unavailable", reason: over };
-  state.instructions++;
-  state.depth++;
-  try {
-    const existing = cells.get(expressionId);
-    if (existing?.status === "done") return existing.result;
-    if (existing?.status === "pending") {
-      return { origin: "unavailable", reason: "cyclic_expression" };
-    }
-    const expression = byId.get(expressionId);
-    if (!expression) return { origin: "unavailable", reason: "missing_expression" };
-    cells.set(expressionId, { status: "pending" });
-    const evalChild = (id) => evaluateExpression(
-      id,
-      plan,
-      byId,
-      cells,
-      args,
-      rootsById,
-      factsById,
-      calleeReturns,
-      state,
-      evaluateCallee
-    );
-    let result;
-    switch (expression.kind) {
-      case "const": {
-        const value = primitiveFromConst(expression.value);
-        result = { origin: "derived", completeness: "exact", value, dependencies: [] };
-        break;
-      }
-      case "param": {
-        if (expression.index < 0 || expression.index >= args.length) {
-          result = { origin: "unavailable", reason: "missing_argument" };
-          break;
-        }
-        const value = args[expression.index];
-        if (rasputinTagKind(value) === "omitted") {
-          result = { origin: "unavailable", reason: "omitted_argument" };
-          break;
-        }
-        result = capturedFromWire(value);
-        break;
-      }
-      case "root": {
-        const root = rootsById.get(expression.rootId);
-        if (!root) {
-          result = { origin: "unavailable", reason: "missing_root" };
-          break;
-        }
-        result = capturedResult(root);
-        break;
-      }
-      case "alias":
-        result = evalChild(expression.from);
-        break;
-      case "binary": {
-        const left = evalChild(expression.left);
-        const right = evalChild(expression.right);
-        const blocked = exactOperandsOrUnavailable([left, right]);
-        if (blocked) {
-          result = blocked;
-          break;
-        }
-        const leftValue = unwrapExactPrimitive(left);
-        const rightValue = unwrapExactPrimitive(right);
-        if (rasputinTagKind(leftValue) || rasputinTagKind(rightValue)) {
-          result = { origin: "unavailable", reason: "tagged_operand" };
-          break;
-        }
-        if (isRedactedCapturedValue(leftValue) || isRedactedCapturedValue(rightValue)) {
-          result = { origin: "unavailable", reason: "redacted_operand" };
-          break;
-        }
-        if (expression.guard === "numeric") {
-          if (!isNumericPrimitive(leftValue) || !isNumericPrimitive(rightValue)) {
-            result = { origin: "unavailable", reason: "numeric_guard_failed" };
-            break;
-          }
-        } else if (expression.guard === "primitive") {
-          if (!isPrimitiveOperand(leftValue) || !isPrimitiveOperand(rightValue)) {
-            result = { origin: "unavailable", reason: "primitive_guard_failed" };
-            break;
-          }
-        }
-        const value = applyBinary(expression.op, leftValue, rightValue);
-        if (value === void 0) {
-          result = { origin: "unavailable", reason: "unsupported_binary" };
-          break;
-        }
-        result = {
-          origin: "derived",
-          completeness: "exact",
-          value,
-          dependencies: [expression.left, expression.right]
-        };
-        break;
-      }
-      case "unary": {
-        const operand = evalChild(expression.operand);
-        const blocked = exactOperandsOrUnavailable([operand]);
-        if (blocked || operand.origin === "unavailable") {
-          result = blocked ?? operand;
-          break;
-        }
-        const raw = operand.value;
-        if (isRedactedCapturedValue(raw) || rasputinTagKind(raw)) {
-          result = { origin: "unavailable", reason: "tagged_operand" };
-          break;
-        }
-        if (expression.op === "typeof") {
-          result = {
-            origin: "derived",
-            completeness: "exact",
-            value: typeof raw,
-            dependencies: [expression.operand]
-          };
-          break;
-        }
-        if (expression.op === "not") {
-          result = {
-            origin: "derived",
-            completeness: "exact",
-            value: !raw,
-            dependencies: [expression.operand]
-          };
-          break;
-        }
-        if (!isNumericPrimitive(raw)) {
-          result = { origin: "unavailable", reason: "numeric_guard_failed" };
-          break;
-        }
-        result = {
-          origin: "derived",
-          completeness: "exact",
-          value: expression.op === "minus" ? -raw : +raw,
-          dependencies: [expression.operand]
-        };
-        break;
-      }
-      case "logical": {
-        const left = evalChild(expression.left);
-        const leftBlocked = exactOperandsOrUnavailable([left]);
-        if (leftBlocked || left.origin === "unavailable") {
-          result = leftBlocked ?? left;
-          break;
-        }
-        const takeRight = expression.op === "and" ? Boolean(left.value) : expression.op === "or" ? !left.value : left.value == null;
-        if (!takeRight) {
-          result = left.origin === "derived" ? left : {
-            origin: "derived",
-            completeness: "exact",
-            value: left.value,
-            dependencies: [expression.left]
-          };
-          break;
-        }
-        const right = evalChild(expression.right);
-        const blocked = exactOperandsOrUnavailable([left, right]);
-        if (blocked || right.origin === "unavailable") {
-          result = blocked ?? right;
-          break;
-        }
-        result = {
-          origin: "derived",
-          completeness: "exact",
-          value: right.value,
-          dependencies: [expression.left, expression.right]
-        };
-        break;
-      }
-      case "cond": {
-        const test = evalChild(expression.test);
-        const testBlocked = exactOperandsOrUnavailable([test]);
-        if (testBlocked || test.origin === "unavailable") {
-          result = testBlocked ?? test;
-          break;
-        }
-        const fact = [...factsById.values()].find(
-          (entry) => plan.controlFacts.some((definition) => definition.id === entry.factId)
-        );
-        const takeConsequent = fact ? fact.value : Boolean(test.value);
-        const branch = evalChild(takeConsequent ? expression.consequent : expression.alternate);
-        const blocked = exactOperandsOrUnavailable([test, branch]);
-        if (blocked || branch.origin === "unavailable") {
-          result = blocked ?? branch;
-          break;
-        }
-        result = {
-          origin: "derived",
-          completeness: "exact",
-          value: branch.value,
-          dependencies: [
-            expression.test,
-            takeConsequent ? expression.consequent : expression.alternate
-          ]
-        };
-        break;
-      }
-      case "template": {
-        const parts = [];
-        let text = "";
-        let failed;
-        for (const part of expression.parts) {
-          if (part.kind === "lit") {
-            text += part.value;
-            continue;
-          }
-          const nested = evalChild(part.expressionId);
-          parts.push(nested);
-          if (nested.origin === "unavailable") {
-            failed = nested;
-            break;
-          }
-          if (!isPrimitiveOperand(nested.value) || isRasputinTaggedValue(nested.value)) {
-            failed = { origin: "unavailable", reason: "template_non_primitive" };
-            break;
-          }
-          text += String(nested.value);
-        }
-        if (failed) {
-          result = failed;
-          break;
-        }
-        const completeness = parts.length === 0 ? "exact" : mergeCompleteness(parts);
-        if (completeness === "unavailable") {
-          result = { origin: "unavailable", reason: "partial_dependency" };
-          break;
-        }
-        result = {
-          origin: "derived",
-          completeness,
-          value: text,
-          dependencies: expression.parts.flatMap(
-            (part) => part.kind === "expr" ? [part.expressionId] : []
-          )
-        };
-        break;
-      }
-      case "object": {
-        const record = {};
-        const parts = [];
-        let failed;
-        for (const property of expression.properties) {
-          const nested = evalChild(property.value);
-          parts.push(nested);
-          if (nested.origin === "unavailable") {
-            failed = nested;
-            break;
-          }
-          record[property.key] = nested.value;
-        }
-        if (failed) {
-          result = failed;
-          break;
-        }
-        const completeness = mergeCompleteness(parts);
-        if (completeness === "unavailable") {
-          result = { origin: "unavailable", reason: "partial_dependency" };
-          break;
-        }
-        result = {
-          origin: "derived",
-          completeness,
-          value: record,
-          dependencies: expression.properties.map((property) => property.value)
-        };
-        break;
-      }
-      case "array": {
-        const items = [];
-        const parts = [];
-        let failed;
-        let unknownCount = 0;
-        for (const element of expression.elements) {
-          if (typeof element !== "number") {
-            items.push(rasputinUnknown());
-            unknownCount++;
-            continue;
-          }
-          const nested = evalChild(element);
-          parts.push(nested);
-          if (nested.origin === "unavailable") {
-            failed = nested;
-            break;
-          }
-          items.push(nested.value);
-        }
-        if (failed) {
-          result = failed;
-          break;
-        }
-        const completeness = unknownCount > 0 ? "partial" : parts.length === 0 ? "exact" : mergeCompleteness(parts);
-        if (completeness === "unavailable") {
-          result = { origin: "unavailable", reason: "partial_dependency" };
-          break;
-        }
-        result = {
-          origin: "derived",
-          completeness,
-          value: items,
-          dependencies: expression.elements.flatMap(
-            (element) => typeof element === "number" ? [element] : []
-          )
-        };
-        break;
-      }
-      case "prop": {
-        const object = evalChild(expression.object);
-        if (object.origin === "unavailable") {
-          result = object;
-          break;
-        }
-        if (isRedactedCapturedValue(object.value)) {
-          result = { origin: "unavailable", reason: "redacted_operand" };
-          break;
-        }
-        if (!isRecord3(object.value) || rasputinTagKind(object.value)) {
-          result = { origin: "unavailable", reason: "prop_on_non_object" };
-          break;
-        }
-        const owned = readOwnDataProperty(object.value, expression.key);
-        if (!owned.ok) {
-          result = { origin: "unavailable", reason: owned.reason };
-          break;
-        }
-        const completeness = object.completeness === "partial" || capturedValueCompleteness(owned.value) === "partial" ? "partial" : "exact";
-        result = {
-          origin: "derived",
-          completeness,
-          value: owned.value,
-          dependencies: [expression.object]
-        };
-        break;
-      }
-      case "index": {
-        const array = evalChild(expression.array);
-        if (array.origin === "unavailable") {
-          result = array;
-          break;
-        }
-        if (!Array.isArray(array.value)) {
-          result = { origin: "unavailable", reason: "index_on_non_array" };
-          break;
-        }
-        if (expression.index < 0 || expression.index >= array.value.length) {
-          result = { origin: "unavailable", reason: "index_out_of_range" };
-          break;
-        }
-        const value = array.value[expression.index];
-        if (rasputinTagKind(value) === "unknown") {
-          result = { origin: "unavailable", reason: "array_hole" };
-          break;
-        }
-        const completeness = array.completeness === "partial" || capturedValueCompleteness(value) === "partial" ? "partial" : "exact";
-        result = {
-          origin: "derived",
-          completeness,
-          value,
-          dependencies: [expression.array]
-        };
-        break;
-      }
-      case "pure_call": {
-        const childReturn = takeChildCapturedReturn(state, expression.calleeFunctionId);
-        if (childReturn && "threw" in childReturn) {
-          result = { origin: "unavailable", reason: "callee_threw" };
-          break;
-        }
-        const capturedReturn = childReturn && "present" in childReturn ? capturedFromWire(childReturn.value) : void 0;
-        const callee = calleeReturns.get(expression.calleeFunctionId);
-        const callArgs = [];
-        let argsExact = true;
-        for (const argId of expression.args) {
-          const nested = evalChild(argId);
-          if (nested.origin === "unavailable" || nested.completeness === "partial") {
-            argsExact = false;
-            continue;
-          }
-          callArgs.push(nested.value);
-        }
-        if (argsExact && state.recordingCallId != null) {
-          recordReconstructedCallArgs(
-            state.omittedCallArgs,
-            state.recordingCallId,
-            expression.calleeFunctionId,
-            callArgs
-          );
-        }
-        const canDeriveCallee = Boolean(
-          argsExact && callee && !callee.fallbackReason && callee.returnExpressionId != null
-        );
-        const derivedReturn = canDeriveCallee && callee ? evaluateCallee(callee, callArgs) : void 0;
-        result = resolveCheckpoint(capturedReturn, derivedReturn, expression.id);
-        break;
-      }
-    }
-    if (result.origin !== "unavailable") {
-      state.outputBytes += estimateBytes(result.value);
-      const sizeOver = budgetExceeded(state);
-      if (sizeOver) result = { origin: "unavailable", reason: sizeOver };
-    }
-    if (result.origin === "derived" && result.completeness === "exact") {
-      for (const dep of result.dependencies) {
-        const child = cells.get(dep);
-        if (child?.status === "done" && child.result.origin !== "unavailable") {
-          if (child.result.completeness === "partial") {
-            result = { ...result, completeness: "partial" };
-            break;
-          }
-        }
-      }
-    }
-    cells.set(expressionId, { status: "done", result });
-    return result;
-  } finally {
-    state.depth--;
-  }
-};
-var isJsPrimitive = (value) => {
-  const type = typeof value;
-  return value === null || type !== "object" && type !== "function";
-};
-var abstractEquals = (left, right) => {
-  if (!isJsPrimitive(left) || !isJsPrimitive(right)) return void 0;
-  return left == right;
-};
-var applyBinary = (op, left, right) => {
-  if (op === "add" && typeof left === "number" && typeof right === "number") return left + right;
-  if (op === "add" && typeof left === "string" && typeof right === "string") return left + right;
-  if (typeof left !== "number" || typeof right !== "number") {
-    if (op === "eq") return abstractEquals(left, right);
-    if (op === "neq") {
-      const equal = abstractEquals(left, right);
-      return equal === void 0 ? void 0 : !equal;
+// src/derivation/sensitive-property-name.ts
+var DEFAULT_SENSITIVE_PROPERTY_NAMES = [
+  "password",
+  "passwd",
+  "pwd",
+  "passphrase",
+  "token",
+  "accesstoken",
+  "refreshtoken",
+  "sessiontoken",
+  "authorization",
+  "auth",
+  "bearer",
+  "cookie",
+  "cookies",
+  "signedcookies",
+  "setcookie",
+  "secret",
+  "secrets",
+  "clientsecret",
+  "apikey",
+  "xapikey",
+  "credential",
+  "credentials",
+  "privatekey",
+  "privkey",
+  "pem",
+  "jwt",
+  "otp",
+  "totp",
+  "pin",
+  "mfacode",
+  "sessionid",
+  "sid",
+  "databaseurl",
+  "connectionstring",
+  "dsn",
+  "mongouri",
+  "redisurl",
+  "signingkey",
+  "encryptionkey",
+  "cvv",
+  "cvc",
+  "cardnumber",
+  "ssn",
+  "creditcard",
+  "securitycode",
+  "twofactorcode",
+  "masterkey",
+  "servicerolekey",
+  "stripekey",
+  "rawheaders"
+];
+var DEFAULT_SENSITIVE_PROPERTY_NAME_SET = new Set(DEFAULT_SENSITIVE_PROPERTY_NAMES);
+var SENSITIVE_SEGMENTS = /* @__PURE__ */ new Set([
+  "password",
+  "passwd",
+  "pwd",
+  "passphrase",
+  "token",
+  "secret",
+  "cookie",
+  "cookies",
+  "authorization",
+  "auth",
+  "bearer",
+  "credential",
+  "credentials",
+  "jwt",
+  "otp",
+  "totp",
+  "pin",
+  "sid",
+  "dsn",
+  "pem",
+  "privkey",
+  "cvv",
+  "cvc",
+  "ssn",
+  "secrets"
+]);
+var SENSITIVE_SUFFIXES = [
+  "password",
+  "passwd",
+  "token",
+  "secret",
+  "apikey",
+  "privatekey",
+  "credential",
+  "credentials",
+  "cookie"
+];
+var compactKey = (key) => {
+  let compacted = "";
+  for (let index = 0; index < key.length; index++) {
+    const code = key.charCodeAt(index);
+    if (code === 45 || code === 46 || code === 95) continue;
+    compacted += code >= 65 && code <= 90 ? String.fromCharCode(code + 32) : key[index];
+  }
+  return compacted;
+};
+var stripTrailingDigits = (value) => {
+  let end = value.length;
+  while (end > 0) {
+    const code = value.charCodeAt(end - 1);
+    if (code < 48 || code > 57) break;
+    end--;
+  }
+  return end === 0 ? value : value.slice(0, end);
+};
+var segmentsOf = (key) => {
+  const segments = [];
+  let current = "";
+  for (let index = 0; index < key.length; index++) {
+    const char = key[index] ?? "";
+    const code = key.charCodeAt(index);
+    if (code === 45 || code === 46 || code === 95) {
+      if (current) segments.push(current.toLowerCase());
+      current = "";
+      continue;
     }
-    if (op === "seq") return left === right;
-    if (op === "sneq") return left !== right;
-    return void 0;
-  }
-  switch (op) {
-    case "add":
-      return left + right;
-    case "sub":
-      return left - right;
-    case "mul":
-      return left * right;
-    case "div":
-      return left / right;
-    case "mod":
-      return left % right;
-    case "eq":
-      return left === right;
-    case "neq":
-      return left !== right;
-    case "seq":
-      return left === right;
-    case "sneq":
-      return left !== right;
-    case "lt":
-      return left < right;
-    case "lte":
-      return left <= right;
-    case "gt":
-      return left > right;
-    case "gte":
-      return left >= right;
-  }
-};
-var evaluatePlan = (plan, args, roots, facts, plansByFunctionId, state, recordingCallId, capturedExit, threw = false) => {
-  const previousRecordingCallId = state.recordingCallId;
-  state.recordingCallId = recordingCallId;
-  try {
-    const byId = new Map(plan.expressions.map((expression) => [expression.id, expression]));
-    const cells = /* @__PURE__ */ new Map();
-    const rootsById = new Map(roots.map((root) => [root.rootId, root]));
-    const factsById = new Map(facts.map((fact) => [fact.factId, fact]));
-    const evaluateCallee = (callee, callArgs) => {
-      if (callee.returnExpressionId == null) {
-        return { origin: "unavailable", reason: "callee_without_return" };
+    if (current && code >= 65 && code <= 90) {
+      const prev = current.charCodeAt(current.length - 1);
+      const prevIsLower = prev >= 97 && prev <= 122;
+      const next = key.charCodeAt(index + 1);
+      const nextIsLower = next >= 97 && next <= 122;
+      if (prevIsLower || nextIsLower) {
+        segments.push(current.toLowerCase());
+        current = char;
+        continue;
       }
-      const nested = evaluatePlan(callee, callArgs, [], [], plansByFunctionId, state, null);
-      return nested.returnValue ?? { origin: "unavailable", reason: "callee_without_return" };
-    };
-    const values = {};
-    for (const expression of plan.expressions) {
-      values[expression.id] = evaluateExpression(
-        expression.id,
-        plan,
-        byId,
-        cells,
-        args,
-        rootsById,
-        factsById,
-        plansByFunctionId,
-        state,
-        evaluateCallee
-      );
     }
-    const variables = plan.variables.map((variable) => ({
-      variableId: variable.id,
-      name: variable.name,
-      availableAtLine: variable.availableAtLine,
-      availableAtColumn: variable.availableAtColumn,
-      result: values[variable.expressionId] ?? {
-        origin: "unavailable",
-        reason: "missing_expression"
-      }
-    }));
-    const derivedReturn = plan.returnExpressionId == null ? void 0 : values[plan.returnExpressionId] ?? {
-      origin: "unavailable",
-      reason: "missing_return"
-    };
-    return {
-      functionId: plan.functionId,
-      callId: roots[0]?.callId ?? facts[0]?.callId ?? 0,
-      values,
-      variables,
-      returnValue: threw ? void 0 : resolveCheckpoint(
-        capturedExit ? capturedFromWire(capturedExit.value) : void 0,
-        derivedReturn,
-        plan.returnExpressionId
-      )
-    };
-  } finally {
-    state.recordingCallId = previousRecordingCallId;
+    current += char;
   }
+  if (current) segments.push(current.toLowerCase());
+  return segments;
 };
-var evaluateRuntimeDerivation = (input) => {
-  if (!input.manifest) {
-    return { unavailableReason: "missing_manifest", functions: [] };
-  }
-  if (input.manifest.schema_version !== 3) {
-    return { unavailableReason: "manifest_version_mismatch", functions: [] };
-  }
-  const expectedHash = input.state.derivation?.manifestHash;
-  if (!expectedHash) {
-    return { unavailableReason: "missing_manifest_hash", functions: [] };
-  }
-  if (hashInstrumentationManifest(input.manifest) !== expectedHash) {
-    return { unavailableReason: "manifest_hash_mismatch", functions: [] };
-  }
-  const plansByFunctionId = new Map(
-    (input.manifest.derivationPlans ?? []).map((plan) => [plan.functionId, plan])
+var adjacentPairsSensitive = (left, right) => left === "api" && right === "key" || left === "private" && right === "key" || left === "client" && right === "secret" || left === "set" && right === "cookie" || left === "database" && right === "url" || left === "connection" && right === "string" || left === "mongo" && (right === "uri" || right === "url") || left === "mongodb" && (right === "uri" || right === "url") || left === "redis" && (right === "uri" || right === "url") || left === "postgres" && (right === "uri" || right === "url") || left === "database" && right === "uri" || left === "signing" && right === "key" || left === "master" && right === "key" || left === "stripe" && right === "key" || left === "service" && right === "role" || left === "security" && right === "code" || left === "two" && right === "factor" || left === "encryption" && right === "key" || left === "session" && (right === "id" || right === "key" || right === "token") || left === "card" && right === "number" || left === "mfa" && right === "code";
+var defaultSensitivePropertyNames = () => DEFAULT_SENSITIVE_PROPERTY_NAME_SET;
+var propertyNameIsSensitive = (key) => {
+  const compacted = compactKey(key);
+  const compactForms = [compacted, stripTrailingDigits(compacted)].filter(
+    (value, index, values) => value.length > 0 && values.indexOf(value) === index
   );
-  const roots = input.state.derivation?.roots ?? [];
-  const facts = input.state.derivation?.controlFacts ?? [];
-  const exitByCallId = /* @__PURE__ */ new Map();
-  const throwCallIds = /* @__PURE__ */ new Set();
-  const childrenByParent = /* @__PURE__ */ new Map();
-  for (const event of input.state.events) {
-    if (event.type === "function_enter" && event.parentCallId != null) {
-      const child = { callId: event.callId, functionId: event.functionId };
-      const siblings = childrenByParent.get(event.parentCallId);
-      if (siblings) siblings.push(child);
-      else childrenByParent.set(event.parentCallId, [child]);
-    }
-    if (event.type === "function_exit") {
-      exitByCallId.set(event.callId, { present: true, value: event.returnValue });
+  for (const form of compactForms) {
+    if (DEFAULT_SENSITIVE_PROPERTY_NAME_SET.has(form)) return true;
+    for (const suffix of SENSITIVE_SUFFIXES) {
+      if (form.endsWith(suffix)) return true;
     }
-    if (event.type === "function_throw") throwCallIds.add(event.callId);
+    if (form.includes("apikey") || form.includes("xapikey")) return true;
   }
-  const state = {
-    instructions: 0,
-    depth: 0,
-    outputBytes: 0,
-    startedAt: Date.now(),
-    recordingCallId: null,
-    omittedCallArgs: /* @__PURE__ */ new Map(),
-    exitByCallId,
-    throwCallIds,
-    childrenByParent,
-    childCursor: /* @__PURE__ */ new Map()
-  };
-  const enterEvents = input.state.events.filter((event) => event.type === "function_enter");
-  const functions = [];
-  for (const enter of enterEvents) {
-    const plan = plansByFunctionId.get(enter.functionId);
-    if (!plan) continue;
-    const callRoots = roots.filter((root) => root.callId === enter.callId);
-    const callFacts = facts.filter((fact) => fact.callId === enter.callId);
-    const evaluated = evaluatePlan(
-      plan,
-      resolveEnterArgs(enter, state.omittedCallArgs),
-      callRoots,
-      callFacts,
-      plansByFunctionId,
-      state,
-      enter.callId,
-      exitByCallId.get(enter.callId),
-      throwCallIds.has(enter.callId)
-    );
-    evaluated.callId = enter.callId;
-    functions.push(evaluated);
+  const segments = segmentsOf(key).map((segment) => stripTrailingDigits(segment) || segment);
+  for (const segment of segments) {
+    if (SENSITIVE_SEGMENTS.has(segment)) return true;
   }
-  return { functions };
-};
-var evaluatedValueAtLine = (evaluated, line) => {
-  if (!evaluated) return [];
-  return evaluated.variables.filter((variable) => line == null || variable.availableAtLine <= line).map((variable) => ({ name: variable.name, result: variable.result }));
+  for (let index = 0; index < segments.length - 1; index++) {
+    const left = segments[index];
+    const right = segments[index + 1];
+    if (left && right && adjacentPairsSensitive(left, right)) return true;
+  }
+  return false;
 };
 
 // src/instrumentation-manifest/instrumentation-manifest-types.ts
@@ -2592,7 +2213,7 @@ var INSTRUMENTATION_MANIFEST_SCHEMA_VERSION = 3;
 var uploadInstrumentationManifest = async (options) => {
   const release = options.release.trim();
   if (!release) return { ok: false };
-  const fetchFn = options.fetch ?? globalThis.fetch;
+  const fetchFn = options.fetch ?? defaultIngestFetch();
   try {
     const response = await fetchFn(options.url, {
       method: "POST",
@@ -2601,7 +2222,8 @@ var uploadInstrumentationManifest = async (options) => {
         "Content-Type": "application/json",
         Accept: "application/json"
       },
-      body: JSON.stringify({ release, manifest: options.manifest })
+      body: JSON.stringify({ release, manifest: options.manifest }),
+      ...options.signal ? { signal: options.signal } : {}
     });
     if (!response.ok) return { ok: false };
     const body = await response.json();
@@ -2615,21 +2237,21 @@ export {
   INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
   RASPUTIN_WIRE_TAG,
   announceDeploy,
-  capturedValueCompleteness,
   createClient,
   createIngestEvent,
   createSuppression,
   createTransport,
+  defaultSensitivePropertyNames,
   detectRelease,
-  evaluateRuntimeDerivation,
-  evaluatedValueAtLine,
+  foldSyntheticFrames,
   hashInstrumentationManifest,
   isClientEnabled,
+  isRasputinHandleRunFrame,
+  isRasputinShellFrame,
   isRasputinTaggedValue,
-  isRedactedCapturedValue,
-  isSerializerMarker,
   normalizeFrames,
   parseStack,
+  propertyNameIsSensitive,
   rasputinOmitted,
   rasputinRedacted,
   rasputinTagKind,