@newtalaria/browser 0.1.12 → 0.1.15

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.12";
+var SDK_VERSION = "0.1.15";
 
 // src/transport/serverpod.ts
 var ServerpodTransport = class {
@@ -284,6 +343,7 @@ var MAX_ERROR_CLIP_COMPRESSED_BYTES = 2 * 1024 * 1024;
 var ERROR_CLIP_FLUSH_SLACK_MS = 5e3;
 var SEGMENT_FLUSH_MS = 5e3;
 var RING_BUFFER_MS = 6e4;
+var RING_BUFFER_CHECKOUT_MS = RING_BUFFER_MS;
 var RING_BUFFER_MAX_BYTES = 15e5;
 var ERROR_REPLAY_AFTER_MS = 15e3;
 var MAX_REPLAY_DURATION_MS = 5 * 60 * 1e3;
@@ -13426,6 +13486,7 @@ function startRecorder(options) {
     inlineStylesheet: options.inlineStylesheet,
     // Shrink DOM snapshots on heavy sites (docs / marketing).
     slimDOMOptions: "all",
+    ...options.checkoutEveryNms != null && options.checkoutEveryNms > 0 ? { checkoutEveryNms: options.checkoutEveryNms } : {},
     sampling: {
       mousemove: 150,
       scroll: 200,
@@ -13445,21 +13506,93 @@ 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") {
+    return () => {
+    };
+  }
+  const onVisibility = () => {
+    if (document.visibilityState === "visible") {
+      onResume();
+    }
+  };
+  const onPageShow = (event) => {
+    if (event.persisted) {
+      onResume();
+    }
+  };
+  document.addEventListener("visibilitychange", onVisibility);
+  if (typeof window !== "undefined") {
+    window.addEventListener("pageshow", onPageShow);
+  }
+  return () => {
+    document.removeEventListener("visibilitychange", onVisibility);
+    if (typeof window !== "undefined") {
+      window.removeEventListener("pageshow", onPageShow);
+    }
+  };
+}
+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 = {};
@@ -13468,9 +13601,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 {
@@ -13506,23 +13642,61 @@ 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 installNetworkHook(options = {}) {
   const originalFetch = typeof fetch === "function" ? fetch.bind(globalThis) : null;
   const XHR = typeof XMLHttpRequest !== "undefined" ? XMLHttpRequest : null;
@@ -13530,15 +13704,22 @@ 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 handleMeta = (meta) => {
-    emitNetwork(meta);
-    options.onNetwork?.(meta);
-    if (shouldPromoteFailedRequest(meta, matchOpts)) {
-      options.onFailedRequest?.(meta);
+    const enriched = enrichNetworkMeta(meta);
+    try {
+      emitNetwork(enriched);
+      options.onNetwork?.(enriched);
+      if (shouldPromoteFailedRequest(enriched, matchOpts)) {
+        options.onFailedRequest?.(enriched);
+      } else if (shouldPromoteNetworkError(enriched, matchOpts)) {
+        options.onNetworkError?.(enriched);
+      }
+    } catch {
     }
   };
   if (originalFetch) {
@@ -13557,11 +13738,16 @@ function installNetworkHook(options = {}) {
         });
         return response;
       } catch (error) {
+        const described = describeUnknownError(error);
         handleMeta({
           method,
           url,
           durationMs: Date.now() - started,
-          ok: false
+          ok: false,
+          errorName: described.errorName,
+          errorMessage: described.errorMessage,
+          aborted: described.aborted,
+          failureKind: "network"
         });
         throw error;
       }
@@ -13576,12 +13762,19 @@ function installNetworkHook(options = {}) {
     XHR.prototype.send = function(body) {
       this.__talariaStarted = Date.now();
       const onDone = () => {
+        const status = this.status;
+        const networkFail = status === 0;
         handleMeta({
           method: this.__talariaMethod ?? "GET",
           url: this.__talariaUrl ?? "",
-          status: this.status,
+          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);
@@ -13596,6 +13789,31 @@ function installNetworkHook(options = {}) {
 }
 
 // src/client.ts
+function mergeNetworkFailureContext(context, failure) {
+  const url = redactUrl(failure.url || "(unknown url)");
+  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: {
+        method: failure.method,
+        url,
+        durationMs: failure.durationMs,
+        ok: false,
+        failureKind: "network",
+        errorName: failure.errorName,
+        errorMessage: failure.errorMessage,
+        aborted: failure.aborted ?? false
+      }
+    }
+  };
+}
 function resolveOptions(options) {
   const baseUrl = (options.baseUrl ?? options.dsn ?? "").trim();
   if (!baseUrl) {
@@ -13610,7 +13828,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),
@@ -13622,10 +13840,12 @@ function resolveOptions(options) {
     tags: options.tags,
     disableDefaultIntegrations: options.disableDefaultIntegrations ?? false,
     captureFailedRequests: options.captureFailedRequests ?? true,
+    captureNetworkErrors: options.captureNetworkErrors ?? true,
     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));
@@ -13650,6 +13870,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;
@@ -13684,6 +13914,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) {
@@ -13698,6 +13937,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;
@@ -13706,6 +13946,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;
@@ -13718,36 +13959,74 @@ var TalariaClient = class {
       maskAllInputs: this.options.maskAllInputs,
       inlineStylesheet: this.options.inlineStylesheet,
       blockSelector: this.options.blockSelector,
+      // Buffer/error path: keep a FullSnapshot inside the ~60s ring. Session
+      // sample uploads continuously so periodic checkouts are skipped (size).
+      checkoutEveryNms: this.sessionSampled ? void 0 : RING_BUFFER_CHECKOUT_MS,
       onEvent: (event) => this.onRrwebEvent(event)
     });
     this.teardowns.push(
       installConsoleHook(),
       installNetworkHook({
         captureFailedRequests: this.options.captureFailedRequests,
+        captureNetworkErrors: this.options.captureNetworkErrors,
         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";
-          const url = meta.url || "(unknown url)";
+          const url = redactUrl(meta.url || "(unknown url)");
           void this.captureMessage(
             `HTTP ${status}: ${method} ${url}`,
             status >= 500 ? "error" : "warning",
             {
               tags: {
                 "http.status_code": String(status),
-                "http.method": method
+                "http.method": method,
+                "network.failure_kind": "http"
               },
               extra: {
                 url,
                 durationMs: meta.durationMs,
-                ok: meta.ok
+                ok: meta.ok,
+                failureKind: "http"
+              }
+            }
+          );
+        },
+        onNetworkError: (meta) => {
+          this.rememberNetworkFailure(meta, { promoted: true });
+          const method = meta.method || "GET";
+          const url = redactUrl(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: {
+                url,
+                durationMs: meta.durationMs,
+                ok: false,
+                failureKind: "network",
+                errorName: meta.errorName,
+                errorMessage: meta.errorMessage,
+                aborted: false
               }
             }
           );
         }
-      })
+      }),
+      installVisibilityResumeHook(() => this.onForegroundResume())
     );
     if (!this.options.disableDefaultIntegrations) {
       this.installGlobalHandlers();
@@ -13778,24 +14057,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,
@@ -13881,6 +14174,7 @@ var TalariaClient = class {
     this.linkableReplayId = null;
     this.lastReplayCaptureFailure = null;
     this.browserContext = null;
+    this.capturing = false;
   }
   onRrwebEvent(event) {
     if (this.closed || !this.options) return;
@@ -13905,6 +14199,7 @@ var TalariaClient = class {
     if (!this.options || !this.transport) {
       throw new Error("@newtalaria/browser: call Talaria.init() first");
     }
+    if (this.ingestDisabled) return;
     const isErrorLike = args.level === "error" || args.level === "fatal";
     let errorClipOutcome = null;
     let attemptedErrorClip = false;
@@ -14011,7 +14306,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() {
@@ -14141,6 +14465,18 @@ var TalariaClient = class {
   checkoutFullSnapshot() {
     this.recorder?.takeFullSnapshot();
   }
+  /**
+   * Tab focus / bfcache restore: background timers are throttled, so the
+   * buffer-mode checkout interval may not have fired. Refresh the paint base
+   * so an error clip still has ~60s of usable lead-up after the user returns.
+   */
+  onForegroundResume() {
+    if (this.closed || !this.options || !this.recorder) return;
+    if (!this.uploadEnabled) {
+      this.buffer.trimRing();
+    }
+    this.checkoutFullSnapshot();
+  }
   /**
    * Ensure segment 0 begins at Meta+FullSnapshot. Orphan increments alone
    * produce a blank rrweb player.
@@ -14204,6 +14540,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) => {
@@ -14225,7 +14612,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);