@rasputin-ai/core 0.2.0 → 0.4.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;
@@ -52,6 +153,7 @@ var toStackFrame = (frame) => {
   const fn = frame.function ?? frame.original?.name;
   return {
     filename,
+    ...frame.source ? { source: frame.source } : {},
     ...fn ? { function: fn } : {},
     ...preferred.line !== void 0 ? { lineno: preferred.line } : {},
     ...preferred.column !== void 0 ? { colno: preferred.column } : {},
@@ -79,18 +181,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;
 };
 
@@ -166,20 +269,98 @@ var detectRelease = (options = {}) => {
   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). 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;
 };
 
 // src/normalize-frames/normalize-frames.ts
-import { isAbsolute, resolve } from "node:path";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/source-identity/source-identity.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-var NON_SOURCE = /* @__PURE__ */ new Set(["", "native", "<anonymous>", "unknown location"]);
+var packageBoundaryByDirectory = /* @__PURE__ */ new Map();
 var toPosix = (path) => path.replaceAll("\\", "/");
+var physicalPath = (file) => {
+  if (!file.startsWith("file://")) return resolve(file);
+  try {
+    return fileURLToPath(file);
+  } catch {
+    return resolve(file.replace(/^file:\/\//, ""));
+  }
+};
+var readPackageBoundary = (directory) => {
+  const visited = [];
+  let current = resolve(directory);
+  while (true) {
+    const cached = packageBoundaryByDirectory.get(current);
+    if (cached !== void 0) {
+      for (const path of visited) packageBoundaryByDirectory.set(path, cached);
+      return cached;
+    }
+    visited.push(current);
+    const packageJson = resolve(current, "package.json");
+    if (existsSync(packageJson)) {
+      let name;
+      try {
+        const parsed = JSON.parse(readFileSync2(packageJson, "utf8"));
+        if (typeof parsed.name === "string" && parsed.name.trim()) name = parsed.name.trim();
+      } catch {
+      }
+      const boundary = { root: current, ...name ? { name } : {} };
+      for (const path of visited) packageBoundaryByDirectory.set(path, boundary);
+      return boundary;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      for (const path of visited) packageBoundaryByDirectory.set(path, null);
+      return null;
+    }
+    current = parent;
+  }
+};
+var sourceLocatorFromFile = (file) => {
+  if (!file || /^(node:|bun:|https?:|webpack:|blob:|data:|native$)/i.test(file)) return void 0;
+  const absolute = physicalPath(file.split("?")[0] ?? file);
+  const boundary = readPackageBoundary(dirname(absolute));
+  if (!boundary) return void 0;
+  const fromPackage = relative(boundary.root, absolute);
+  if (!fromPackage || fromPackage === ".." || fromPackage.startsWith(`..${sep}`) || isAbsolute(fromPackage)) {
+    return { packageRelativePath: basename(absolute) };
+  }
+  return {
+    ...boundary.name ? { packageName: boundary.name } : {},
+    packageRelativePath: toPosix(fromPackage)
+  };
+};
+var sourceLocatorKey = (source) => `${source.packageName ?? ""}\0${source.packageRelativePath}`;
+var runtimeFunctionId = (definition) => {
+  const source = definition.source;
+  const identity = [
+    definition.name,
+    source?.packageName ?? "",
+    source?.packageRelativePath ?? "",
+    String(source?.line ?? ""),
+    String(source?.column ?? "")
+  ].join("\0");
+  return `rf_${createHash("sha256").update(identity).digest("base64url").slice(0, 24)}`;
+};
+var sourceDisplayPath = (source) => source.repositoryPath ?? source.packageRelativePath;
+var resetSourceIdentityCache = () => {
+  packageBoundaryByDirectory.clear();
+};
+
+// src/normalize-frames/normalize-frames.ts
+var NON_SOURCE = /* @__PURE__ */ new Set(["", "native", "<anonymous>", "unknown location"]);
+var toPosix2 = (path) => path.replaceAll("\\", "/");
 var stripFileUrl = (file) => {
   if (!file.startsWith("file://")) return file;
   try {
-    return fileURLToPath(file);
+    return fileURLToPath2(file);
   } catch {
     return file.replace(/^file:\/\//, "");
   }
@@ -187,44 +368,55 @@ var stripFileUrl = (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() ?? "";
+  const cleaned = toPosix2(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)
+  const root = appRoot ? toPosix2(resolve2(appRoot)) : void 0;
+  const absolute = toPosix2(
+    isAbsolute2(cleaned) || /^[A-Za-z]:\//.test(cleaned) ? resolve2(cleaned) : resolve2(root ?? process.cwd(), cleaned)
   );
-  if (absolute === root) return { file: ".", underRoot: true };
+  if (!root) return { file: cleaned, absolute, underRoot: false };
+  if (absolute === root) return { file: ".", absolute, underRoot: true };
   const prefix = root.endsWith("/") ? root : `${root}/`;
   if (absolute.startsWith(prefix)) {
-    return { file: absolute.slice(prefix.length), underRoot: true };
+    return { file: absolute.slice(prefix.length), absolute, underRoot: true };
   }
-  return { file: absolute, underRoot: false };
+  return { file: absolute, absolute, underRoot: false };
 };
-var isInApp = (file, underRoot) => {
-  if (!underRoot || isSchemePath(file)) return false;
-  if (/(^|\/)node_modules\//.test(file)) return false;
-  return true;
+var isInApp = (file, absolute, underRoot, source) => {
+  if (isSchemePath(file)) return false;
+  if (/(^|\/)node_modules\//.test(absolute ?? file)) return false;
+  if (/^@rasputin-ai\/(?:core|node|elysia)$/.test(source?.packageName ?? "")) return false;
+  return underRoot || source !== void 0;
 };
 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;
+    const generatedSource = generated.absolute ? sourceLocatorFromFile(generated.absolute) : void 0;
+    const originalSource = original?.absolute ? sourceLocatorFromFile(original.absolute) : void 0;
     const preferred = original ?? generated;
+    const locator = originalSource ?? generatedSource;
+    const source = locator ? {
+      ...locator,
+      ...(frame.original?.line ?? frame.generated.line) !== void 0 ? { line: frame.original?.line ?? frame.generated.line } : {},
+      ...(frame.original?.column ?? frame.generated.column) !== void 0 ? { column: frame.original?.column ?? frame.generated.column } : {}
+    } : void 0;
     return {
       generated: {
-        file: generated.file,
+        file: generatedSource && !generated.underRoot ? sourceDisplayPath(generatedSource) : generated.file,
         line: frame.generated.line,
         column: frame.generated.column
       },
       original: frame.original ? {
-        file: original?.file ?? frame.original.file,
+        file: originalSource && !original?.underRoot ? sourceDisplayPath(originalSource) : 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)
+      in_app: isInApp(preferred.file, preferred.absolute, preferred.underRoot, source),
+      ...source ? { source } : {}
     };
   });
 };
@@ -288,22 +480,22 @@ var parseStack = (stack) => {
 };
 
 // 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"));
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname2, join as join2, 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 repoRootFrom = (moduleUrl) => {
-  let current = resolve2(dirname(fileURLToPath2(moduleUrl)));
+  let current = resolve3(dirname2(fileURLToPath3(moduleUrl)));
   let packageRoot;
   while (true) {
     if (isGitRoot(current)) return current;
     if (hasPackageJson(current)) packageRoot = current;
-    const parent = dirname(current);
+    const parent = dirname2(current);
     if (parent === current) break;
     current = parent;
   }
-  return packageRoot ?? resolve2(dirname(fileURLToPath2(moduleUrl)));
+  return packageRoot ?? resolve3(dirname2(fileURLToPath3(moduleUrl)));
 };
 
 // src/repo-root/resolve-repo-root.ts
@@ -317,34 +509,12 @@ var resolveRepoRoot = (options) => {
 
 // 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;
@@ -372,8 +542,8 @@ Or set repoRoot yourself.
 
 // src/resolve-source-maps/resolve-source-maps.ts
 import { readFile } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join3 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join3 } 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*$/;
@@ -381,7 +551,7 @@ var mapCache = /* @__PURE__ */ new Map();
 var toPath = (file) => {
   if (file.startsWith("file://")) {
     try {
-      return fileURLToPath3(file);
+      return fileURLToPath4(file);
     } catch {
       return file;
     }
@@ -422,7 +592,7 @@ var readMapPayload = async (generatedPath) => {
   if (comment?.startsWith("data:")) return decodeDataUrl(comment);
   if (comment) {
     try {
-      return await readFile(join3(dirname2(generatedPath), comment), "utf8");
+      return await readFile(join3(dirname3(generatedPath), comment), "utf8");
     } catch {
     }
   }
@@ -469,7 +639,7 @@ var resolveFrame = async (raw) => {
   return {
     ...base,
     original: {
-      file: isAbsolute2(pos.source) ? pos.source : join3(dirname2(generatedPath), pos.source),
+      file: isAbsolute3(pos.source) ? pos.source : join3(dirname3(generatedPath), pos.source),
       line: pos.line,
       column: pos.column ?? void 0,
       name: pos.name ?? void 0
@@ -489,7 +659,7 @@ var resolveSourceMaps = async (frames) => {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/core";
-var SDK_VERSION = "0.2.0";
+var SDK_VERSION = "0.4.0";
 
 // src/suppression/identity-needs-message-template.ts
 var identityNeedsMessageTemplate = (type, code) => {
@@ -687,7 +857,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) {
@@ -771,17 +941,17 @@ var createSuppression = (options = {}) => {
 
 // src/transport/send-batch.ts
 import { gzipSync } from "node:zlib";
-var sleep = (ms, signal) => new Promise((resolve3) => {
+var sleep = (ms, signal) => new Promise((resolve4) => {
   if (signal?.aborted) {
-    resolve3();
+    resolve4();
     return;
   }
-  const timer = setTimeout(resolve3, ms);
+  const timer = setTimeout(resolve4, ms);
   signal?.addEventListener(
     "abort",
     () => {
       clearTimeout(timer);
-      resolve3();
+      resolve4();
     },
     { once: true }
   );
@@ -859,6 +1029,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++) {
@@ -874,16 +1047,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;
     }
@@ -1058,7 +1243,14 @@ var createTransport = (options) => {
     enqueueSummary,
     flush,
     close,
-    size: () => queue.size() + (retryBatch?.items.length ?? 0)
+    size: () => queue.size() + (retryBatch?.items.length ?? 0),
+    getStats: () => {
+      const queueStats = queue.getStats();
+      return {
+        ...queueStats,
+        queued: queueStats.queued + (retryBatch?.items.length ?? 0)
+      };
+    }
   };
 };
 
@@ -1070,16 +1262,26 @@ 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
-var DEFAULT_API_URL = "https://rasputin-api.fly.dev";
+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`
+    deployUrl: `${base}/deploy`,
+    instrumentationManifestUrl: `${base}/instrumentationManifest`
   };
 };
 
@@ -1115,12 +1317,19 @@ var createClient = (options, hooks = {}) => {
     const release = detectRelease({ release: options.release });
     const environment = options.environment;
     const { ingestUrl, deployUrl } = resolveEndpointUrls(options.apiUrl);
-    const repoRoot = resolveRepoRoot(options);
-    if (!repoRoot) {
-      warnIfMissingRepoRoot();
+    if (!release) {
+      if (hooks.announceDeploy ?? true) {
+        void announceDeploy({
+          deployUrl,
+          projectApiKey,
+          environment,
+          fetch: hooks.fetch
+        });
+      }
       return noopClient();
     }
-    warnIfSuspiciousRepoRoot(repoRoot);
+    const repoRoot = resolveRepoRoot(options);
+    if (repoRoot) 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");
@@ -1183,7 +1392,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,
@@ -1221,12 +1431,45 @@ var createClient = (options, hooks = {}) => {
       } 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 = 2;
+
+// src/instrumentation-manifest/upload-instrumentation-manifest.ts
+var uploadInstrumentationManifest = async (options) => {
+  const release = options.release.trim();
+  if (!release) return { ok: false };
+  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: false };
+    const body = await response.json();
+    const verification = body.payload?.verification;
+    return verification ? { ok: true, verification } : { ok: false };
+  } catch {
+    return { ok: false };
+  }
+};
 export {
+  INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
   announceDeploy,
   createClient,
   createIngestEvent,
@@ -1237,5 +1480,13 @@ export {
   normalizeFrames,
   parseStack,
   repoRootFrom,
-  resolveSourceMaps
+  resetSourceIdentityCache,
+  resolveEndpointUrls,
+  resolveRepoRoot,
+  resolveSourceMaps,
+  runtimeFunctionId,
+  sourceDisplayPath,
+  sourceLocatorFromFile,
+  sourceLocatorKey,
+  uploadInstrumentationManifest
 };