@rasputin-ai/core 0.1.2

package/dist/index.js

@@ -0,0 +1,1013 @@
+// src/announce-deploy/announce-deploy.ts
+var announceDeploy = async (options) => {
+  if (options.enabled === false) return "skipped";
+  const release = options.release?.trim();
+  const environment = options.environment.trim();
+  if (!release || !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";
+  } catch {
+    return "failed";
+  }
+};
+
+// src/create-ingest-event/create-ingest-event.ts
+var MAX_MESSAGE_BYTES = 8 * 1024;
+var MAX_STACK_FRAMES = 50;
+var truncateUtf8 = (value, maxBytes) => {
+  if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
+  let end = Math.min(value.length, maxBytes);
+  while (end > 0 && Buffer.byteLength(value.slice(0, end), "utf8") > maxBytes) end--;
+  return value.slice(0, end);
+};
+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;
+    return {
+      type: error.name || "Error",
+      message: error.message || String(error),
+      code
+    };
+  }
+  if (typeof error === "string") {
+    return { type: "string", message: error };
+  }
+  return { type: "Error", message: String(error) };
+};
+var toStackFrame = (frame) => {
+  const preferred = frame.original ?? frame.generated;
+  const filename = (preferred.file || frame.generated.file).trim();
+  if (!filename) return null;
+  const fn = frame.function ?? frame.original?.name;
+  return {
+    filename,
+    ...fn ? { function: fn } : {},
+    ...preferred.line !== void 0 ? { lineno: preferred.line } : {},
+    ...preferred.column !== void 0 ? { colno: preferred.column } : {},
+    in_app: frame.in_app
+  };
+};
+var sanitizeRequest = (request) => {
+  if (!request) return void 0;
+  const { method, route, status } = request;
+  if (method == null && route == null && status == null) return void 0;
+  return {
+    ...method != null ? { method } : {},
+    ...route != null ? { route } : {},
+    ...status != null ? { status } : {}
+  };
+};
+var framesToStackFrames = (frames) => frames.slice(0, MAX_STACK_FRAMES).map(toStackFrame).filter((frame) => frame !== null);
+var withResolvedFrames = (event, frames, resolution) => ({
+  ...event,
+  stack_frames: framesToStackFrames(frames),
+  resolution
+});
+var createIngestEvent = (input) => {
+  const extracted = errorFields(input.error);
+  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),
+    stack_frames: framesToStackFrames(input.frames),
+    occurred_at: occurred,
+    environment: input.environment,
+    origin: input.origin,
+    resolution: input.resolution
+  };
+  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;
+  return event;
+};
+
+// src/create-ingest-event/finalize-resolution.ts
+var SOURCE_EXT = /\.(ts|tsx|mts|cts)$/i;
+var isAbsolutePath = (file) => file.startsWith("/") || /^[A-Za-z]:[\\/]/.test(file);
+var isRuntimeFrame = (file) => !file || file === "native" || /^(node:|bun:)/.test(file);
+var finalizeResolution = (resolution, stackFrames) => {
+  if (resolution !== "exact") return resolution;
+  const mapped = stackFrames.filter((frame) => !isRuntimeFrame(frame.filename));
+  if (mapped.some((frame) => frame.filename.includes("..") || isAbsolutePath(frame.filename))) {
+    return "partial";
+  }
+  const resolvedSource = mapped.some((frame) => SOURCE_EXT.test(frame.filename));
+  const hasInApp = stackFrames.some((frame) => frame.in_app);
+  if (resolvedSource && !hasInApp) return "partial";
+  return "exact";
+};
+
+// src/detect-release/detect-release.ts
+var ENV_KEYS = [
+  "VERCEL_GIT_COMMIT_SHA",
+  "RAILWAY_GIT_COMMIT_SHA",
+  "RENDER_GIT_COMMIT",
+  "SOURCE_VERSION",
+  "GIT_COMMIT",
+  "COMMIT_SHA",
+  "GIT_SHA"
+];
+var detectRelease = (options = {}) => {
+  const explicit = options.release?.trim();
+  if (explicit) return explicit;
+  const env = options.env ?? process.env;
+  for (const key of ENV_KEYS) {
+    const value = env[key]?.trim();
+    if (value) return value;
+  }
+  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."
+  );
+  return void 0;
+};
+
+// src/normalize-frames/normalize-frames.ts
+import { isAbsolute, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var NON_SOURCE = /* @__PURE__ */ new Set(["", "native", "<anonymous>", "unknown location"]);
+var toPosix = (path) => path.replaceAll("\\", "/");
+var stripFileUrl = (file) => {
+  if (!file.startsWith("file://")) return file;
+  try {
+    return fileURLToPath(file);
+  } catch {
+    return file.replace(/^file:\/\//, "");
+  }
+};
+var isSchemePath = (file) => NON_SOURCE.has(file) || /^(node:|bun:|https?:|webpack:|blob:|data:|eval\b)/i.test(file);
+var normalizeFile = (file, appRoot) => {
+  if (!file || isSchemePath(file)) return { file, underRoot: false };
+  const cleaned = toPosix(stripFileUrl(file)).split("?")[0]?.trim() ?? "";
+  if (!cleaned || isSchemePath(cleaned)) return { file: cleaned, underRoot: false };
+  const root = toPosix(resolve(appRoot));
+  const absolute = toPosix(
+    isAbsolute(cleaned) || /^[A-Za-z]:\//.test(cleaned) ? resolve(cleaned) : resolve(root, cleaned)
+  );
+  if (absolute === root) return { file: ".", underRoot: true };
+  const prefix = root.endsWith("/") ? root : `${root}/`;
+  if (absolute.startsWith(prefix)) {
+    return { file: absolute.slice(prefix.length), underRoot: true };
+  }
+  return { file: absolute, underRoot: false };
+};
+var isInApp = (file, underRoot) => {
+  if (!underRoot || isSchemePath(file)) return false;
+  if (/(^|\/)node_modules\//.test(file)) return false;
+  return true;
+};
+var normalizeFrames = (frames, options = {}) => {
+  const appRoot = options.appRoot ?? process.cwd();
+  return frames.map((frame) => {
+    const generated = normalizeFile(frame.generated.file, appRoot);
+    const original = frame.original ? normalizeFile(frame.original.file, appRoot) : void 0;
+    const preferred = original ?? generated;
+    return {
+      generated: {
+        file: generated.file,
+        line: frame.generated.line,
+        column: frame.generated.column
+      },
+      original: frame.original ? {
+        file: original?.file ?? frame.original.file,
+        line: frame.original.line,
+        column: frame.original.column,
+        name: frame.original.name
+      } : void 0,
+      function: frame.function,
+      in_app: isInApp(preferred.file, preferred.underRoot)
+    };
+  });
+};
+
+// src/parse-stack/parse-stack.ts
+var V8 = /^\s*at (?<fn>.*?) ?\((?<loc>(?:file|https?|blob|native|eval|webpack|rsc|node|bun|data|<anonymous>|\/|[a-z]:\\|\\\\).*?)(?::(?<line>\d+))?(?::(?<col>\d+))?\)?\s*$/i;
+var V8_EVAL = /\((?<loc>\S+)(?::(?<line>\d+))(?::(?<col>\d+))\)/;
+var NODE = /^\s*at (?:(?<fn>(?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(?<loc>.+?):(?<line>\d+)(?::(?<col>\d+))?\)?\s*$/i;
+var JSC = /^\s*(?:(?<fn>[^@]*)(?:\(.*?\))?@)?(?<loc>\S.*?):(?<line>\d+)(?::(?<col>\d+))?\s*$/i;
+var convertToNumber = (value) => {
+  if (value === void 0 || value === "") return void 0;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : void 0;
+};
+var cleanFunctionName = (fn) => {
+  if (!fn) return void 0;
+  const trimmed = fn.trim();
+  if (!trimmed || trimmed === "<anonymous>" || trimmed === "<unknown>") return void 0;
+  return trimmed.startsWith("async ") ? trimmed.slice(6) || void 0 : trimmed;
+};
+var cleanFilePath = (loc) => {
+  if (loc.startsWith("file:///")) {
+    const rest = loc.slice("file://".length);
+    return /^\/[A-Za-z]:/.test(rest) ? rest.slice(1) : rest;
+  }
+  if (loc.startsWith("file://")) return loc.slice("file://".length);
+  return loc.startsWith("native") ? "native" : loc;
+};
+var createFrame = (fn, loc, line, col) => ({
+  file: cleanFilePath(loc),
+  function: cleanFunctionName(fn),
+  line: convertToNumber(line),
+  column: convertToNumber(col)
+});
+var parseV8 = (line) => {
+  const g = V8.exec(line)?.groups;
+  if (!g?.loc) return null;
+  if (g.loc.startsWith("eval")) {
+    const inner = V8_EVAL.exec(g.loc)?.groups;
+    if (inner?.loc) return createFrame(g.fn, inner.loc, inner.line, inner.col);
+  }
+  return createFrame(g.fn, g.loc, g.line, g.col);
+};
+var parseNode = (line) => {
+  const g = NODE.exec(line)?.groups;
+  return g?.loc ? createFrame(g.fn, g.loc, g.line, g.col) : null;
+};
+var parseJsc = (line) => {
+  if (!line.includes("@")) return null;
+  const g = JSC.exec(line)?.groups;
+  return g?.loc ? createFrame(g.fn, g.loc, g.line, g.col) : null;
+};
+var parseLine = (line) => parseV8(line) ?? parseNode(line) ?? parseJsc(line);
+var parseStack = (stack) => {
+  const frames = [];
+  for (const line of stack.split(/\r?\n/)) {
+    const parsed = parseLine(line);
+    if (parsed) frames.push(parsed);
+  }
+  return frames;
+};
+
+// 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 { 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 mapCache = /* @__PURE__ */ new Map();
+var toPath = (file) => {
+  if (file.startsWith("file://")) {
+    try {
+      return fileURLToPath2(file);
+    } catch {
+      return file;
+    }
+  }
+  return file;
+};
+var isSourcePath = (file) => SOURCE_EXT2.test(file);
+var isResolvableFile = (file) => {
+  if (isSourcePath(file) || file === "<anonymous>" || file === "native") return false;
+  return !/^(node:|bun:|https?:|webpack:|blob:|data:|eval\b)/i.test(file);
+};
+var decodeDataUrl = (url) => {
+  const base64 = /^data:application\/json(?:;charset=[^;,]+)?;base64,(.+)$/i.exec(url);
+  if (base64?.[1]) {
+    try {
+      return Buffer.from(base64[1], "base64").toString("utf8");
+    } catch {
+      return null;
+    }
+  }
+  const raw = /^data:application\/json(?:;charset=[^;,]+)?,(.+)$/i.exec(url);
+  if (!raw?.[1]) return null;
+  try {
+    return decodeURIComponent(raw[1]);
+  } catch {
+    return null;
+  }
+};
+var readMapPayload = async (generatedPath) => {
+  let source;
+  try {
+    source = await readFile(generatedPath, "utf8");
+  } catch {
+    return null;
+  }
+  const match = SOURCEMAP_COMMENT.exec(source);
+  const comment = match?.[1] ?? match?.[2];
+  if (comment?.startsWith("data:")) return decodeDataUrl(comment);
+  if (comment) {
+    try {
+      return await readFile(join(dirname(generatedPath), comment), "utf8");
+    } catch {
+    }
+  }
+  try {
+    return await readFile(`${generatedPath}.map`, "utf8");
+  } catch {
+    return null;
+  }
+};
+var loadTraceMap = async (generatedPath) => {
+  const cached = mapCache.get(generatedPath);
+  if (cached !== void 0) return cached;
+  const payload = await readMapPayload(generatedPath);
+  if (!payload) {
+    mapCache.set(generatedPath, null);
+    return null;
+  }
+  try {
+    const map = new TraceMap(payload);
+    mapCache.set(generatedPath, map);
+    return map;
+  } catch {
+    mapCache.set(generatedPath, null);
+    return null;
+  }
+};
+var isMapCandidate = (raw) => raw.line !== void 0 && isResolvableFile(raw.file) && !isSourcePath(raw.file);
+var resolveFrame = async (raw) => {
+  const generated = { file: raw.file, line: raw.line, column: raw.column };
+  const base = { generated, function: raw.function };
+  if (isSourcePath(raw.file)) {
+    return { ...base, original: { ...generated } };
+  }
+  if (raw.line === void 0 || !isResolvableFile(raw.file)) return base;
+  const generatedPath = toPath(raw.file);
+  const map = await loadTraceMap(generatedPath);
+  if (!map) return base;
+  const column = raw.column ?? 0;
+  let pos = originalPositionFor(map, { line: raw.line, column });
+  if ((!pos.source || pos.line == null) && column === 0) {
+    pos = originalPositionFor(map, { line: raw.line, column: 0, bias: LEAST_UPPER_BOUND });
+  }
+  if (!pos.source || pos.line == null) return base;
+  return {
+    ...base,
+    original: {
+      file: isAbsolute2(pos.source) ? pos.source : join(dirname(generatedPath), pos.source),
+      line: pos.line,
+      column: pos.column ?? void 0,
+      name: pos.name ?? void 0
+    }
+  };
+};
+var resolveSourceMaps = async (frames) => {
+  const resolved = await Promise.all(frames.map(resolveFrame));
+  const candidateIndexes = frames.flatMap((raw, index) => isMapCandidate(raw) ? [index] : []);
+  const unresolvedGenerated = candidateIndexes.length > 0 && candidateIndexes.every((index) => resolved[index]?.original === void 0);
+  return {
+    frames: resolved,
+    resolution: resolved.some((f) => f.original) ? "exact" : "none",
+    unresolvedGenerated
+  };
+};
+
+// src/sdk-meta.ts
+var SDK_NAME = "@rasputin-ai/core";
+var SDK_VERSION = "0.1.2";
+
+// src/suppression/identity-needs-message-template.ts
+var identityNeedsMessageTemplate = (type, code) => {
+  if (code != null && code !== "") return false;
+  return type === "Error";
+};
+
+// src/suppression/parameterize-message.ts
+import { isIP } from "node:net";
+var MAX_INPUT_LENGTH = 8192;
+var RULES = [
+  {
+    token: "email",
+    pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,63}\b/giu
+  },
+  {
+    token: "url",
+    pattern: /\b(?:https?|wss?):\/\/[^\s"'<>]+/giu
+  },
+  {
+    token: "traceparent",
+    pattern: /\b00-[0-9a-f]{32}-[0-9a-f]{16}-0[01]\b/giu
+  },
+  {
+    token: "aws_trace_id",
+    pattern: /\b1-[0-9a-f]{8}-[0-9a-f]{24}\b/giu
+  },
+  {
+    token: "uuid",
+    pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/giu
+  },
+  {
+    token: "timestamp",
+    pattern: /\b\d{4}-\d{2}-\d{2}[T ][0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b/gu
+  },
+  {
+    token: "mac",
+    pattern: /\b(?:[0-9a-f]{2}[:-]){5}[0-9a-f]{2}\b/giu
+  },
+  {
+    token: "ip",
+    pattern: /\b(?:\d{1,3}\.){3}\d{1,3}\b|(?<![\w:])(?:[0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}(?![\w:])/giu,
+    validate: (candidate) => isIP(candidate) !== 0
+  },
+  {
+    token: "hash",
+    pattern: /\b[0-9a-f]{16,128}\b/giu
+  },
+  {
+    token: "hex",
+    pattern: /\b0x[0-9a-f]+\b/giu
+  },
+  {
+    token: "duration",
+    pattern: /\b\d+(?:\.\d+)?\s?(?:ns|µs|us|ms|secs?|seconds?|mins?|minutes?|hrs?|hours?|days?)\b/giu
+  },
+  {
+    token: "id",
+    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();
+  const lines = normalized.split("\n").filter((line) => line.trim());
+  let result = lines.slice(0, 2).join("\n");
+  if (result !== normalized) {
+    result += "...";
+  }
+  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) {
+    result = result.replace(rule.pattern, (match) => {
+      if (rule.validate && !rule.validate(match)) {
+        return match;
+      }
+      return `<${rule.token}>`;
+    });
+  }
+  result = result.replace(/(?<![\w.])-?\d+\.\d+(?:e[+-]?\d+)?(?![\w.])/giu, "<float>").replace(/(?<![\w.])-?\d+(?![\w.])/gu, "<int>");
+  return result;
+};
+
+// src/suppression/compute-burst-key.ts
+var preferredFile = (frame) => (frame.original ?? frame.generated).file;
+var frameBurstParts = (frames) => {
+  return frames.filter((frame) => frame.in_app).slice(0, 3).map((frame) => {
+    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}`;
+    }
+    return `${file}:${fn}`;
+  });
+};
+var computeBurstKey = (errorType, message, code, frames) => {
+  const parts = frameBurstParts(frames);
+  let key = `${errorType}\0${parts.join("\0")}`;
+  if (identityNeedsMessageTemplate(errorType, code)) {
+    key += `\0${parameterizeMessage(message)}`;
+  }
+  return key;
+};
+
+// src/suppression/create-suppression.ts
+var DEFAULTS = {
+  windowMs: 6e4,
+  capPerWindow: 5,
+  maxBurstBuckets: 1e3
+};
+var sameDim = (a, b) => (a ?? null) === (b ?? null);
+var captureIdentity = (input) => ({
+  type: input.errorType,
+  message: input.message,
+  stack_frames: framesToStackFrames(input.frames),
+  origin: input.origin,
+  ...input.code !== void 0 ? { code: input.code } : {},
+  resolution: "none"
+});
+var createSuppression = (options = {}) => {
+  const windowMs = options.windowMs ?? DEFAULTS.windowMs;
+  const capPerWindow = options.capPerWindow ?? DEFAULTS.capPerWindow;
+  const maxBurstBuckets = options.maxBurstBuckets ?? DEFAULTS.maxBurstBuckets;
+  const burstBuckets = /* @__PURE__ */ new Map();
+  const pending = [];
+  const touch = (burstKey, bucket) => {
+    burstBuckets.delete(burstKey);
+    burstBuckets.set(burstKey, bucket);
+  };
+  const evictIfNeeded = () => {
+    while (burstBuckets.size > maxBurstBuckets) {
+      const oldest = burstBuckets.keys().next().value;
+      if (oldest === void 0) break;
+      const bucket = burstBuckets.get(oldest);
+      if (bucket && bucket.suppressed > 0) {
+        pending.push(toDraft(bucket, Date.now()));
+      }
+      burstBuckets.delete(oldest);
+    }
+  };
+  const toDraft = (bucket, windowEndMs) => ({
+    count: bucket.suppressed,
+    windowStart: bucket.windowStart,
+    windowEndMs,
+    lastRelease: bucket.lastRelease,
+    lastEnvironment: bucket.lastEnvironment,
+    identity: bucket.identity,
+    captureRawFrames: bucket.captureRawFrames
+  });
+  const toSummary = (draft, identity) => ({
+    count: draft.count,
+    window_start: new Date(draft.windowStart).toISOString(),
+    window_end: new Date(draft.windowEndMs).toISOString(),
+    release: draft.lastRelease,
+    environment: draft.lastEnvironment,
+    ...identity
+  });
+  const flushSuppressed = (bucket, windowEndMs) => {
+    if (bucket.suppressed <= 0) return;
+    pending.push(toDraft(bucket, windowEndMs));
+    bucket.suppressed = 0;
+  };
+  const decide = (input) => {
+    const now = input.now ?? Date.now();
+    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 route = input.route ?? null;
+    let bucket = burstBuckets.get(burstKey);
+    if (!bucket) {
+      bucket = {
+        sentInWindow: 1,
+        suppressed: 0,
+        windowStart: now,
+        lastRelease: release,
+        lastRoute: route,
+        lastEnvironment: input.environment,
+        identity,
+        captureRawFrames
+      };
+      burstBuckets.set(burstKey, bucket);
+      evictIfNeeded();
+      return { action: "send", priority: "first" };
+    }
+    touch(burstKey, bucket);
+    const dimensionChanged = !sameDim(release, bucket.lastRelease) || !sameDim(route, bucket.lastRoute) || bucket.lastEnvironment !== input.environment;
+    const windowExpired = now - bucket.windowStart >= windowMs;
+    if (dimensionChanged || windowExpired) {
+      flushSuppressed(bucket, now);
+      bucket.sentInWindow = 1;
+      bucket.windowStart = now;
+      bucket.lastRelease = release;
+      bucket.lastRoute = route;
+      bucket.lastEnvironment = input.environment;
+      bucket.identity = identity;
+      bucket.captureRawFrames = captureRawFrames;
+      return { action: "send", priority: "first" };
+    }
+    if (bucket.sentInWindow < capPerWindow) {
+      bucket.sentInWindow += 1;
+      bucket.lastRelease = release;
+      bucket.lastRoute = route;
+      bucket.lastEnvironment = input.environment;
+      return { action: "send", priority: "repeat" };
+    }
+    bucket.suppressed += 1;
+    return { action: "suppress" };
+  };
+  const takeSummaries = async (now = Date.now(), prepareSummary) => {
+    const drafts = pending.splice(0, pending.length);
+    for (const bucket of burstBuckets.values()) {
+      if (bucket.suppressed > 0) {
+        drafts.push(toDraft(bucket, now));
+        bucket.suppressed = 0;
+      }
+    }
+    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 {
+        }
+      }
+      out.push(toSummary(draft, identity));
+    }
+    return out;
+  };
+  return {
+    decide,
+    takeSummaries,
+    /** Test helper — number of active burst buckets. */
+    size: () => burstBuckets.size
+  };
+};
+
+// src/transport/send-batch.ts
+import { gzipSync } from "node:zlib";
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var backoffMs = (attempt) => {
+  const base = Math.min(3e4, 500 * 2 ** attempt);
+  return Math.floor(base * (0.5 + Math.random()));
+};
+var retryAfterMs = (response) => {
+  const header = response.headers.get("retry-after");
+  if (!header) return null;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(header);
+  return Number.isFinite(date) ? Math.max(0, date - Date.now()) : null;
+};
+var sendBatch = async (options) => {
+  const summaries = options.summaries ?? [];
+  let payload;
+  if (summaries.length > 0) {
+    payload = { events: options.events, summaries };
+  } else {
+    payload = { events: options.events };
+  }
+  if (options.sdkVersion) payload.sdk_version = options.sdkVersion;
+  if (options.sdkName) payload.sdk_name = options.sdkName;
+  const json = JSON.stringify(payload);
+  const headers = {
+    Authorization: `Bearer ${options.projectApiKey}`,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  let body = json;
+  if (Buffer.byteLength(json, "utf8") >= options.gzipThresholdBytes) {
+    const compressed = gzipSync(json);
+    const bytes = new Uint8Array(compressed.byteLength);
+    bytes.set(compressed);
+    body = bytes;
+    headers["Content-Encoding"] = "gzip";
+  }
+  for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+    if (options.signal?.aborted) return "failed";
+    try {
+      const response = await options.fetch(options.ingestUrl, {
+        method: "POST",
+        headers,
+        body,
+        signal: options.signal
+      });
+      if (response.ok) return "ok";
+      if (response.status === 429) {
+        if (attempt === options.maxRetries) return "failed";
+        const wait = retryAfterMs(response) ?? backoffMs(attempt);
+        await sleep(wait);
+        continue;
+      }
+      if (response.status >= 400 && response.status < 500) return "dropped";
+      if (attempt === options.maxRetries) return "failed";
+      await sleep(backoffMs(attempt));
+    } catch {
+      if (options.signal?.aborted) return "failed";
+      if (attempt === options.maxRetries) return "failed";
+      await sleep(backoffMs(attempt));
+    }
+  }
+  return "failed";
+};
+
+// src/transport/transport-queue.ts
+var RANK = {
+  repeat: 0,
+  summary: 1,
+  first: 2
+};
+var createQueue = (maxSize) => {
+  const items = [];
+  const oldestLowestIndex = () => {
+    let best = 0;
+    for (let i = 1; i < items.length; i++) {
+      const current = items[i];
+      const champion = items[best];
+      if (!current || !champion) continue;
+      if (RANK[current.priority] < RANK[champion.priority]) best = i;
+    }
+    return best;
+  };
+  const enqueue = (item) => {
+    while (items.length >= maxSize) {
+      const victimIndex = oldestLowestIndex();
+      const victim = items[victimIndex];
+      if (!victim) break;
+      if (RANK[item.priority] < RANK[victim.priority]) return;
+      items.splice(victimIndex, 1);
+    }
+    items.push(item);
+  };
+  const drain = (count) => items.splice(0, count);
+  return {
+    enqueue,
+    drain,
+    size: () => items.length,
+    clear: () => {
+      items.length = 0;
+    }
+  };
+};
+
+// src/transport/create-transport.ts
+var DEFAULTS2 = {
+  enabled: true,
+  maxQueueSize: 500,
+  batchSize: 30,
+  flushIntervalMs: 5e3,
+  gzipThresholdBytes: 10 * 1024,
+  maxRetries: 5,
+  installSignalHandlers: true
+};
+var createTransport = (options) => {
+  const enabled = options.enabled ?? DEFAULTS2.enabled;
+  const batchSize = options.batchSize ?? DEFAULTS2.batchSize;
+  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);
+  let timer;
+  let flushing;
+  let closed = false;
+  const schedule = () => {
+    if (timer || !enabled || closed) return;
+    timer = setInterval(() => {
+      void flush();
+    }, flushIntervalMs);
+    timer.unref?.();
+  };
+  const stopTimer = () => {
+    if (!timer) return;
+    clearInterval(timer);
+    timer = void 0;
+  };
+  const flush = async (timeoutMs = 1e4) => {
+    if (!enabled || closed) {
+      queue.clear();
+      return;
+    }
+    if (flushing) return flushing;
+    flushing = (async () => {
+      const controller = new AbortController();
+      const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
+      try {
+        while (queue.size() > 0) {
+          if (controller.signal.aborted) break;
+          const batch = queue.drain(batchSize);
+          if (batch.length === 0) break;
+          const events = [];
+          const summaries = [];
+          for (const item of batch) {
+            if (item.kind === "summary") {
+              summaries.push(item.summary);
+              continue;
+            }
+            if (options.prepareEvent && item.rawFrames.length > 0) {
+              try {
+                events.push(
+                  await options.prepareEvent({
+                    event: item.event,
+                    rawFrames: item.rawFrames
+                  })
+                );
+              } catch {
+                events.push(item.event);
+              }
+            } else {
+              events.push(item.event);
+            }
+          }
+          const result = await sendBatch({
+            ingestUrl: options.ingestUrl,
+            projectApiKey: options.projectApiKey,
+            events,
+            summaries,
+            sdkVersion: options.sdkVersion,
+            sdkName: options.sdkName,
+            gzipThresholdBytes,
+            maxRetries,
+            fetch: fetchFn,
+            signal: controller.signal
+          });
+          if (result === "failed") {
+            for (const item of batch) queue.enqueue(item);
+            break;
+          }
+        }
+      } finally {
+        if (timeout) clearTimeout(timeout);
+        if (queue.size() === 0) stopTimer();
+        flushing = void 0;
+      }
+    })();
+    return flushing;
+  };
+  const enqueue = (event, priority = "first", rawFrames = []) => {
+    if (!enabled || closed) return;
+    queue.enqueue({ kind: "event", event, priority, rawFrames });
+    schedule();
+    if (queue.size() >= batchSize) void flush();
+  };
+  const enqueueSummary = (summary) => {
+    if (!enabled || closed) return;
+    queue.enqueue({ kind: "summary", summary, priority: "summary" });
+    schedule();
+    if (queue.size() >= batchSize) void flush();
+  };
+  const onSignal = () => {
+    try {
+      void flush(2e3);
+    } catch {
+    }
+  };
+  if (enabled && (options.installSignalHandlers ?? DEFAULTS2.installSignalHandlers)) {
+    process.on("beforeExit", onSignal);
+    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);
+    await flush(2e3);
+    queue.clear();
+  };
+  return {
+    enqueue,
+    enqueueSummary,
+    flush,
+    close,
+    size: () => queue.size()
+  };
+};
+
+// src/create-client/is-client-enabled.ts
+var isClientEnabled = (options) => options.enabled ?? true;
+var noopClient = () => ({
+  captureException: () => {
+  },
+  flush: async () => {
+  },
+  close: async () => {
+  }
+});
+
+// src/create-client/resolve-endpoint-urls.ts
+var DEFAULT_API_URL = "https://rasputin-api.fly.dev";
+var resolveEndpointUrls = (apiUrl = DEFAULT_API_URL) => {
+  const base = apiUrl.replace(/\/+$/, "");
+  return {
+    ingestUrl: `${base}/ingest`,
+    deployUrl: `${base}/deploy`
+  };
+};
+
+// src/create-client/create-client.ts
+var warnedUnresolvedMaps = false;
+var warnedPartialResolution = false;
+var warnUnresolvedMaps = (unresolved) => {
+  if (!unresolved || warnedUnresolvedMaps) return;
+  warnedUnresolvedMaps = true;
+  console.warn(
+    "[rasputin] Could not resolve source maps for one or more stack frames; fingerprinting uses generated paths"
+  );
+};
+var warnPartialResolution = () => {
+  if (warnedPartialResolution) return;
+  warnedPartialResolution = true;
+  console.warn(
+    "[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 } : {}
+}));
+var stackOf = (error) => {
+  if (error instanceof Error && error.stack) return error.stack;
+  return "";
+};
+var createClient = (options, hooks = {}) => {
+  try {
+    if (!isClientEnabled(options)) return noopClient();
+    const projectApiKey = options.projectApiKey.trim();
+    const release = detectRelease({ release: options.release });
+    const environment = options.environment;
+    const { ingestUrl, deployUrl } = resolveEndpointUrls(options.apiUrl);
+    const repoRoot = options.repoRoot;
+    const transport = createTransport({
+      ingestUrl,
+      projectApiKey,
+      enabled: true,
+      fetch: hooks.fetch,
+      installSignalHandlers: hooks.installTransportSignalHandlers,
+      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 suppression = createSuppression();
+    if (hooks.announceDeploy ?? true) {
+      void announceDeploy({
+        deployUrl,
+        projectApiKey,
+        environment,
+        release,
+        enabled: true,
+        fetch: hooks.fetch
+      });
+    }
+    const captureException = (error, context) => {
+      try {
+        const rawFrames = parseStack(stackOf(error));
+        const frames = normalizeFrames(toResolvedFrames(rawFrames), { appRoot: repoRoot });
+        const event = createIngestEvent({
+          error,
+          frames,
+          environment,
+          release,
+          origin: "server",
+          resolution: "none",
+          request: context?.request
+        });
+        const decision = suppression.decide({
+          errorType: event.type,
+          message: event.message,
+          frames,
+          rawFrames,
+          origin: event.origin,
+          code: event.code,
+          environment,
+          release,
+          route: context?.request?.route
+        });
+        if (decision.action === "send") {
+          transport.enqueue(event, decision.priority, rawFrames);
+        }
+      } catch {
+      }
+    };
+    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);
+        }
+        await transport.flush(timeoutMs);
+      } catch {
+      }
+    };
+    const close = async () => {
+      try {
+        await flush(2e3);
+        await transport.close();
+      } catch {
+      }
+    };
+    return { captureException, flush, close };
+  } catch {
+    return noopClient();
+  }
+};
+export {
+  announceDeploy,
+  createClient,
+  createIngestEvent,
+  createSuppression,
+  createTransport,
+  detectRelease,
+  isClientEnabled,
+  normalizeFrames,
+  parseStack,
+  resolveSourceMaps
+};