@rasputin-ai/core 0.1.4 → 0.3.0

package/dist/index.js

@@ -1,9 +1,9 @@
 // src/announce-deploy/announce-deploy.ts
 var announceDeploy = async (options) => {
   if (options.enabled === false) return "skipped";
-  const release = options.release?.trim();
+  const release = options.release?.trim() ?? "";
   const environment = options.environment.trim();
-  if (!release || !environment) return "skipped";
+  if (!environment) return "skipped";
   const fetchFn = options.fetch ?? globalThis.fetch;
   try {
     const response = await fetchFn(options.deployUrl, {
@@ -22,15 +22,116 @@ var announceDeploy = async (options) => {
   }
 };
 
-// src/create-ingest-event/create-ingest-event.ts
+// src/create-ingest-event/truncate-ingest-message.ts
 var MAX_MESSAGE_BYTES = 8 * 1024;
-var MAX_STACK_FRAMES = 50;
+var utf8Bytes = (value) => Buffer.byteLength(value, "utf8");
 var truncateUtf8 = (value, maxBytes) => {
-  if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
+  if (utf8Bytes(value) <= maxBytes) return value;
   let end = Math.min(value.length, maxBytes);
-  while (end > 0 && Buffer.byteLength(value.slice(0, end), "utf8") > maxBytes) end--;
+  while (end > 0 && utf8Bytes(value.slice(0, end)) > maxBytes) end--;
   return value.slice(0, end);
 };
+var truncation = (reason, extra = {}) => ({
+  __rasputin_truncated: true,
+  __reason: reason,
+  ...extra
+});
+var mapJson = (value, maxStringChars, maxArrayItems, maxObjectKeys) => {
+  if (typeof value === "string") {
+    if (value.length <= maxStringChars) return value;
+    if (maxStringChars <= 1) return value.slice(0, maxStringChars);
+    return `${value.slice(0, maxStringChars - 1)}\u2026`;
+  }
+  if (Array.isArray(value)) {
+    const keep = maxArrayItems === null ? value.length : Math.min(value.length, maxArrayItems);
+    const items = value.slice(0, keep).map((item) => mapJson(item, maxStringChars, maxArrayItems, maxObjectKeys));
+    if (keep < value.length) {
+      items.push(truncation("max_array_elements", { __original_length: value.length }));
+    }
+    return items;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    const keep = maxObjectKeys === null ? entries.length : Math.min(entries.length, maxObjectKeys);
+    const out = {};
+    for (const [key, child] of entries.slice(0, keep)) {
+      out[key] = mapJson(child, maxStringChars, maxArrayItems, maxObjectKeys);
+    }
+    if (keep < entries.length) {
+      Object.assign(out, truncation("max_object_keys", { __original_length: entries.length }));
+    }
+    return out;
+  }
+  return value;
+};
+var jsonIfFits = (value, maxBytes) => {
+  const json = JSON.stringify(value);
+  return utf8Bytes(json) <= maxBytes ? json : null;
+};
+var boundJsonMessage = (value, maxBytes) => {
+  const fit = (maxStringChars, maxArrayItems, maxObjectKeys) => jsonIfFits(mapJson(value, maxStringChars, maxArrayItems, maxObjectKeys), maxBytes);
+  const longestStringsThatFit = (maxArrayItems, maxObjectKeys) => {
+    let lo = 0;
+    let hi = maxBytes;
+    let best = null;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const candidate = fit(mid, maxArrayItems, maxObjectKeys);
+      if (candidate) {
+        best = candidate;
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return best;
+  };
+  const withAllKeys = longestStringsThatFit(null, null);
+  if (withAllKeys) return withAllKeys;
+  const searchCount = (emptyFits, fillStrings) => {
+    let lo = 0;
+    let hi = 1;
+    while (!emptyFits(hi) && hi < 1048576) hi *= 2;
+    let best = 0;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      if (emptyFits(mid)) {
+        best = mid;
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return fillStrings(best);
+  };
+  const withFewerArrayItems = searchCount(
+    (count) => fit(0, count, null) !== null,
+    (count) => longestStringsThatFit(count, null)
+  );
+  if (withFewerArrayItems) return withFewerArrayItems;
+  return searchCount(
+    (count) => fit(0, 0, count) !== null,
+    (count) => longestStringsThatFit(0, count)
+  ) ?? JSON.stringify(
+    Array.isArray(value) ? [truncation("max_array_elements", { __original_length: value.length })] : truncation("max_object_keys", { __original_length: Object.keys(value).length })
+  );
+};
+var truncateIngestMessage = (value, maxBytes = MAX_MESSAGE_BYTES) => {
+  if (utf8Bytes(value) <= maxBytes) return value;
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed !== null && typeof parsed === "object") {
+      const compact = JSON.stringify(parsed);
+      if (utf8Bytes(compact) <= maxBytes) return compact;
+      return boundJsonMessage(parsed, maxBytes);
+    }
+  } catch {
+  }
+  return truncateUtf8(value, maxBytes);
+};
+
+// src/create-ingest-event/create-ingest-event.ts
+var MAX_STACK_FRAMES = 50;
 var errorFields = (error) => {
   if (error instanceof Error) {
     const code = "code" in error && (typeof error.code === "string" || typeof error.code === "number") ? String(error.code) : void 0;
@@ -79,18 +180,19 @@ var createIngestEvent = (input) => {
   const occurred = input.occurredAt === void 0 ? (/* @__PURE__ */ new Date()).toISOString() : typeof input.occurredAt === "string" ? input.occurredAt : input.occurredAt.toISOString();
   const event = {
     type: extracted.type,
-    message: truncateUtf8(extracted.message, MAX_MESSAGE_BYTES),
+    message: truncateIngestMessage(extracted.message),
     stack_frames: framesToStackFrames(input.frames),
     occurred_at: occurred,
     environment: input.environment,
     origin: input.origin,
-    resolution: input.resolution
+    resolution: input.resolution,
+    release: input.release
   };
   const code = input.code !== void 0 ? input.code : extracted.code;
   if (code !== void 0) event.code = code;
-  if (input.release !== void 0) event.release = input.release;
   const request = sanitizeRequest(input.request);
   if (request) event.request = request;
+  if (input.runtimeState) event.runtime_state = input.runtimeState;
   return event;
 };
 
@@ -111,25 +213,62 @@ var finalizeResolution = (resolution, stackFrames) => {
 };
 
 // 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",
-  "SOURCE_VERSION",
+  "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) return explicit;
+  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) return value;
+    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 `release` in RasputinInit or a commit SHA env var (e.g. GIT_COMMIT, VERCEL_GIT_COMMIT_SHA). Without a release, deploy correlation and diagnosis confidence are degraded."
+    "[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;
 };
@@ -168,8 +307,8 @@ var isInApp = (file, underRoot) => {
   if (/(^|\/)node_modules\//.test(file)) return false;
   return true;
 };
-var normalizeFrames = (frames, options = {}) => {
-  const appRoot = options.appRoot ?? process.cwd();
+var normalizeFrames = (frames, options) => {
+  const appRoot = options.appRoot;
   return frames.map((frame) => {
     const generated = normalizeFile(frame.generated.file, appRoot);
     const original = frame.original ? normalizeFile(frame.original.file, appRoot) : void 0;
@@ -250,10 +389,93 @@ var parseStack = (stack) => {
   return frames;
 };
 
+// src/repo-root/repo-root-from.ts
+import { existsSync } from "node:fs";
+import { dirname, join as join2, resolve as resolve2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var isGitRoot = (dir) => existsSync(join2(dir, ".git"));
+var hasPackageJson = (dir) => existsSync(join2(dir, "package.json"));
+var repoRootFrom = (moduleUrl) => {
+  let current = resolve2(dirname(fileURLToPath2(moduleUrl)));
+  let packageRoot;
+  while (true) {
+    if (isGitRoot(current)) return current;
+    if (hasPackageJson(current)) packageRoot = current;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return packageRoot ?? resolve2(dirname(fileURLToPath2(moduleUrl)));
+};
+
+// src/repo-root/resolve-repo-root.ts
+var resolveRepoRoot = (options) => {
+  const repoRoot = options.repoRoot?.trim();
+  if (repoRoot) return repoRoot;
+  const moduleUrl = options.moduleUrl?.trim();
+  if (moduleUrl) return repoRootFrom(moduleUrl);
+  return void 0;
+};
+
+// src/repo-root/warn-repo-root-setup.ts
+var BUILD_OUTPUT_SEGMENTS = /* @__PURE__ */ new Set(["dist", "build", "out", ".next", "coverage"]);
+var warnedMissing = false;
+var warnedSuspicious = false;
+var BANNER = "======== [rasputin] WARNING";
+var looksLikeBuildOutputRoot = (root) => {
+  const posix = root.replaceAll("\\", "/").replace(/\/+$/, "");
+  return posix.split("/").some((segment) => BUILD_OUTPUT_SEGMENTS.has(segment));
+};
+var warnIfMissingRepoRoot = () => {
+  if (warnedMissing) return;
+  warnedMissing = true;
+  console.warn(
+    `
+
+${BANNER}: we don't know where your project is ========
+Rasputin needs to know which folder your app lives in so errors show
+the right file paths in the dashboard.
+
+Add this to RasputinInit (from the same file you call it in):
+
+  moduleUrl: import.meta.url
+
+Or set repoRoot to the folder you open in your editor.
+
+Nothing will be sent until this is set.
+======================================================================
+`
+  );
+};
+var warnIfSuspiciousRepoRoot = (root) => {
+  if (warnedSuspicious || !looksLikeBuildOutputRoot(root)) return;
+  warnedSuspicious = true;
+  console.warn(
+    `
+
+${BANNER}: this looks like a build folder, not your project ========
+Rasputin thinks your project is here:
+  ${root}
+
+That's usually compiled output (dist, build, .next, \u2026), not the folder
+you write code in. Error locations in the dashboard will be wrong.
+
+Point Rasputin at the folder you open in your editor.
+
+Easiest fix \u2014 from the file where you call RasputinInit:
+
+  moduleUrl: import.meta.url
+
+Or set repoRoot yourself.
+======================================================================
+`
+  );
+};
+
 // src/resolve-source-maps/resolve-source-maps.ts
 import { readFile } from "node:fs/promises";
-import { dirname, isAbsolute as isAbsolute2, join } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join3 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } 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*$/;
@@ -261,7 +483,7 @@ var mapCache = /* @__PURE__ */ new Map();
 var toPath = (file) => {
   if (file.startsWith("file://")) {
     try {
-      return fileURLToPath2(file);
+      return fileURLToPath3(file);
     } catch {
       return file;
     }
@@ -302,7 +524,7 @@ var readMapPayload = async (generatedPath) => {
   if (comment?.startsWith("data:")) return decodeDataUrl(comment);
   if (comment) {
     try {
-      return await readFile(join(dirname(generatedPath), comment), "utf8");
+      return await readFile(join3(dirname2(generatedPath), comment), "utf8");
     } catch {
     }
   }
@@ -349,7 +571,7 @@ var resolveFrame = async (raw) => {
   return {
     ...base,
     original: {
-      file: isAbsolute2(pos.source) ? pos.source : join(dirname(generatedPath), pos.source),
+      file: isAbsolute2(pos.source) ? pos.source : join3(dirname2(generatedPath), pos.source),
       line: pos.line,
       column: pos.column ?? void 0,
       name: pos.name ?? void 0
@@ -369,7 +591,7 @@ var resolveSourceMaps = async (frames) => {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/core";
-var SDK_VERSION = "0.1.4";
+var SDK_VERSION = "0.3.0";
 
 // src/suppression/identity-needs-message-template.ts
 var identityNeedsMessageTemplate = (type, code) => {
@@ -431,14 +653,22 @@ var RULES = [
     pattern: /\b(?=[a-z0-9]*[a-z])(?=[a-z0-9]*\d)[a-z0-9]{8,}\b/giu
   }
 ];
-var parameterizeMessage = (rawMessage) => {
-  if (rawMessage.length > MAX_INPUT_LENGTH) return rawMessage;
-  const normalized = rawMessage.normalize("NFKC").replace(/\r\n?/g, "\n").trim();
+var normalizeForIdentity = (normalized) => {
+  try {
+    return JSON.stringify(JSON.parse(normalized));
+  } catch {
+  }
   const lines = normalized.split("\n").filter((line) => line.trim());
   let result = lines.slice(0, 2).join("\n");
   if (result !== normalized) {
     result += "...";
   }
+  return result;
+};
+var parameterizeMessage = (rawMessage) => {
+  if (rawMessage.length > MAX_INPUT_LENGTH) return rawMessage;
+  const normalized = rawMessage.normalize("NFKC").replace(/\r\n?/g, "\n").trim();
+  let result = normalizeForIdentity(normalized);
   result = result.replace(/\b([A-Za-z_][\w.-]*)=(["'])(?:\\.|(?!\2).)*\2/gu, "$1=<string>");
   result = result.replace(/\b([A-Za-z_][\w.-]*)=(?:true|false)\b/giu, "$1=<bool>");
   for (const rule of RULES) {
@@ -454,21 +684,43 @@ var parameterizeMessage = (rawMessage) => {
 };
 
 // src/suppression/compute-burst-key.ts
+var FRAME_COUNT = 4;
 var preferredFile = (frame) => (frame.original ?? frame.generated).file;
-var frameBurstParts = (frames) => {
-  return frames.filter((frame) => frame.in_app).slice(0, 3).map((frame) => {
+var normalizeFunction = (raw) => {
+  if (!raw) return "";
+  const name = raw.trim();
+  if (name === "<anonymous>" || name === "anonymous") return "";
+  return name.replace(/^(async|new|get|set|bound)\s+/, "").replace(/^Object\./, "").replace(/\s+\[as .+\]$/, "");
+};
+var collapseConsecutive = (frames) => {
+  const out = [];
+  let previousKey = null;
+  for (const frame of frames) {
     const file = preferredFile(frame);
-    const fn = frame.function ?? frame.original?.name ?? "";
-    if (!frame.original && frame.generated.line !== void 0) {
-      return `${file}:${fn}:${frame.generated.line}:${frame.generated.column ?? 0}`;
+    const fn = normalizeFunction(frame.function ?? frame.original?.name);
+    const key = `${file}#${fn}`;
+    if (key !== previousKey) {
+      out.push(frame);
+      previousKey = key;
     }
+  }
+  return out;
+};
+var frameBurstParts = (frames) => {
+  const collapsed = collapseConsecutive(frames);
+  const inApp = collapsed.filter((frame) => frame.in_app);
+  const selected = (inApp.length > 0 ? inApp : collapsed).slice(0, FRAME_COUNT);
+  return selected.map((frame) => {
+    const file = preferredFile(frame);
+    const fn = normalizeFunction(frame.function ?? frame.original?.name);
     return `${file}:${fn}`;
   });
 };
 var computeBurstKey = (errorType, message, code, frames) => {
   const parts = frameBurstParts(frames);
-  let key = `${errorType}\0${parts.join("\0")}`;
-  if (identityNeedsMessageTemplate(errorType, code)) {
+  const codePart = code ?? "";
+  let key = `${errorType}\0${codePart}\0${parts.join("\0")}`;
+  if (parts.length === 0 || identityNeedsMessageTemplate(errorType, code)) {
     key += `\0${parameterizeMessage(message)}`;
   }
   return key;
@@ -537,7 +789,7 @@ var createSuppression = (options = {}) => {
     const identity = captureIdentity(input);
     const captureRawFrames = (input.rawFrames ?? []).slice(0, MAX_STACK_FRAMES);
     const burstKey = computeBurstKey(input.errorType, input.message, input.code, input.frames);
-    const release = input.release ?? null;
+    const release = input.release;
     const route = input.route ?? null;
     let bucket = burstBuckets.get(burstKey);
     if (!bucket) {
@@ -579,7 +831,7 @@ var createSuppression = (options = {}) => {
     bucket.suppressed += 1;
     return { action: "suppress" };
   };
-  const takeSummaries = async (now = Date.now(), prepareSummary) => {
+  const drainSummaries = (now = Date.now()) => {
     const drafts = pending.splice(0, pending.length);
     for (const bucket of burstBuckets.values()) {
       if (bucket.suppressed > 0) {
@@ -587,22 +839,32 @@ var createSuppression = (options = {}) => {
         bucket.suppressed = 0;
       }
     }
+    return drafts.map((draft) => ({
+      summary: toSummary(draft, draft.identity),
+      rawFrames: draft.captureRawFrames
+    }));
+  };
+  const takeSummaries = async (now = Date.now(), prepareSummary) => {
+    const drafts = drainSummaries(now);
+    if (!prepareSummary) return drafts.map((draft) => draft.summary);
     const out = [];
     for (const draft of drafts) {
-      let identity = draft.identity;
-      if (prepareSummary && draft.captureRawFrames.length > 0) {
-        try {
-          const resolved = await prepareSummary(draft.captureRawFrames);
-          identity = { ...identity, ...resolved };
-        } catch {
-        }
+      if (draft.rawFrames.length === 0) {
+        out.push(draft.summary);
+        continue;
+      }
+      try {
+        const resolved = await prepareSummary(draft.rawFrames);
+        out.push({ ...draft.summary, ...resolved });
+      } catch {
+        out.push(draft.summary);
       }
-      out.push(toSummary(draft, identity));
     }
     return out;
   };
   return {
     decide,
+    drainSummaries,
     takeSummaries,
     /** Test helper — number of active burst buckets. */
     size: () => burstBuckets.size
@@ -611,7 +873,21 @@ var createSuppression = (options = {}) => {
 
 // src/transport/send-batch.ts
 import { gzipSync } from "node:zlib";
-var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var sleep = (ms, signal) => new Promise((resolve3) => {
+  if (signal?.aborted) {
+    resolve3();
+    return;
+  }
+  const timer = setTimeout(resolve3, ms);
+  signal?.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(timer);
+      resolve3();
+    },
+    { once: true }
+  );
+});
 var backoffMs = (attempt) => {
   const base = Math.min(3e4, 500 * 2 ** attempt);
   return Math.floor(base * (0.5 + Math.random()));
@@ -634,6 +910,7 @@ var sendBatch = async (options) => {
   }
   if (options.sdkVersion) payload.sdk_version = options.sdkVersion;
   if (options.sdkName) payload.sdk_name = options.sdkName;
+  if (options.idempotencyKey) payload.idempotency_key = options.idempotencyKey;
   const json = JSON.stringify(payload);
   const headers = {
     Authorization: `Bearer ${options.projectApiKey}`,
@@ -661,16 +938,16 @@ var sendBatch = async (options) => {
       if (response.status === 429) {
         if (attempt === options.maxRetries) return "failed";
         const wait = retryAfterMs(response) ?? backoffMs(attempt);
-        await sleep(wait);
+        await sleep(wait, options.signal);
         continue;
       }
       if (response.status >= 400 && response.status < 500) return "dropped";
       if (attempt === options.maxRetries) return "failed";
-      await sleep(backoffMs(attempt));
+      await sleep(backoffMs(attempt), options.signal);
     } catch {
       if (options.signal?.aborted) return "failed";
       if (attempt === options.maxRetries) return "failed";
-      await sleep(backoffMs(attempt));
+      await sleep(backoffMs(attempt), options.signal);
     }
   }
   return "failed";
@@ -684,6 +961,9 @@ var RANK = {
 };
 var createQueue = (maxSize) => {
   const items = [];
+  let enqueued = 0;
+  let droppedIncoming = 0;
+  let droppedQueued = 0;
   const oldestLowestIndex = () => {
     let best = 0;
     for (let i = 1; i < items.length; i++) {
@@ -699,16 +979,28 @@ var createQueue = (maxSize) => {
       const victimIndex = oldestLowestIndex();
       const victim = items[victimIndex];
       if (!victim) break;
-      if (RANK[item.priority] < RANK[victim.priority]) return;
+      if (RANK[item.priority] < RANK[victim.priority]) {
+        droppedIncoming++;
+        return;
+      }
       items.splice(victimIndex, 1);
+      droppedQueued++;
     }
     items.push(item);
+    enqueued++;
   };
   const drain = (count) => items.splice(0, count);
   return {
     enqueue,
     drain,
     size: () => items.length,
+    getStats: () => ({
+      queued: items.length,
+      enqueued,
+      droppedIncoming,
+      droppedQueued,
+      droppedTotal: droppedIncoming + droppedQueued
+    }),
     clear: () => {
       items.length = 0;
     }
@@ -725,6 +1017,20 @@ var DEFAULTS2 = {
   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);
+};
 var createTransport = (options) => {
   const enabled = options.enabled ?? DEFAULTS2.enabled;
   const batchSize = options.batchSize ?? DEFAULTS2.batchSize;
@@ -736,6 +1042,8 @@ var createTransport = (options) => {
   let timer;
   let flushing;
   let closed = false;
+  let shuttingDown = false;
+  let retryBatch = null;
   const schedule = () => {
     if (timer || !enabled || closed) return;
     timer = setInterval(() => {
@@ -748,9 +1056,19 @@ var createTransport = (options) => {
     clearInterval(timer);
     timer = void 0;
   };
+  const prepareSummary = async (item) => {
+    if (!options.prepareSummary || item.rawFrames.length === 0) return item.summary;
+    try {
+      const resolved = await options.prepareSummary(item.rawFrames);
+      return { ...item.summary, ...resolved };
+    } catch {
+      return item.summary;
+    }
+  };
   const flush = async (timeoutMs = 1e4) => {
     if (!enabled || closed) {
       queue.clear();
+      retryBatch = null;
       return;
     }
     if (flushing) return flushing;
@@ -758,15 +1076,17 @@ var createTransport = (options) => {
       const controller = new AbortController();
       const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
       try {
-        while (queue.size() > 0) {
+        while (queue.size() > 0 || retryBatch) {
           if (controller.signal.aborted) break;
-          const batch = queue.drain(batchSize);
+          const batch = retryBatch?.items ?? queue.drain(batchSize);
+          const idempotencyKey = retryBatch?.idempotencyKey ?? crypto.randomUUID();
+          retryBatch = null;
           if (batch.length === 0) break;
           const events = [];
           const summaries = [];
           for (const item of batch) {
             if (item.kind === "summary") {
-              summaries.push(item.summary);
+              summaries.push(await prepareSummary(item));
               continue;
             }
             if (options.prepareEvent && item.rawFrames.length > 0) {
@@ -789,6 +1109,7 @@ var createTransport = (options) => {
             projectApiKey: options.projectApiKey,
             events,
             summaries,
+            idempotencyKey,
             sdkVersion: options.sdkVersion,
             sdkName: options.sdkName,
             gzipThresholdBytes,
@@ -797,13 +1118,13 @@ var createTransport = (options) => {
             signal: controller.signal
           });
           if (result === "failed") {
-            for (const item of batch) queue.enqueue(item);
+            retryBatch = { items: batch, idempotencyKey };
             break;
           }
         }
       } finally {
         if (timeout) clearTimeout(timeout);
-        if (queue.size() === 0) stopTimer();
+        if (queue.size() === 0 && !retryBatch) stopTimer();
         flushing = void 0;
       }
     })();
@@ -815,38 +1136,53 @@ var createTransport = (options) => {
     schedule();
     if (queue.size() >= batchSize) void flush();
   };
-  const enqueueSummary = (summary) => {
+  const enqueueSummary = (summary, rawFrames = []) => {
     if (!enabled || closed) return;
-    queue.enqueue({ kind: "summary", summary, priority: "summary" });
+    queue.enqueue({ kind: "summary", summary, priority: "summary", rawFrames });
     schedule();
     if (queue.size() >= batchSize) void flush();
   };
+  const onBeforeExit = () => {
+    if (closed || shuttingDown) return;
+    if (queue.size() === 0 && !retryBatch && !flushing) return;
+    void flush(2e3).catch(() => {
+    });
+  };
   const onSignal = () => {
-    try {
-      void flush(2e3);
-    } catch {
-    }
+    if (shuttingDown) return;
+    shuttingDown = true;
+    stopTimer();
+    holdProcessExitUntil(flush(2e3).catch(() => {
+    }));
   };
   if (enabled && (options.installSignalHandlers ?? DEFAULTS2.installSignalHandlers)) {
-    process.on("beforeExit", onSignal);
+    process.on("beforeExit", onBeforeExit);
     process.on("SIGTERM", onSignal);
     process.on("SIGINT", onSignal);
   }
   const close = async () => {
-    closed = true;
     stopTimer();
-    process.off("beforeExit", onSignal);
-    process.off("SIGTERM", onSignal);
-    process.off("SIGINT", onSignal);
+    removeProcessListener("beforeExit", onBeforeExit);
+    removeProcessListener("SIGTERM", onSignal);
+    removeProcessListener("SIGINT", onSignal);
     await flush(2e3);
+    closed = true;
     queue.clear();
+    retryBatch = null;
   };
   return {
     enqueue,
     enqueueSummary,
     flush,
     close,
-    size: () => queue.size()
+    size: () => queue.size() + (retryBatch?.items.length ?? 0),
+    getStats: () => {
+      const queueStats = queue.getStats();
+      return {
+        ...queueStats,
+        queued: queueStats.queued + (retryBatch?.items.length ?? 0)
+      };
+    }
   };
 };
 
@@ -858,7 +1194,16 @@ var noopClient = () => ({
   flush: async () => {
   },
   close: async () => {
-  }
+  },
+  getStats: () => ({
+    transport: {
+      queued: 0,
+      enqueued: 0,
+      droppedIncoming: 0,
+      droppedQueued: 0,
+      droppedTotal: 0
+    }
+  })
 });
 
 // src/create-client/resolve-endpoint-urls.ts
@@ -867,7 +1212,8 @@ var resolveEndpointUrls = (apiUrl = DEFAULT_API_URL) => {
   const base = apiUrl.replace(/\/+$/, "");
   return {
     ingestUrl: `${base}/ingest`,
-    deployUrl: `${base}/deploy`
+    deployUrl: `${base}/deploy`,
+    instrumentationManifestUrl: `${base}/instrumentationManifest`
   };
 };
 
@@ -888,12 +1234,6 @@ var warnPartialResolution = () => {
     "[rasputin] Source map paths could not be normalized to the repo root; fingerprinting may be degraded"
   );
 };
-var prepareResolvedEvent = (event, normalized, resolution) => {
-  const stackFrames = framesToStackFrames(normalized);
-  const finalResolution = finalizeResolution(resolution, stackFrames);
-  if (finalResolution === "partial") warnPartialResolution();
-  return withResolvedFrames(event, normalized, finalResolution);
-};
 var toResolvedFrames = (raw) => raw.map((frame) => ({
   generated: { file: frame.file, line: frame.line, column: frame.column },
   ...frame.function ? { function: frame.function } : {}
@@ -909,7 +1249,46 @@ var createClient = (options, hooks = {}) => {
     const release = detectRelease({ release: options.release });
     const environment = options.environment;
     const { ingestUrl, deployUrl } = resolveEndpointUrls(options.apiUrl);
-    const repoRoot = options.repoRoot;
+    if (!release) {
+      if (hooks.announceDeploy ?? true) {
+        void announceDeploy({
+          deployUrl,
+          projectApiKey,
+          environment,
+          fetch: hooks.fetch
+        });
+      }
+      return noopClient();
+    }
+    const repoRoot = resolveRepoRoot(options);
+    if (!repoRoot) {
+      warnIfMissingRepoRoot();
+      return noopClient();
+    }
+    warnIfSuspiciousRepoRoot(repoRoot);
+    const MAX_STACK_RESOLVE_CACHE = 32;
+    const stackResolveCache = /* @__PURE__ */ new Map();
+    const stackCacheKey = (rawFrames) => rawFrames.map((frame) => `${frame.file}\0${frame.line}\0${frame.column}\0${frame.function ?? ""}`).join("\n");
+    const resolveStack = async (rawFrames) => {
+      const key = stackCacheKey(rawFrames);
+      const cached = stackResolveCache.get(key);
+      if (cached) return cached;
+      const pending = (async () => {
+        const { frames, resolution, unresolvedGenerated } = await resolveSourceMaps(rawFrames);
+        warnUnresolvedMaps(unresolvedGenerated);
+        const normalized = normalizeFrames(frames, { appRoot: repoRoot });
+        const stack_frames = framesToStackFrames(normalized);
+        const finalResolution = finalizeResolution(resolution, stack_frames);
+        if (finalResolution === "partial") warnPartialResolution();
+        return { frames: normalized, stack_frames, resolution: finalResolution };
+      })();
+      stackResolveCache.set(key, pending);
+      if (stackResolveCache.size > MAX_STACK_RESOLVE_CACHE) {
+        const oldest = stackResolveCache.keys().next().value;
+        if (oldest !== void 0) stackResolveCache.delete(oldest);
+      }
+      return pending;
+    };
     const transport = createTransport({
       ingestUrl,
       projectApiKey,
@@ -919,10 +1298,12 @@ var createClient = (options, hooks = {}) => {
       sdkVersion: hooks.sdkVersion ?? SDK_VERSION,
       sdkName: hooks.sdkName ?? SDK_NAME,
       prepareEvent: async ({ event, rawFrames }) => {
-        const { frames, resolution, unresolvedGenerated } = await resolveSourceMaps(rawFrames);
-        warnUnresolvedMaps(unresolvedGenerated);
-        const normalized = normalizeFrames(frames, { appRoot: repoRoot });
-        return prepareResolvedEvent(event, normalized, resolution);
+        const prepared = await resolveStack(rawFrames);
+        return withResolvedFrames(event, prepared.frames, prepared.resolution);
+      },
+      prepareSummary: async (rawFrames) => {
+        const prepared = await resolveStack(rawFrames);
+        return { stack_frames: prepared.stack_frames, resolution: prepared.resolution };
       }
     });
     const suppression = createSuppression();
@@ -947,7 +1328,8 @@ var createClient = (options, hooks = {}) => {
           release,
           origin: "server",
           resolution: "none",
-          request: context?.request
+          request: context?.request,
+          runtimeState: context?.runtimeState
         });
         const decision = suppression.decide({
           errorType: event.type,
@@ -966,40 +1348,62 @@ var createClient = (options, hooks = {}) => {
       } catch {
       }
     };
+    const enqueuePendingSummaries = () => {
+      for (const { summary, rawFrames } of suppression.drainSummaries()) {
+        transport.enqueueSummary(summary, rawFrames);
+      }
+    };
     const flush = async (timeoutMs) => {
       try {
-        const summaries = await suppression.takeSummaries(Date.now(), async (raw) => {
-          const { frames, resolution, unresolvedGenerated } = await resolveSourceMaps(raw);
-          warnUnresolvedMaps(unresolvedGenerated);
-          const normalized = normalizeFrames(frames, { appRoot: repoRoot });
-          const stack_frames = framesToStackFrames(normalized);
-          const finalResolution = finalizeResolution(resolution, stack_frames);
-          if (finalResolution === "partial") warnPartialResolution();
-          return {
-            stack_frames,
-            resolution: finalResolution
-          };
-        });
-        for (const summary of summaries) {
-          transport.enqueueSummary(summary);
-        }
+        enqueuePendingSummaries();
         await transport.flush(timeoutMs);
       } catch {
       }
     };
     const close = async () => {
       try {
-        await flush(2e3);
+        enqueuePendingSummaries();
         await transport.close();
       } catch {
       }
     };
-    return { captureException, flush, close };
+    return {
+      captureException,
+      flush,
+      close,
+      getStats: () => ({ transport: transport.getStats() })
+    };
   } catch {
     return noopClient();
   }
 };
+
+// src/instrumentation-manifest/instrumentation-manifest-types.ts
+var INSTRUMENTATION_MANIFEST_SCHEMA_VERSION = 1;
+
+// src/instrumentation-manifest/upload-instrumentation-manifest.ts
+var uploadInstrumentationManifest = async (options) => {
+  const release = options.release.trim();
+  if (!release) return "failed";
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  try {
+    const response = await fetchFn(options.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${options.projectApiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({ release, manifest: options.manifest })
+    });
+    if (response.ok) return "ok";
+    return "failed";
+  } catch {
+    return "failed";
+  }
+};
 export {
+  INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
   announceDeploy,
   createClient,
   createIngestEvent,
@@ -1009,5 +1413,9 @@ export {
   isClientEnabled,
   normalizeFrames,
   parseStack,
-  resolveSourceMaps
+  repoRootFrom,
+  resolveEndpointUrls,
+  resolveRepoRoot,
+  resolveSourceMaps,
+  uploadInstrumentationManifest
 };