@newtalaria/browser 0.1.13 → 0.1.16

package/dist/index.js

@@ -15,6 +15,43 @@ function createId() {
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 
+// src/utils/environment.ts
+var WIRE = /* @__PURE__ */ new Set([
+  "production",
+  "staging",
+  "development"
+]);
+function normalizeEnvironment(raw) {
+  const normalized = raw.trim().toLowerCase();
+  if (!normalized) {
+    throw new Error(
+      "@newtalaria/browser: init requires `environment` (production | staging | development)"
+    );
+  }
+  switch (normalized) {
+    case "prod":
+    case "production":
+    case "live":
+      return "production";
+    case "stage":
+    case "staging":
+    case "uat":
+    case "test":
+      return "staging";
+    case "dev":
+    case "development":
+    case "local":
+      return "development";
+    default:
+      if (WIRE.has(normalized)) {
+        return normalized;
+      }
+      throw new Error(
+        `@newtalaria/browser: invalid environment '${raw}'. Expected production, staging, or development.`
+      );
+  }
+}
+
 // src/utils/browser_extension_noise.ts
 var EXTENSION_URL = /(?:chrome|moz|safari|safari-web|ms-browser)-extension:\/\//i;
 var WEBKIT_MASKED = /webkit-masked-url:\/\/hidden\//i;
@@ -38,6 +75,28 @@ function isOpaqueCrossOriginScriptError(event) {
   return true;
 }
 
+// src/utils/sdk_internal_noise.ts
+var SDK_STACK_FRAME = /@newtalaria\/browser|\/npm\/@newtalaria\/browser(?:@[\w.-]+)?\//i;
+function isSdkInternalNoise(opts) {
+  const stack = opts.stack ?? "";
+  if (!stack) return false;
+  const frameLines = stack.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("at "));
+  if (frameLines.length === 0) return false;
+  let sdkFrames = 0;
+  let otherUrlFrames = 0;
+  for (const line of frameLines) {
+    const urlMatch = line.match(/\((https?:\/\/[^)]+)\)|(https?:\/\/\S+)/i);
+    const url = urlMatch?.[1] ?? urlMatch?.[2];
+    if (!url) continue;
+    if (SDK_STACK_FRAME.test(url)) {
+      sdkFrames += 1;
+    } else {
+      otherUrlFrames += 1;
+    }
+  }
+  return sdkFrames > 0 && otherUrlFrames === 0;
+}
+
 // src/utils/browser_context.ts
 function parseBrowserContext(ua = typeof navigator !== "undefined" ? navigator.userAgent : "", language = typeof navigator !== "undefined" ? navigator.language : "") {
   const userAgent = ua || "";
@@ -167,7 +226,7 @@ async function collectBrowserContext() {
 
 // src/sdk_meta.ts
 var SDK_NAME = "@newtalaria/browser";
-var SDK_VERSION = "0.1.13";
+var SDK_VERSION = "0.1.16";
 
 // src/transport/serverpod.ts
 var ServerpodTransport = class {
@@ -13391,6 +13450,40 @@ function redactUrl(raw) {
     return raw.replace(SENSITIVE_QUERY, (_m, name) => `${name}=[Filtered]`);
   }
 }
+function sanitizeNetworkUrl(raw, opts) {
+  const baseHref = opts?.baseHref ?? (typeof location !== "undefined" ? location.href : void 0);
+  try {
+    const parsed = new URL(raw, baseHref);
+    const hostname = parsed.hostname;
+    const pathname = parsed.pathname || "/";
+    const originPath = `${parsed.origin}${pathname}`;
+    if (!opts?.includeQuery) {
+      return { url: originPath, hostname, pathname };
+    }
+    const redacted = new URL(redactUrl(parsed.toString()));
+    const search = redacted.search || void 0;
+    return {
+      url: search ? `${originPath}${search}` : originPath,
+      hostname,
+      pathname,
+      ...search ? { search } : {}
+    };
+  } catch {
+    const stripped = (raw.split(/[?#]/)[0] ?? raw).trim() || raw;
+    if (!opts?.includeQuery) {
+      return { url: stripped, hostname: "", pathname: stripped };
+    }
+    const redacted = redactUrl(raw);
+    const qIndex = redacted.indexOf("?");
+    const search = qIndex >= 0 ? redacted.slice(qIndex) : void 0;
+    return {
+      url: redacted.split("#")[0] || redacted,
+      hostname: "",
+      pathname: stripped,
+      ...search ? { search } : {}
+    };
+  }
+}
 function defaultBlockSelector(extra) {
   const parts = [
     "[data-talaria-mask]",
@@ -13447,6 +13540,32 @@ function startRecorder(options) {
   };
 }
 
+// src/utils/network_error.ts
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function isLikelyNetworkFetchError(error) {
+  if (!(error instanceof Error)) return false;
+  if (error.name === "AbortError") return false;
+  if (error.name === "NetworkError") return true;
+  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 describeUnknownError(error) {
+  if (error instanceof Error) {
+    return {
+      errorName: error.name || "Error",
+      errorMessage: (error.message || "").slice(0, 500),
+      aborted: error.name === "AbortError"
+    };
+  }
+  return {
+    errorName: "Error",
+    errorMessage: String(error).slice(0, 500),
+    aborted: false
+  };
+}
+
 // src/replay/hooks.ts
 function installVisibilityResumeHook(onResume) {
   if (typeof document === "undefined") {
@@ -13474,20 +13593,40 @@ function installVisibilityResumeHook(onResume) {
     }
   };
 }
+function serializeConsoleArg(arg) {
+  if (arg instanceof Error) {
+    return { name: arg.name, message: arg.message, stack: arg.stack };
+  }
+  return arg;
+}
+function formatConsoleArg(arg) {
+  if (arg == null) return String(arg);
+  if (typeof arg === "string") return arg;
+  if (typeof arg === "number" || typeof arg === "boolean") return String(arg);
+  if (arg instanceof Error) {
+    return arg.stack || `${arg.name}: ${arg.message}`;
+  }
+  if (typeof arg === "object" && arg !== null && "name" in arg && "message" in arg) {
+    const err = arg;
+    if (typeof err.stack === "string" && err.stack) return err.stack;
+    return `${String(err.name)}: ${String(err.message)}`;
+  }
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+}
 function safeSerialize(args) {
   try {
-    return JSON.stringify(
-      args.map((a) => {
-        if (a instanceof Error) {
-          return { name: a.name, message: a.message, stack: a.stack };
-        }
-        return a;
-      })
-    );
+    return JSON.stringify(args.map(serializeConsoleArg));
   } catch {
     return "[unserializable]";
   }
 }
+function consoleMessage(args) {
+  return args.map(formatConsoleArg).join(" ").slice(0, 4e3);
+}
 function installConsoleHook() {
   const levels = ["log", "info", "warn", "error", "debug"];
   const originals = {};
@@ -13496,9 +13635,12 @@ function installConsoleHook() {
     originals[level] = original;
     console[level] = (...args) => {
       try {
+        const serializedArgs = safeSerialize(args).slice(0, 4e3);
         record.addCustomEvent("talaria-console", {
           level,
-          args: safeSerialize(args).slice(0, 4e3),
+          // `message` is what the replay sidebar displays; `args` kept for tooling.
+          message: consoleMessage(args),
+          args: serializedArgs,
           timestamp: Date.now()
         });
       } catch {
@@ -13517,7 +13659,6 @@ function emitNetwork(meta) {
   try {
     record.addCustomEvent("talaria-network", {
       ...meta,
-      url: redactUrl(meta.url),
       timestamp: Date.now()
     });
   } catch {
@@ -13534,23 +13675,70 @@ function statusMatches(status, codes) {
   }
   return false;
 }
-function shouldPromoteFailedRequest(meta, opts) {
-  if (!opts.captureFailedRequests) return false;
-  if (typeof meta.status !== "number" || Number.isNaN(meta.status)) return false;
-  if (!statusMatches(meta.status, opts.failedRequestStatusCodes)) return false;
-  const url = meta.url || "";
-  const ignore = [...opts.failedRequestIgnoreUrls];
-  const base = (opts.talariaBaseUrl ?? "").replace(/\/+$/, "");
+function buildFailedRequestIgnoreUrls(failedRequestIgnoreUrls, talariaBaseUrl) {
+  const ignore = [...failedRequestIgnoreUrls];
+  const base = (talariaBaseUrl ?? "").replace(/\/+$/, "");
   if (base) {
     ignore.push(`${base}/events/`, `${base}/replays/`);
   }
   ignore.push("/events/ingest", "/events/ingestBatch", "/replays/");
-  const lower = url.toLowerCase();
-  for (const part of ignore) {
-    if (part && lower.includes(part.toLowerCase())) return false;
+  return ignore;
+}
+function urlMatchesIgnoreList(url, ignoreUrls) {
+  const lower = (url || "").toLowerCase();
+  for (const part of ignoreUrls) {
+    if (part && lower.includes(part.toLowerCase())) return true;
   }
+  return false;
+}
+function shouldPromoteFailedRequest(meta, opts) {
+  if (!opts.captureFailedRequests) return false;
+  if (typeof meta.status !== "number" || Number.isNaN(meta.status)) return false;
+  if (meta.status === 0) return false;
+  if (!statusMatches(meta.status, opts.failedRequestStatusCodes)) return false;
+  const ignore = buildFailedRequestIgnoreUrls(
+    opts.failedRequestIgnoreUrls,
+    opts.talariaBaseUrl
+  );
+  if (urlMatchesIgnoreList(meta.url || "", ignore)) return false;
   return true;
 }
+function shouldPromoteNetworkError(meta, opts) {
+  if (!opts.captureNetworkErrors) return false;
+  if (meta.aborted) return false;
+  if (meta.failureKind !== "network") return false;
+  const ignore = buildFailedRequestIgnoreUrls(
+    opts.failedRequestIgnoreUrls,
+    opts.talariaBaseUrl
+  );
+  if (urlMatchesIgnoreList(meta.url || "", ignore)) return false;
+  return true;
+}
+function enrichNetworkMeta(meta) {
+  const hasHttpStatus = typeof meta.status === "number" && !Number.isNaN(meta.status) && meta.status > 0;
+  if (hasHttpStatus) {
+    return {
+      ...meta,
+      failureKind: meta.ok === false ? "http" : meta.failureKind
+    };
+  }
+  if (meta.ok === false || meta.errorName || meta.errorMessage) {
+    return {
+      ...meta,
+      failureKind: "network"
+    };
+  }
+  return meta;
+}
+function networkUrlParts(rawUrl, includeQuery) {
+  const parts = sanitizeNetworkUrl(rawUrl, { includeQuery });
+  return {
+    url: parts.url,
+    hostname: parts.hostname,
+    pathname: parts.pathname,
+    ...parts.search ? { search: parts.search } : {}
+  };
+}
 function installNetworkHook(options = {}) {
   const originalFetch = typeof fetch === "function" ? fetch.bind(globalThis) : null;
   const XHR = typeof XMLHttpRequest !== "undefined" ? XMLHttpRequest : null;
@@ -13558,38 +13746,57 @@ function installNetworkHook(options = {}) {
   const originalSend = XHR?.prototype.send;
   const matchOpts = {
     captureFailedRequests: options.captureFailedRequests ?? true,
+    captureNetworkErrors: options.captureNetworkErrors ?? true,
     failedRequestStatusCodes: options.failedRequestStatusCodes ?? [[500, 599]],
     failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? [],
     talariaBaseUrl: options.talariaBaseUrl
   };
+  const includeQuery = options.includeNetworkUrlQuery ?? false;
   const handleMeta = (meta) => {
-    emitNetwork(meta);
-    options.onNetwork?.(meta);
-    if (shouldPromoteFailedRequest(meta, matchOpts)) {
-      options.onFailedRequest?.(meta);
+    const { rawUrl, ...rest } = meta;
+    const enriched = enrichNetworkMeta({
+      ...rest,
+      ...networkUrlParts(rawUrl, includeQuery)
+    });
+    try {
+      emitNetwork(enriched);
+      options.onNetwork?.(enriched);
+      if (shouldPromoteFailedRequest(enriched, matchOpts)) {
+        options.onFailedRequest?.(enriched);
+      } else if (shouldPromoteNetworkError(enriched, matchOpts)) {
+        options.onNetworkError?.(enriched);
+      }
+    } catch {
     }
   };
   if (originalFetch) {
     globalThis.fetch = async (input2, init) => {
       const started = Date.now();
       const method = (init?.method ?? (input2 instanceof Request ? input2.method : "GET")).toUpperCase();
-      const url = typeof input2 === "string" ? input2 : input2 instanceof URL ? input2.toString() : input2.url;
+      const rawUrl = typeof input2 === "string" ? input2 : input2 instanceof URL ? input2.toString() : input2.url;
       try {
         const response = await originalFetch(input2, init);
         handleMeta({
           method,
-          url,
+          rawUrl,
+          url: rawUrl,
           status: response.status,
           durationMs: Date.now() - started,
           ok: response.ok
         });
         return response;
       } catch (error) {
+        const described = describeUnknownError(error);
         handleMeta({
           method,
-          url,
+          rawUrl,
+          url: rawUrl,
           durationMs: Date.now() - started,
-          ok: false
+          ok: false,
+          errorName: described.errorName,
+          errorMessage: described.errorMessage,
+          aborted: described.aborted,
+          failureKind: "network"
         });
         throw error;
       }
@@ -13604,12 +13811,21 @@ function installNetworkHook(options = {}) {
     XHR.prototype.send = function(body) {
       this.__talariaStarted = Date.now();
       const onDone = () => {
+        const status = this.status;
+        const networkFail = status === 0;
+        const rawUrl = this.__talariaUrl ?? "";
         handleMeta({
           method: this.__talariaMethod ?? "GET",
-          url: this.__talariaUrl ?? "",
-          status: this.status,
+          rawUrl,
+          url: rawUrl,
+          status,
           durationMs: Date.now() - (this.__talariaStarted ?? Date.now()),
-          ok: this.status >= 200 && this.status < 400
+          ok: status >= 200 && status < 400,
+          ...networkFail ? {
+            failureKind: "network",
+            errorName: "NetworkError",
+            errorMessage: "XMLHttpRequest failed (status 0)"
+          } : {}
         });
       };
       this.addEventListener("loadend", onDone);
@@ -13624,6 +13840,37 @@ function installNetworkHook(options = {}) {
 }
 
 // src/client.ts
+function networkFailureExtra(failure) {
+  return {
+    method: failure.method || "GET",
+    url: failure.url || "(unknown url)",
+    ...failure.hostname ? { hostname: failure.hostname } : {},
+    ...failure.pathname ? { pathname: failure.pathname } : {},
+    ...failure.search ? { search: failure.search } : {},
+    ...typeof failure.status === "number" ? { status: failure.status } : {},
+    durationMs: failure.durationMs,
+    ok: failure.ok ?? false,
+    failureKind: failure.failureKind ?? "network",
+    aborted: failure.aborted ?? false,
+    ...failure.errorName ? { errorName: failure.errorName } : {},
+    ...failure.errorMessage ? { errorMessage: failure.errorMessage } : {}
+  };
+}
+function mergeNetworkFailureContext(context, failure) {
+  return {
+    ...context,
+    tags: {
+      ...context?.tags ?? {},
+      "http.method": failure.method || "GET",
+      "network.failure_kind": "network",
+      ...failure.errorName ? { "network.error_name": failure.errorName } : {}
+    },
+    extra: {
+      ...context?.extra ?? {},
+      network: networkFailureExtra(failure)
+    }
+  };
+}
 function resolveOptions(options) {
   const baseUrl = (options.baseUrl ?? options.dsn ?? "").trim();
   if (!baseUrl) {
@@ -13638,7 +13885,7 @@ function resolveOptions(options) {
   return {
     baseUrl,
     apiKey: options.apiKey.trim(),
-    environment: String(options.environment),
+    environment: normalizeEnvironment(String(options.environment)),
     release: options.release,
     replaysSessionSampleRate: clamp01(options.replaysSessionSampleRate ?? 0),
     replaysOnErrorSampleRate: clamp01(options.replaysOnErrorSampleRate ?? 1),
@@ -13650,10 +13897,13 @@ function resolveOptions(options) {
     tags: options.tags,
     disableDefaultIntegrations: options.disableDefaultIntegrations ?? false,
     captureFailedRequests: options.captureFailedRequests ?? true,
+    captureNetworkErrors: options.captureNetworkErrors ?? true,
+    includeNetworkUrlQuery: options.includeNetworkUrlQuery ?? false,
     failedRequestStatusCodes: options.failedRequestStatusCodes ?? [[500, 599]],
     failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? []
   };
 }
+var RECENT_NETWORK_FAILURE_MS = 5e3;
 function clamp01(n2) {
   if (Number.isNaN(n2)) return 0;
   return Math.min(1, Math.max(0, n2));
@@ -13678,6 +13928,16 @@ function isOversizedSegmentError(error) {
   const msg = error instanceof Error ? error.message : String(error);
   return msg.includes("segment exceeds max compressed size") || msg.includes("segment exceeds max uncompressed size") || msg.includes("HTTP 400") && msg.includes("ApiValidationException");
 }
+function isPermanentIngestError(error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  const match = /Talaria events\/ingest(?:Batch)? failed: HTTP (\d{3})/.exec(
+    msg
+  );
+  if (!match) return false;
+  const status = Number(match[1]);
+  if (status < 400 || status >= 500) return false;
+  return status !== 408 && status !== 429;
+}
 var TalariaClient = class {
   constructor() {
     this.options = null;
@@ -13712,6 +13972,15 @@ var TalariaClient = class {
     this.lastReplayCaptureFailure = null;
     /** Cached once per init for event tags/extra. */
     this.browserContext = null;
+    /** Prevent ingest/replay failures from being re-captured via unhandledrejection. */
+    this.capturing = false;
+    /**
+     * Set after a permanent events/ingest 4xx (bad env/auth/wire). Further
+     * captures no-op so we don't spin on retries or burn error-clip replay quota.
+     */
+    this.ingestDisabled = false;
+    /** Recent fetch/XHR transport failures for correlation + dedupe. */
+    this.recentNetworkFailures = [];
   }
   init(options) {
     if (this.options) {
@@ -13726,6 +13995,7 @@ var TalariaClient = class {
     this.sessionId = createId();
     this.replayId = createId();
     this.closed = false;
+    this.ingestDisabled = false;
     this.finishedOnServer = false;
     this.startedOnServer = false;
     this.segmentIndex = 0;
@@ -13734,6 +14004,7 @@ var TalariaClient = class {
     this.errorClipDeadlineMs = null;
     this.linkableReplayId = null;
     this.lastReplayCaptureFailure = null;
+    this.recentNetworkFailures = [];
     this.browserContext = parseBrowserContext();
     void collectBrowserContext().then((ctx) => {
       if (this.options) this.browserContext = ctx;
@@ -13755,9 +14026,16 @@ var TalariaClient = class {
       installConsoleHook(),
       installNetworkHook({
         captureFailedRequests: this.options.captureFailedRequests,
+        captureNetworkErrors: this.options.captureNetworkErrors,
+        includeNetworkUrlQuery: this.options.includeNetworkUrlQuery,
         failedRequestStatusCodes: this.options.failedRequestStatusCodes,
         failedRequestIgnoreUrls: this.options.failedRequestIgnoreUrls,
         talariaBaseUrl: this.options.baseUrl,
+        onNetwork: (meta) => {
+          if (meta.failureKind === "network" && !meta.aborted) {
+            this.rememberNetworkFailure(meta, { promoted: false });
+          }
+        },
         onFailedRequest: (meta) => {
           const status = meta.status;
           const method = meta.method || "GET";
@@ -13768,15 +14046,40 @@ var TalariaClient = class {
             {
               tags: {
                 "http.status_code": String(status),
-                "http.method": method
+                "http.method": method,
+                "network.failure_kind": "http"
               },
               extra: {
-                url,
-                durationMs: meta.durationMs,
-                ok: meta.ok
+                ...networkFailureExtra({
+                  ...meta,
+                  failureKind: "http",
+                  aborted: false
+                })
               }
             }
           );
+        },
+        onNetworkError: (meta) => {
+          this.rememberNetworkFailure(meta, { promoted: true });
+          const method = meta.method || "GET";
+          const url = meta.url || "(unknown url)";
+          const errLabel = meta.errorName && meta.errorMessage ? `${meta.errorName}: ${meta.errorMessage}` : meta.errorMessage || meta.errorName || "Failed to fetch";
+          void this.captureMessage(
+            `Network error: ${method} ${url} \u2014 ${errLabel}`,
+            "error",
+            {
+              tags: {
+                "http.method": method,
+                "network.failure_kind": "network",
+                ...meta.errorName ? { "network.error_name": meta.errorName } : {}
+              },
+              extra: networkFailureExtra({
+                ...meta,
+                failureKind: "network",
+                aborted: false
+              })
+            }
+          );
         }
       }),
       installVisibilityResumeHook(() => this.onForegroundResume())
@@ -13810,24 +14113,38 @@ var TalariaClient = class {
     return this.linkableReplayId;
   }
   async captureException(error, context) {
+    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;
     if (isBrowserExtensionNoise({
       message: err.message,
       stack: err.stack,
       filename
+    }) || isSdkInternalNoise({
+      message: err.message,
+      stack: err.stack
     })) {
       return;
     }
-    await this.capture({
-      message: err.message || err.name || "Error",
-      level: "error",
-      title: err.name || "Error",
-      stackTrace: err.stack,
-      context
-    });
+    const correlated = this.consumeCorrelatedNetworkFailure(err);
+    if (correlated?.promoted) return;
+    const mergedContext = correlated ? mergeNetworkFailureContext(context, correlated) : context;
+    this.capturing = true;
+    try {
+      await this.capture({
+        message: err.message || err.name || "Error",
+        level: "error",
+        title: err.name || "Error",
+        stackTrace: err.stack,
+        context: mergedContext
+      });
+    } finally {
+      this.capturing = false;
+    }
   }
   async captureMessage(message, level = "info", context) {
+    if (this.ingestDisabled) return;
     await this.capture({
       message,
       level,
@@ -13913,6 +14230,7 @@ var TalariaClient = class {
     this.linkableReplayId = null;
     this.lastReplayCaptureFailure = null;
     this.browserContext = null;
+    this.capturing = false;
   }
   onRrwebEvent(event) {
     if (this.closed || !this.options) return;
@@ -13937,6 +14255,8 @@ var TalariaClient = class {
     if (!this.options || !this.transport) {
       throw new Error("@newtalaria/browser: call Talaria.init() first");
     }
+    if (this.ingestDisabled) return;
+    const occurredAt = /* @__PURE__ */ new Date();
     const isErrorLike = args.level === "error" || args.level === "fatal";
     let errorClipOutcome = null;
     let attemptedErrorClip = false;
@@ -13994,6 +14314,7 @@ var TalariaClient = class {
         errorClipOutcome = { status: "failed", reason: "buffer_empty" };
       }
     }
+    const queuedMs = Math.max(0, Date.now() - occurredAt.getTime());
     const tags = applyReplayCaptureTags(
       {
         ...this.browserContext ? browserContextTags(this.browserContext) : {},
@@ -14015,7 +14336,12 @@ var TalariaClient = class {
             userAgent: this.browserContext.userAgent
           }
         } : {},
-        sdk: { name: SDK_NAME, version: SDK_VERSION },
+        sdk: {
+          name: SDK_NAME,
+          version: SDK_VERSION,
+          // Time spent in capture() before ingest (mostly replay flush).
+          ...queuedMs >= 50 ? { queuedMs } : {}
+        },
         ...args.context?.extra
       },
       errorClipOutcome
@@ -14035,7 +14361,7 @@ var TalariaClient = class {
         url: typeof location !== "undefined" ? location.href : void 0,
         tags: Object.keys(tags).length ? tags : void 0,
         extraJson: extra ? JSON.stringify(extra) : void 0,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        timestamp: occurredAt.toISOString(),
         keepalive: args.keepalive
       });
       if (replayId && replayId === this.linkableReplayId) {
@@ -14043,7 +14369,36 @@ var TalariaClient = class {
       }
     } catch (error) {
       console.warn("@newtalaria/browser: event ingest failed", error);
-      throw error;
+      if (isPermanentIngestError(error)) {
+        this.disableIngestAfterPermanentError(error);
+      }
+    }
+  }
+  /**
+   * Stop further event capture (and error-clip uploads) after a permanent
+   * events/ingest 4xx so misconfig cannot spin forever.
+   */
+  disableIngestAfterPermanentError(error) {
+    if (this.ingestDisabled) return;
+    this.ingestDisabled = true;
+    console.warn(
+      "@newtalaria/browser: event ingest disabled after permanent client error",
+      error
+    );
+    if (!this.sessionSampled && this.uploadEnabled) {
+      this.clearErrorClipTimer();
+      void this.enqueueUpload(async () => {
+        if (this.startedOnServer && !this.finishedOnServer) {
+          await this.finishOnServer({
+            keepalive: false,
+            reason: "ingest_disabled"
+          });
+        }
+        this.resetToBufferMode();
+      });
+    } else if (!this.sessionSampled) {
+      this.clearErrorClipTimer();
+      this.uploadEnabled = false;
     }
   }
   markUploadStarted() {
@@ -14248,6 +14603,57 @@ var TalariaClient = class {
       this.resetToBufferMode();
     }
   }
+  pruneRecentNetworkFailures(now = Date.now()) {
+    this.recentNetworkFailures = this.recentNetworkFailures.filter(
+      (f) => now - f.at <= RECENT_NETWORK_FAILURE_MS
+    );
+  }
+  rememberNetworkFailure(meta, opts) {
+    const now = Date.now();
+    this.pruneRecentNetworkFailures(now);
+    for (let i = this.recentNetworkFailures.length - 1; i >= 0; i--) {
+      const existing = this.recentNetworkFailures[i];
+      if (existing.method === meta.method && existing.url === meta.url && existing.errorMessage === meta.errorMessage && now - existing.at < 1e3) {
+        existing.promoted = existing.promoted || opts.promoted;
+        existing.durationMs = meta.durationMs ?? existing.durationMs;
+        existing.errorName = meta.errorName ?? existing.errorName;
+        existing.aborted = meta.aborted ?? existing.aborted;
+        existing.failureKind = meta.failureKind ?? existing.failureKind;
+        return;
+      }
+    }
+    this.recentNetworkFailures.push({
+      ...meta,
+      at: now,
+      promoted: opts.promoted
+    });
+  }
+  /**
+   * Find a recent transport failure for a bare fetch TypeError.
+   * Consumes the entry so a later duplicate path cannot reuse it.
+   */
+  consumeCorrelatedNetworkFailure(error) {
+    if (!isLikelyNetworkFetchError(error)) return null;
+    const now = Date.now();
+    this.pruneRecentNetworkFailures(now);
+    const takeAt = (index2) => {
+      const [failure] = this.recentNetworkFailures.splice(index2, 1);
+      return failure;
+    };
+    for (let i = this.recentNetworkFailures.length - 1; i >= 0; i--) {
+      const failure = this.recentNetworkFailures[i];
+      if (failure.aborted || failure.failureKind !== "network") 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;
+      return takeAt(i);
+    }
+    return null;
+  }
   installGlobalHandlers() {
     if (typeof window === "undefined") return;
     const onError = (event) => {
@@ -14269,7 +14675,21 @@ var TalariaClient = class {
       });
     };
     const onRejection = (event) => {
-      void this.captureException(event.reason);
+      const reason = event.reason;
+      if (isAbortError(reason)) return;
+      const err = reason instanceof Error ? reason : new Error(
+        typeof reason === "string" ? reason : "unhandledrejection"
+      );
+      if (isBrowserExtensionNoise({
+        message: err.message,
+        stack: err.stack
+      }) || isSdkInternalNoise({
+        message: err.message,
+        stack: err.stack
+      })) {
+        return;
+      }
+      void this.captureException(reason);
     };
     window.addEventListener("error", onError);
     window.addEventListener("unhandledrejection", onRejection);