@newtalaria/browser 0.1.17 → 0.1.19

package/dist/index.js

@@ -270,9 +270,262 @@ async function collectBrowserContext() {
   return base;
 }
 
+// src/utils/tags.ts
+var MAX_TAGS_PER_EVENT = 20;
+var MAX_TAG_KEY_LENGTH = 64;
+var MAX_TAG_VALUE_LENGTH = 128;
+var MAX_TAG_TOTAL_UTF8_BYTES = 2048;
+var KEY_PATTERN = /^[a-z0-9_.-]+$/;
+var HIGH_CARDINALITY_TAG_KEYS = /* @__PURE__ */ new Set([
+  "user_id",
+  "userid",
+  "request_id",
+  "requestid",
+  "business_id",
+  "order_id",
+  "email",
+  "url",
+  "uuid",
+  "session_id",
+  "trace_id",
+  "span_id"
+]);
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+var LONG_NUMERIC_RE = /^\d{8,}$/;
+function utf8Bytes(s) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(s).length;
+  }
+  return unescape(encodeURIComponent(s)).length;
+}
+function normalizeKey(raw) {
+  const key = raw.trim().toLowerCase();
+  if (!key || key.length > MAX_TAG_KEY_LENGTH) return null;
+  if (!KEY_PATTERN.test(key)) return null;
+  return key;
+}
+function normalizeValue(raw) {
+  if (raw == null) return null;
+  const value = String(raw).trim();
+  if (!value) return null;
+  return value.length <= MAX_TAG_VALUE_LENGTH ? value : value.slice(0, MAX_TAG_VALUE_LENGTH);
+}
+function normalizeTags(tags) {
+  if (!tags) return {};
+  const result2 = {};
+  let totalBytes = 0;
+  for (const [rawKey, rawValue] of Object.entries(tags)) {
+    if (Object.keys(result2).length >= MAX_TAGS_PER_EVENT) break;
+    const key = normalizeKey(rawKey);
+    if (!key) continue;
+    const value = normalizeValue(rawValue);
+    if (value == null) continue;
+    if (result2[key] != null) {
+      totalBytes -= utf8Bytes(key) + utf8Bytes(result2[key]);
+    }
+    const entryBytes = utf8Bytes(key) + utf8Bytes(value);
+    if (totalBytes + entryBytes > MAX_TAG_TOTAL_UTF8_BYTES) continue;
+    result2[key] = value;
+    totalBytes += entryBytes;
+  }
+  return result2;
+}
+function mergeTags(...parts) {
+  const merged = {};
+  for (const part of parts) {
+    if (!part) continue;
+    Object.assign(merged, part);
+  }
+  return normalizeTags(merged);
+}
+function looksHighCardinalityValue(value) {
+  return UUID_RE.test(value) || EMAIL_RE.test(value) || LONG_NUMERIC_RE.test(value);
+}
+function warnSuspiciousTags(tags, environment) {
+  if (!environment || environment === "production") return;
+  if (typeof console === "undefined" || typeof console.warn !== "function") {
+    return;
+  }
+  for (const [key, value] of Object.entries(tags)) {
+    if (HIGH_CARDINALITY_TAG_KEYS.has(key)) {
+      console.warn(
+        `@newtalaria/browser: Tag "${key}" appears to have high cardinality. Consider moving it to context/extra.`
+      );
+      continue;
+    }
+    if (looksHighCardinalityValue(value)) {
+      console.warn(
+        `@newtalaria/browser: Tag "${key}" value looks high-cardinality. Consider moving it to context/extra.`
+      );
+    }
+  }
+}
+var RESERVED_TAG_KEYS = [
+  "service",
+  "platform",
+  "feature",
+  "operation",
+  "component",
+  "runtime",
+  "runtime_version"
+];
+
+// src/utils/stacktrace.ts
+var V8_FRAME = /^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?\s*$/;
+var V8_FRAME_BARE = /^\s*at\s+(.+)\s*$/;
+var EXTENSION_URL2 = /(?:chrome|moz|safari|safari-web|ms-browser)-extension:\/\//i;
+function parseStackTrace(stack, inAppOptions) {
+  if (!stack || !stack.trim()) return void 0;
+  const parsed = [];
+  for (const line of stack.split("\n")) {
+    const frame = parseStackLine(line, inAppOptions);
+    if (frame) parsed.push(frame);
+  }
+  if (parsed.length === 0) return void 0;
+  parsed.reverse();
+  return { frames: parsed };
+}
+function parseStackLine(line, inAppOptions) {
+  if (!/^\s*at\s+/.test(line)) return null;
+  const v8 = V8_FRAME.exec(line);
+  if (v8) {
+    const functionName = cleanFunction(v8[1]);
+    const absPath = stripQuery(v8[2] ?? "");
+    const lineno = Number.parseInt(v8[3] ?? "", 10);
+    const colno = Number.parseInt(v8[4] ?? "", 10);
+    return {
+      functionName,
+      absPath: absPath || void 0,
+      filename: basename(absPath),
+      lineno: Number.isFinite(lineno) ? lineno : void 0,
+      colno: Number.isFinite(colno) ? colno : void 0,
+      inApp: isInAppFrame(absPath, inAppOptions),
+      platform: "javascript"
+    };
+  }
+  const bare = V8_FRAME_BARE.exec(line);
+  if (bare) {
+    const functionName = cleanFunction(bare[1]);
+    if (!functionName) return null;
+    return {
+      functionName,
+      inApp: false,
+      platform: "javascript"
+    };
+  }
+  return null;
+}
+function applySourceLocation(stacktrace, source, inAppOptions) {
+  if (!source) return stacktrace;
+  const filename = source.filename?.trim() || void 0;
+  const lineno = typeof source.lineno === "number" && source.lineno > 0 ? source.lineno : void 0;
+  const colno = typeof source.colno === "number" && source.colno >= 0 ? source.colno : void 0;
+  if (!filename && lineno == null && colno == null) return stacktrace;
+  if (!stacktrace || stacktrace.frames.length === 0) {
+    if (!filename && lineno == null) return stacktrace;
+    const absPath = filename;
+    return {
+      frames: [
+        {
+          filename: absPath ? basename(absPath) : void 0,
+          absPath,
+          lineno,
+          colno,
+          inApp: absPath ? isInAppFrame(absPath, inAppOptions) : true,
+          platform: "javascript"
+        }
+      ]
+    };
+  }
+  const frames = stacktrace.frames.slice();
+  const top = { ...frames[frames.length - 1] };
+  if (filename) {
+    top.absPath = filename;
+    top.filename = basename(filename);
+    top.inApp = isInAppFrame(filename, inAppOptions);
+  }
+  if (lineno != null) top.lineno = lineno;
+  if (colno != null) top.colno = colno;
+  frames[frames.length - 1] = top;
+  return { ...stacktrace, frames };
+}
+function isInAppFrame(path, options) {
+  const lower = path.toLowerCase();
+  if (!lower) return true;
+  if (lower.includes("node_modules")) return false;
+  if (EXTENSION_URL2.test(path) || lower.includes("webkit-masked-url://")) {
+    return false;
+  }
+  if (lower.includes("@newtalaria/browser")) return false;
+  if (matchesUrlList(path, options?.denyUrls)) return false;
+  if (matchesUrlList(path, options?.allowUrls)) return true;
+  const frameOrigin = tryParseOrigin(path);
+  if (frameOrigin != null) {
+    const pageOrigin = normalizeOrigin(options?.pageOrigin);
+    if (pageOrigin && frameOrigin === pageOrigin) return true;
+    const extra = options?.inAppOrigins ?? [];
+    for (const origin of extra) {
+      if (normalizeOrigin(origin) === frameOrigin) return true;
+    }
+    return false;
+  }
+  return true;
+}
+function matchesUrlList(path, patterns) {
+  if (!patterns || patterns.length === 0) return false;
+  for (const pattern of patterns) {
+    if (typeof pattern === "string") {
+      if (pattern && path.includes(pattern)) return true;
+    } else if (pattern.test(path)) {
+      return true;
+    }
+  }
+  return false;
+}
+function tryParseOrigin(path) {
+  if (!/^https?:\/\//i.test(path)) return null;
+  try {
+    return new URL(path).origin;
+  } catch {
+    return null;
+  }
+}
+function normalizeOrigin(origin) {
+  if (!origin || !origin.trim()) return null;
+  const trimmed = origin.trim();
+  try {
+    if (/^https?:\/\//i.test(trimmed)) {
+      return new URL(trimmed).origin;
+    }
+    return trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+function resolvePageOrigin(originOrUrl) {
+  return normalizeOrigin(originOrUrl) ?? void 0;
+}
+function cleanFunction(raw) {
+  if (raw == null) return void 0;
+  const value = raw.trim();
+  return value.length === 0 ? void 0 : value;
+}
+function stripQuery(path) {
+  const q = path.indexOf("?");
+  return q >= 0 ? path.slice(0, q) : path;
+}
+function basename(path) {
+  if (!path) return void 0;
+  const normalized = stripQuery(path);
+  const parts = normalized.split(/[/\\]/);
+  const last = parts[parts.length - 1];
+  return last || normalized;
+}
+
 // src/sdk_meta.ts
 var SDK_NAME = "@newtalaria/browser";
-var SDK_VERSION = "0.1.17";
+var SDK_VERSION = "0.1.18";
 
 // src/transport/serverpod.ts
 var ServerpodTransport = class {
@@ -330,6 +583,9 @@ async function ingestEvent(transport, params) {
   if (params.eventType) input2.eventType = params.eventType;
   if (params.title) input2.title = params.title;
   if (params.stackTrace) input2.stackTrace = params.stackTrace;
+  if (params.exception) input2.exception = serializeException(params.exception);
+  if (params.debugMeta) input2.debugMeta = serializeDebugMeta(params.debugMeta);
+  if (params.platform) input2.platform = params.platform;
   if (params.release) input2.release = params.release;
   if (params.userId) input2.userId = params.userId;
   if (params.sessionId) input2.sessionId = params.sessionId;
@@ -346,6 +602,89 @@ async function ingestEvent(transport, params) {
     { keepalive: params.keepalive }
   );
 }
+function serializeException(data) {
+  return {
+    __className__: "ExceptionDataDto",
+    values: data.values.map(serializeExceptionValue)
+  };
+}
+function serializeExceptionValue(value) {
+  const out = {
+    __className__: "ExceptionValueDto"
+  };
+  if (value.type != null) out.type = value.type;
+  if (value.value != null) out.value = value.value;
+  if (value.module != null) out.module = value.module;
+  if (value.threadId != null) out.threadId = value.threadId;
+  if (value.code != null) out.code = value.code;
+  if (value.mechanism) out.mechanism = serializeMechanism(value.mechanism);
+  if (value.stacktrace) out.stacktrace = serializeStackTrace(value.stacktrace);
+  return out;
+}
+function serializeMechanism(mechanism) {
+  const out = {
+    __className__: "ExceptionMechanismDto",
+    type: mechanism.type
+  };
+  if (mechanism.handled != null) out.handled = mechanism.handled;
+  if (mechanism.synthetic != null) out.synthetic = mechanism.synthetic;
+  return out;
+}
+function serializeStackTrace(stack) {
+  const out = {
+    __className__: "StackTraceDto",
+    frames: stack.frames.map(serializeStackFrame)
+  };
+  if (stack.registers) out.registers = stack.registers;
+  return out;
+}
+function serializeStackFrame(frame) {
+  const out = {
+    __className__: "StackFrameDto"
+  };
+  if (frame.filename != null) out.filename = frame.filename;
+  if (frame.absPath != null) out.absPath = frame.absPath;
+  if (frame.functionName != null) out.functionName = frame.functionName;
+  if (frame.rawFunction != null) out.rawFunction = frame.rawFunction;
+  if (frame.module != null) out.module = frame.module;
+  if (frame.package != null) out.package = frame.package;
+  if (frame.platform != null) out.platform = frame.platform;
+  if (frame.lineno != null) out.lineno = frame.lineno;
+  if (frame.colno != null) out.colno = frame.colno;
+  if (frame.inApp != null) out.inApp = frame.inApp;
+  if (frame.instructionAddr != null) out.instructionAddr = frame.instructionAddr;
+  if (frame.symbolAddr != null) out.symbolAddr = frame.symbolAddr;
+  if (frame.imageAddr != null) out.imageAddr = frame.imageAddr;
+  if (frame.addrMode != null) out.addrMode = frame.addrMode;
+  if (frame.contextLine != null) out.contextLine = frame.contextLine;
+  if (frame.preContext != null) out.preContext = frame.preContext;
+  if (frame.postContext != null) out.postContext = frame.postContext;
+  if (frame.vars != null) out.vars = frame.vars;
+  if (frame.stackStart != null) out.stackStart = frame.stackStart;
+  return out;
+}
+function serializeDebugMeta(meta) {
+  const out = {
+    __className__: "DebugMetaDto"
+  };
+  if (meta.images) {
+    out.images = meta.images.map((image) => {
+      const img = {
+        __className__: "DebugImageDto"
+      };
+      if (image.type != null) img.type = image.type;
+      if (image.imageAddr != null) img.imageAddr = image.imageAddr;
+      if (image.imageSize != null) img.imageSize = image.imageSize;
+      if (image.debugId != null) img.debugId = image.debugId;
+      if (image.debugFile != null) img.debugFile = image.debugFile;
+      if (image.codeId != null) img.codeId = image.codeId;
+      if (image.codeFile != null) img.codeFile = image.codeFile;
+      if (image.arch != null) img.arch = image.arch;
+      return img;
+    });
+  }
+  return out;
+}
 
 // src/utils/gzip.ts
 async function gzipBytes(data) {
@@ -13482,18 +13821,22 @@ var { freezePage } = record;
 var { takeFullSnapshot } = record;
 
 // src/replay/privacy.ts
-var SENSITIVE_QUERY = /(?:^|[?&])(token|secret|password|auth|api[_-]?key|access[_-]?token)=([^&#]*)/gi;
+var SENSITIVE_QUERY_KEY = /^(?:token|secret|password|auth|api[_-]?key|access[_-]?token|gclid|fbclid|gcl_au|msclkid|_ga(?:_.*)?|cid|sid)$/i;
+var SENSITIVE_QUERY_LEGACY = /(?:^|[?&])(token|secret|password|auth|api[_-]?key|access[_-]?token|gclid|fbclid|gcl_au|msclkid|_ga(?:_[^=&#]*)?|cid|sid)=([^&#]*)/gi;
+function isSensitiveQueryKey(key) {
+  return SENSITIVE_QUERY_KEY.test(key);
+}
 function redactUrl(raw) {
   try {
     const url = new URL(raw, typeof location !== "undefined" ? location.href : void 0);
     for (const key of [...url.searchParams.keys()]) {
-      if (/token|secret|password|auth|api[_-]?key|access[_-]?token/i.test(key)) {
+      if (isSensitiveQueryKey(key)) {
         url.searchParams.set(key, "[Filtered]");
       }
     }
     return url.toString();
   } catch {
-    return raw.replace(SENSITIVE_QUERY, (_m, name) => `${name}=[Filtered]`);
+    return raw.replace(SENSITIVE_QUERY_LEGACY, (_m, name) => `${name}=[Filtered]`);
   }
 }
 function sanitizeNetworkUrl(raw, opts) {
@@ -13590,6 +13933,9 @@ function startRecorder(options) {
 function isAbortError(error) {
   return error instanceof Error && error.name === "AbortError";
 }
+function isTimeoutError(error) {
+  return error instanceof Error && error.name === "TimeoutError";
+}
 function isLikelyNetworkFetchError(error) {
   if (!(error instanceof Error)) return false;
   if (error.name === "AbortError" || error.name === "TimeoutError") return false;
@@ -13597,6 +13943,9 @@ function isLikelyNetworkFetchError(error) {
   const msg = error.message.toLowerCase().trim();
   return msg === "failed to fetch" || msg === "load failed" || msg === "networkerror when attempting to fetch resource." || msg.startsWith("networkerror") || msg.includes("failed to fetch");
 }
+function isCorrelatableTransportError(error) {
+  return isLikelyNetworkFetchError(error) || isTimeoutError(error);
+}
 function describeUnknownError(error) {
   if (error instanceof Error) {
     return {
@@ -13744,6 +14093,56 @@ function urlMatchesIgnoreList(url, ignoreUrls) {
   }
   return false;
 }
+function normalizeNetworkOrigin(raw) {
+  const trimmed = (raw || "").trim();
+  if (!trimmed || trimmed === "*") return trimmed;
+  try {
+    return new URL(trimmed).origin;
+  } catch {
+    try {
+      return new URL(`https://${trimmed}`).origin;
+    } catch {
+      return trimmed.replace(/\/+$/, "");
+    }
+  }
+}
+function resolvePageOrigin2(pageOrigin) {
+  if (pageOrigin) {
+    try {
+      return new URL(pageOrigin).origin;
+    } catch {
+      return pageOrigin.replace(/\/+$/, "");
+    }
+  }
+  if (typeof location !== "undefined" && location.origin) {
+    return location.origin;
+  }
+  return "";
+}
+function resolveRequestOrigin(rawUrl, pageOrigin) {
+  const base = pageOrigin || (typeof location !== "undefined" ? location.href : void 0);
+  try {
+    return new URL(rawUrl, base).origin;
+  } catch {
+    return "";
+  }
+}
+function isAllowedNetworkOrigin(requestOrigin, opts) {
+  if (!requestOrigin) return false;
+  const allow = opts.networkErrorOrigins.map(normalizeNetworkOrigin);
+  if (allow.includes("*")) return true;
+  const page = resolvePageOrigin2(opts.pageOrigin);
+  if (page && requestOrigin === page) return true;
+  return allow.includes(requestOrigin);
+}
+function classifyNetworkParty(requestOrigin, pageOrigin) {
+  const page = resolvePageOrigin2(pageOrigin);
+  if (page && requestOrigin && requestOrigin === page) return "first_party";
+  return "third_party";
+}
+function isHttpOkStatus(status) {
+  return status >= 200 && status < 300;
+}
 function shouldPromoteFailedRequest(meta, opts) {
   if (!opts.captureFailedRequests) return false;
   if (typeof meta.status !== "number" || Number.isNaN(meta.status)) return false;
@@ -13754,6 +14153,13 @@ function shouldPromoteFailedRequest(meta, opts) {
     opts.talariaBaseUrl
   );
   if (urlMatchesIgnoreList(meta.url || "", ignore)) return false;
+  const requestOrigin = meta.origin || resolveRequestOrigin(meta.url || "", opts.pageOrigin);
+  if (!isAllowedNetworkOrigin(requestOrigin, {
+    networkErrorOrigins: opts.networkErrorOrigins ?? [],
+    pageOrigin: opts.pageOrigin
+  })) {
+    return false;
+  }
   return true;
 }
 function shouldPromoteNetworkError(meta, opts) {
@@ -13767,6 +14173,13 @@ function shouldPromoteNetworkError(meta, opts) {
     opts.talariaBaseUrl
   );
   if (urlMatchesIgnoreList(meta.url || "", ignore)) return false;
+  const requestOrigin = meta.origin || resolveRequestOrigin(meta.url || "", opts.pageOrigin);
+  if (!isAllowedNetworkOrigin(requestOrigin, {
+    networkErrorOrigins: opts.networkErrorOrigins ?? [],
+    pageOrigin: opts.pageOrigin
+  })) {
+    return false;
+  }
   return true;
 }
 function enrichNetworkMeta(meta) {
@@ -13777,7 +14190,8 @@ function enrichNetworkMeta(meta) {
       failureKind: meta.ok === false ? "http" : meta.failureKind
     };
   }
-  if (meta.ok === false || meta.errorName || meta.errorMessage || meta.aborted) {
+  const hasTransportSignal = !!meta.errorName || !!meta.errorMessage || !!meta.aborted || meta.failureKind === "abort" || meta.failureKind === "timeout" || meta.failureKind === "network";
+  if (hasTransportSignal) {
     const failureKind = meta.failureKind === "abort" || meta.failureKind === "timeout" || meta.failureKind === "network" ? meta.failureKind : classifyTransportFailure({
       aborted: meta.aborted,
       errorName: meta.errorName
@@ -13790,10 +14204,13 @@ function enrichNetworkMeta(meta) {
   }
   return meta;
 }
-function networkUrlParts(rawUrl, includeQuery) {
-  const parts = sanitizeNetworkUrl(rawUrl, { includeQuery });
+function networkUrlParts(rawUrl, includeQuery, pageOrigin) {
+  const baseHref = pageOrigin || (typeof location !== "undefined" ? location.href : void 0);
+  const parts = sanitizeNetworkUrl(rawUrl, { includeQuery, baseHref });
+  const origin = resolveRequestOrigin(rawUrl, pageOrigin);
   return {
     url: parts.url,
+    origin: origin || void 0,
     hostname: parts.hostname,
     pathname: parts.pathname,
     ...parts.search ? { search: parts.search } : {}
@@ -13809,14 +14226,22 @@ function installNetworkHook(options = {}) {
     captureNetworkErrors: options.captureNetworkErrors ?? true,
     failedRequestStatusCodes: options.failedRequestStatusCodes ?? [[500, 599]],
     failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? [],
+    networkErrorOrigins: options.networkErrorOrigins ?? [],
+    pageOrigin: options.pageOrigin,
     talariaBaseUrl: options.talariaBaseUrl
   };
   const includeQuery = options.captureRequestQueryParameters ?? options.includeNetworkUrlQuery ?? false;
   const handleMeta = (meta) => {
     const { rawUrl, ...rest } = meta;
+    const parts = networkUrlParts(rawUrl, includeQuery, matchOpts.pageOrigin);
+    const party = classifyNetworkParty(
+      parts.origin || "",
+      matchOpts.pageOrigin
+    );
     const enriched = enrichNetworkMeta({
       ...rest,
-      ...networkUrlParts(rawUrl, includeQuery)
+      ...parts,
+      party
     });
     try {
       emitNetwork(enriched);
@@ -13836,6 +14261,7 @@ function installNetworkHook(options = {}) {
       const rawUrl = typeof input2 === "string" ? input2 : input2 instanceof URL ? input2.toString() : input2.url;
       try {
         const response = await originalFetch(input2, init);
+        const opaque = response.type === "opaque" || response.type === "opaqueredirect";
         handleMeta({
           method,
           rawUrl,
@@ -13843,7 +14269,8 @@ function installNetworkHook(options = {}) {
           transport: "fetch",
           status: response.status,
           durationMs: Date.now() - started,
-          ok: response.ok
+          // Opaque responses resolve successfully with status 0 — not a failure.
+          ok: opaque ? true : response.ok
         });
         return response;
       } catch (error) {
@@ -13905,7 +14332,7 @@ function installNetworkHook(options = {}) {
           transport: "xhr",
           status,
           durationMs: Date.now() - (this.__talariaStarted ?? Date.now()),
-          ok: status >= 200 && status < 400,
+          ok: isHttpOkStatus(status),
           ...transportFail ? {
             failureKind,
             errorName,
@@ -13914,7 +14341,7 @@ function installNetworkHook(options = {}) {
           } : {}
         });
       };
-      this.addEventListener("loadend", onDone);
+      this.addEventListener("loadend", onDone, { once: true });
       return originalSend.call(this, body);
     };
   }
@@ -13926,10 +14353,26 @@ function installNetworkHook(options = {}) {
 }
 
 // src/client.ts
+var PLATFORM_JAVASCRIPT = "javascript";
+var EXTRA_LOCATION_KEYS = /* @__PURE__ */ new Set([
+  "exception_class",
+  "file",
+  "line",
+  "code",
+  "filename",
+  "lineno",
+  "colno"
+]);
+function networkExceptionClass(failure) {
+  if (failure.failureKind === "http") return "HttpError";
+  if (failure.failureKind === "timeout") return "TimeoutError";
+  return "NetworkError";
+}
 function networkFailureTags(failure) {
   return {
     "http.method": failure.method || "GET",
     "network.failure_kind": failure.failureKind ?? "network",
+    ...failure.party ? { "network.party": failure.party } : {},
     ...failure.transport ? { "network.transport": failure.transport } : {},
     ...failure.errorName ? { "network.error_name": failure.errorName } : {}
   };
@@ -13939,6 +14382,7 @@ function networkFailureExtra(failure) {
     method: failure.method || "GET",
     url: failure.url || "(unknown url)"
   };
+  if (failure.origin) http.origin = failure.origin;
   if (failure.hostname) http.hostname = failure.hostname;
   if (failure.pathname) http.pathname = failure.pathname;
   if (failure.search) http.search = failure.search;
@@ -13951,14 +14395,69 @@ function networkFailureExtra(failure) {
   };
   if (failure.errorName) fail.name = failure.errorName;
   if (failure.errorMessage) fail.message = failure.errorMessage;
+  const statusCode = typeof failure.status === "number" && failure.status > 0 ? failure.status : null;
   return {
     http,
     failure: fail,
+    network: {
+      party: failure.party ?? "third_party",
+      durationMs: failure.durationMs,
+      aborted: failure.aborted ?? false,
+      ok: failure.ok ?? false
+    },
+    // Top-level for server fingerprint compatibility (status only —
+    // exception type lives on first-class `exception.values[0].type`).
+    status_code: statusCode,
     durationMs: failure.durationMs,
     aborted: failure.aborted ?? false,
     ok: failure.ok ?? false
   };
 }
+function networkExceptionData(failure, message) {
+  return {
+    values: [
+      {
+        type: networkExceptionClass(failure),
+        value: message,
+        mechanism: {
+          type: "http",
+          handled: true,
+          synthetic: true
+        }
+      }
+    ]
+  };
+}
+function scrubLegacyExceptionExtra(extra) {
+  if (!extra) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(extra)) {
+    if (EXTRA_LOCATION_KEYS.has(key)) continue;
+    out[key] = value;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function buildExceptionFromError(err, context, inAppOptions) {
+  const mechanism = context?.mechanism ?? {
+    type: "generic",
+    handled: true
+  };
+  const stacktrace = applySourceLocation(
+    parseStackTrace(err.stack, inAppOptions),
+    context?.source,
+    inAppOptions
+  );
+  return {
+    values: [
+      {
+        type: err.name || "Error",
+        value: err.message || err.name || "Error",
+        mechanism,
+        ...stacktrace ? { stacktrace } : {}
+      }
+    ]
+  };
+}
 function mergeNetworkFailureContext(context, failure) {
   return {
     ...context,
@@ -13995,13 +14494,17 @@ function resolveOptions(options) {
     inlineStylesheet: options.inlineStylesheet ?? false,
     blockSelector: options.blockSelector ?? "",
     userId: options.userId,
-    tags: options.tags,
+    tags: mergeTags(options.tags),
     disableDefaultIntegrations: options.disableDefaultIntegrations ?? false,
     captureFailedRequests: options.captureFailedRequests ?? true,
     captureNetworkErrors: options.captureNetworkErrors ?? true,
+    networkErrorOrigins: options.networkErrorOrigins ?? [],
     includeNetworkUrlQuery: options.captureRequestQueryParameters ?? options.includeNetworkUrlQuery ?? false,
     failedRequestStatusCodes: options.failedRequestStatusCodes ?? [[500, 599]],
-    failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? []
+    failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? [],
+    inAppAllowUrls: options.inAppAllowUrls ?? [],
+    inAppDenyUrls: options.inAppDenyUrls ?? [],
+    inAppOrigins: options.inAppOrigins ?? []
   };
 }
 var RECENT_NETWORK_FAILURE_MS = 5e3;
@@ -14128,6 +14631,8 @@ var TalariaClient = class {
       installNetworkHook({
         captureFailedRequests: this.options.captureFailedRequests,
         captureNetworkErrors: this.options.captureNetworkErrors,
+        networkErrorOrigins: this.options.networkErrorOrigins,
+        pageOrigin: typeof location !== "undefined" ? location.origin : void 0,
         includeNetworkUrlQuery: this.options.includeNetworkUrlQuery,
         failedRequestStatusCodes: this.options.failedRequestStatusCodes,
         failedRequestIgnoreUrls: this.options.failedRequestIgnoreUrls,
@@ -14146,17 +14651,21 @@ var TalariaClient = class {
             failureKind: "http",
             aborted: false
           };
-          void this.captureMessage(
-            `HTTP ${status}: ${method} ${url}`,
-            status >= 500 ? "error" : "warning",
-            {
+          const message = `HTTP ${status}: ${method} ${url}`;
+          void this.capture({
+            message,
+            level: status >= 500 ? "error" : "warning",
+            title: networkExceptionClass(enriched),
+            exception: networkExceptionData(enriched, message),
+            platform: PLATFORM_JAVASCRIPT,
+            context: {
               tags: {
                 ...networkFailureTags(enriched),
                 "http.status_code": String(status)
               },
               extra: networkFailureExtra(enriched)
             }
-          );
+          });
         },
         onNetworkError: (meta) => {
           this.rememberNetworkFailure(meta, { promoted: true });
@@ -14164,14 +14673,18 @@ var TalariaClient = class {
           const url = meta.url || "(unknown url)";
           const errLabel = meta.errorName && meta.errorMessage ? `${meta.errorName}: ${meta.errorMessage}` : meta.errorMessage || meta.errorName || "Failed to fetch";
           const prefix = meta.failureKind === "timeout" ? "Timeout error" : "Network error";
-          void this.captureMessage(
-            `${prefix}: ${method} ${url} \u2014 ${errLabel}`,
-            "error",
-            {
+          const message = `${prefix}: ${method} ${url} \u2014 ${errLabel}`;
+          void this.capture({
+            message,
+            level: "error",
+            title: networkExceptionClass(meta),
+            exception: networkExceptionData(meta, message),
+            platform: PLATFORM_JAVASCRIPT,
+            context: {
               tags: networkFailureTags(meta),
               extra: networkFailureExtra(meta)
             }
-          );
+          });
         }
       }),
       installVisibilityResumeHook(() => this.onForegroundResume())
@@ -14208,7 +14721,7 @@ var TalariaClient = class {
     if (this.capturing || this.ingestDisabled) return;
     const err = error instanceof Error ? error : new Error(typeof error === "string" ? error : "Unknown error");
     if (isAbortError(err)) return;
-    const filename = typeof context?.extra?.filename === "string" ? context.extra.filename : void 0;
+    const filename = context?.source?.filename;
     if (isBrowserExtensionNoise({
       message: err.message,
       stack: err.stack,
@@ -14221,6 +14734,7 @@ var TalariaClient = class {
     }
     const correlated = this.consumeCorrelatedNetworkFailure(err);
     if (correlated?.promoted) return;
+    if (correlated && correlated.party === "third_party") return;
     const mergedContext = correlated ? mergeNetworkFailureContext(context, correlated) : context;
     this.capturing = true;
     try {
@@ -14229,6 +14743,12 @@ var TalariaClient = class {
         level: "error",
         title: err.name || "Error",
         stackTrace: err.stack,
+        exception: buildExceptionFromError(
+          err,
+          mergedContext,
+          this.inAppFrameOptions()
+        ),
+        platform: PLATFORM_JAVASCRIPT,
         context: mergedContext
       });
     } finally {
@@ -14244,6 +14764,13 @@ var TalariaClient = class {
       context
     });
   }
+  /**
+   * Returns a scoped capture facade that merges [tags] into every event.
+   * Nested `withTags` calls merge further (later keys win).
+   */
+  withTags(tags) {
+    return createScopedTalaria(this, mergeTags(tags));
+  }
   async flush(opts) {
     if (!this.options || !this.transport || this.closed) return;
     const keepalive = opts?.keepalive ?? false;
@@ -14408,13 +14935,17 @@ var TalariaClient = class {
     }
     const queuedMs = Math.max(0, Date.now() - occurredAt.getTime());
     const tags = applyReplayCaptureTags(
-      {
-        ...this.browserContext ? browserContextTags(this.browserContext) : {},
-        ...this.options.tags ?? {},
-        ...args.context?.tags ?? {}
-      },
+      mergeTags(
+        this.browserContext ? browserContextTags(this.browserContext) : {},
+        this.options.tags,
+        args.context?.tags
+      ),
       errorClipOutcome
     );
+    warnSuspiciousTags(tags, this.options.environment);
+    const scrubbedContextExtra = scrubLegacyExceptionExtra(
+      args.context?.extra
+    );
     const extra = mergeReplayCaptureExtra(
       {
         ...this.browserContext ? {
@@ -14436,7 +14967,7 @@ var TalariaClient = class {
           // Time spent in capture() before ingest (mostly replay flush).
           ...queuedMs >= 50 ? { queuedMs } : {}
         },
-        ...args.context?.extra
+        ...scrubbedContextExtra ?? {}
       },
       errorClipOutcome
     );
@@ -14448,6 +14979,8 @@ var TalariaClient = class {
         eventType: levelToEventType(args.level),
         title: args.title ?? args.context?.title,
         stackTrace: args.stackTrace,
+        exception: args.exception,
+        platform: args.platform,
         release: this.options.release,
         userId: args.context?.userId ?? this.options.userId,
         sessionId: this.sessionId ?? void 0,
@@ -14697,12 +15230,36 @@ var TalariaClient = class {
       this.resetToBufferMode();
     }
   }
+  inAppFrameOptions() {
+    const opts = this.options;
+    let pageOrigin;
+    try {
+      pageOrigin = resolvePageOrigin(
+        typeof window !== "undefined" ? window.location?.origin : void 0
+      );
+    } catch {
+      pageOrigin = void 0;
+    }
+    return {
+      pageOrigin,
+      allowUrls: opts?.inAppAllowUrls,
+      denyUrls: opts?.inAppDenyUrls,
+      inAppOrigins: opts?.inAppOrigins
+    };
+  }
   pruneRecentNetworkFailures(now = Date.now()) {
     this.recentNetworkFailures = this.recentNetworkFailures.filter(
       (f) => now - f.at <= RECENT_NETWORK_FAILURE_MS
     );
   }
   rememberNetworkFailure(meta, opts) {
+    if (this.options) {
+      const ignore = buildFailedRequestIgnoreUrls(
+        this.options.failedRequestIgnoreUrls,
+        this.options.baseUrl
+      );
+      if (urlMatchesIgnoreList(meta.url || "", ignore)) return;
+    }
     const now = Date.now();
     this.pruneRecentNetworkFailures(now);
     for (let i = this.recentNetworkFailures.length - 1; i >= 0; i--) {
@@ -14713,6 +15270,8 @@ var TalariaClient = class {
         existing.errorName = meta.errorName ?? existing.errorName;
         existing.aborted = meta.aborted ?? existing.aborted;
         existing.failureKind = meta.failureKind ?? existing.failureKind;
+        existing.party = meta.party ?? existing.party;
+        existing.origin = meta.origin ?? existing.origin;
         return;
       }
     }
@@ -14723,11 +15282,12 @@ var TalariaClient = class {
     });
   }
   /**
-   * Find a recent transport failure for a bare fetch TypeError.
+   * Find a recent transport failure for a bare fetch TypeError / TimeoutError.
    * Consumes the entry so a later duplicate path cannot reuse it.
    */
   consumeCorrelatedNetworkFailure(error) {
-    if (!isLikelyNetworkFetchError(error)) return null;
+    if (!isCorrelatableTransportError(error)) return null;
+    const wantKind = isTimeoutError(error) ? "timeout" : "network";
     const now = Date.now();
     this.pruneRecentNetworkFailures(now);
     const takeAt = (index2) => {
@@ -14736,14 +15296,14 @@ var TalariaClient = class {
     };
     for (let i = this.recentNetworkFailures.length - 1; i >= 0; i--) {
       const failure = this.recentNetworkFailures[i];
-      if (failure.aborted || failure.failureKind !== "network") continue;
+      if (failure.aborted || failure.failureKind !== wantKind) continue;
       if (failure.errorMessage && failure.errorMessage === error.message) {
         return takeAt(i);
       }
     }
     for (let i = this.recentNetworkFailures.length - 1; i >= 0; i--) {
       const failure = this.recentNetworkFailures[i];
-      if (failure.aborted || failure.failureKind !== "network") continue;
+      if (failure.aborted || failure.failureKind !== wantKind) continue;
       return takeAt(i);
     }
     return null;
@@ -14761,7 +15321,8 @@ var TalariaClient = class {
         return;
       }
       void this.captureException(error, {
-        extra: {
+        mechanism: { type: "onerror", handled: false },
+        source: {
           filename: event.filename,
           lineno: event.lineno,
           colno: event.colno
@@ -14783,7 +15344,9 @@ var TalariaClient = class {
       })) {
         return;
       }
-      void this.captureException(reason);
+      void this.captureException(reason, {
+        mechanism: { type: "unhandledrejection", handled: false }
+      });
     };
     window.addEventListener("error", onError);
     window.addEventListener("unhandledrejection", onRejection);
@@ -15045,6 +15608,23 @@ var TalariaClient = class {
     }
   }
 };
+function createScopedTalaria(client2, scopeTags) {
+  const mergeContext = (context) => ({
+    ...context,
+    tags: mergeTags(scopeTags, context?.tags)
+  });
+  return {
+    captureException(error, context) {
+      return client2.captureException(error, mergeContext(context));
+    },
+    captureMessage(message, level, context) {
+      return client2.captureMessage(message, level, mergeContext(context));
+    },
+    withTags(tags) {
+      return createScopedTalaria(client2, mergeTags(scopeTags, tags));
+    }
+  };
+}
 
 // src/index.ts
 var client = new TalariaClient();
@@ -15058,6 +15638,9 @@ var Talaria = {
   captureMessage(message, level, context) {
     return client.captureMessage(message, level, context);
   },
+  withTags(tags) {
+    return client.withTags(tags);
+  },
   getReplayId() {
     return client.getReplayId();
   },
@@ -15075,14 +15658,22 @@ export {
   MAX_SEGMENTS_ERROR_CLIP,
   REPLAY_CAPTURE_REASON_TAG,
   REPLAY_CAPTURE_TAG,
+  RESERVED_TAG_KEYS,
   TARGET_COMPRESSED_SEGMENT_BYTES,
   Talaria,
   TalariaClient,
+  applySourceLocation,
   computeErrorClipDeadlineMs,
   index_default as default,
   fitCompressedPrefix,
   isErrorClipBudgetExhausted,
-  planOversizedRetry
+  isInAppFrame,
+  mergeTags,
+  normalizeTags,
+  parseStackLine,
+  parseStackTrace,
+  planOversizedRetry,
+  resolvePageOrigin
 };
 /*! Bundled license information: