@newtalaria/browser 0.1.17 → 0.1.19

package/dist/talaria.browser.iife.js

@@ -272,9 +272,253 @@
     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.`
+        );
+      }
+    }
+  }
+
+  // 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 {
@@ -332,6 +576,9 @@
     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;
@@ -348,6 +595,89 @@
       { 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) {
@@ -13484,18 +13814,22 @@
   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) {
@@ -13592,6 +13926,9 @@
   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;
@@ -13599,6 +13936,9 @@
     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 {
@@ -13746,6 +14086,56 @@
     }
     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;
@@ -13756,6 +14146,13 @@
       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) {
@@ -13769,6 +14166,13 @@
       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) {
@@ -13779,7 +14183,8 @@
         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
@@ -13792,10 +14197,13 @@
     }
     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 } : {}
@@ -13811,14 +14219,22 @@
       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);
@@ -13838,6 +14254,7 @@
         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,
@@ -13845,7 +14262,8 @@
             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) {
@@ -13907,7 +14325,7 @@
             transport: "xhr",
             status,
             durationMs: Date.now() - (this.__talariaStarted ?? Date.now()),
-            ok: status >= 200 && status < 400,
+            ok: isHttpOkStatus(status),
             ...transportFail ? {
               failureKind,
               errorName,
@@ -13916,7 +14334,7 @@
             } : {}
           });
         };
-        this.addEventListener("loadend", onDone);
+        this.addEventListener("loadend", onDone, { once: true });
         return originalSend.call(this, body);
       };
     }
@@ -13928,10 +14346,26 @@
   }
 
   // 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 } : {}
     };
@@ -13941,6 +14375,7 @@
       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;
@@ -13953,14 +14388,69 @@
     };
     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,
@@ -13997,13 +14487,17 @@
       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;
@@ -14130,6 +14624,8 @@
         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,
@@ -14148,17 +14644,21 @@
               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 });
@@ -14166,14 +14666,18 @@
             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())
@@ -14210,7 +14714,7 @@
       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,
@@ -14223,6 +14727,7 @@
       }
       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 {
@@ -14231,6 +14736,12 @@
           level: "error",
           title: err.name || "Error",
           stackTrace: err.stack,
+          exception: buildExceptionFromError(
+            err,
+            mergedContext,
+            this.inAppFrameOptions()
+          ),
+          platform: PLATFORM_JAVASCRIPT,
           context: mergedContext
         });
       } finally {
@@ -14246,6 +14757,13 @@
         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;
@@ -14410,13 +14928,17 @@
       }
       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 ? {
@@ -14438,7 +14960,7 @@
             // Time spent in capture() before ingest (mostly replay flush).
             ...queuedMs >= 50 ? { queuedMs } : {}
           },
-          ...args.context?.extra
+          ...scrubbedContextExtra ?? {}
         },
         errorClipOutcome
       );
@@ -14450,6 +14972,8 @@
           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,
@@ -14699,12 +15223,36 @@
         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--) {
@@ -14715,6 +15263,8 @@
           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;
         }
       }
@@ -14725,11 +15275,12 @@
       });
     }
     /**
-     * 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) => {
@@ -14738,14 +15289,14 @@
       };
       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;
@@ -14763,7 +15314,8 @@
           return;
         }
         void this.captureException(error, {
-          extra: {
+          mechanism: { type: "onerror", handled: false },
+          source: {
             filename: event.filename,
             lineno: event.lineno,
             colno: event.colno
@@ -14785,7 +15337,9 @@
         })) {
           return;
         }
-        void this.captureException(reason);
+        void this.captureException(reason, {
+          mechanism: { type: "unhandledrejection", handled: false }
+        });
       };
       window.addEventListener("error", onError);
       window.addEventListener("unhandledrejection", onRejection);
@@ -15047,6 +15601,23 @@
       }
     }
   };
+  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();
@@ -15060,6 +15631,9 @@
     captureMessage(message, level, context) {
       return client.captureMessage(message, level, context);
     },
+    withTags(tags) {
+      return client.withTags(tags);
+    },
     getReplayId() {
       return client.getReplayId();
     },