@newtalaria/browser 0.1.13 → 0.1.15

package/dist/talaria.browser.iife.js

@@ -17,6 +17,43 @@
     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;
@@ -40,6 +77,28 @@
     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 || "";
@@ -169,7 +228,7 @@
 
   // src/sdk_meta.ts
   var SDK_NAME = "@newtalaria/browser";
-  var SDK_VERSION = "0.1.13";
+  var SDK_VERSION = "0.1.15";
 
   // src/transport/serverpod.ts
   var ServerpodTransport = class {
@@ -13449,6 +13508,32 @@
     };
   }
 
+  // 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") {
@@ -13476,20 +13561,40 @@
       }
     };
   }
+  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 = {};
@@ -13498,9 +13603,12 @@
       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 {
@@ -13536,23 +13644,61 @@
     }
     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;
@@ -13560,15 +13706,22 @@
     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) {
@@ -13587,11 +13740,16 @@
           });
           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;
         }
@@ -13606,12 +13764,19 @@
       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);
@@ -13626,6 +13791,31 @@
   }
 
   // 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) {
@@ -13640,7 +13830,7 @@
     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),
@@ -13652,10 +13842,12 @@
       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));
@@ -13680,6 +13872,16 @@
     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;
@@ -13714,6 +13916,15 @@
       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) {
@@ -13728,6 +13939,7 @@
       this.sessionId = createId();
       this.replayId = createId();
       this.closed = false;
+      this.ingestDisabled = false;
       this.finishedOnServer = false;
       this.startedOnServer = false;
       this.segmentIndex = 0;
@@ -13736,6 +13948,7 @@
       this.errorClipDeadlineMs = null;
       this.linkableReplayId = null;
       this.lastReplayCaptureFailure = null;
+      this.recentNetworkFailures = [];
       this.browserContext = parseBrowserContext();
       void collectBrowserContext().then((ctx) => {
         if (this.options) this.browserContext = ctx;
@@ -13757,25 +13970,59 @@
         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
                 }
               }
             );
@@ -13812,24 +14059,38 @@
       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,
@@ -13915,6 +14176,7 @@
       this.linkableReplayId = null;
       this.lastReplayCaptureFailure = null;
       this.browserContext = null;
+      this.capturing = false;
     }
     onRrwebEvent(event) {
       if (this.closed || !this.options) return;
@@ -13939,6 +14201,7 @@
       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;
@@ -14045,7 +14308,36 @@
         }
       } 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() {
@@ -14250,6 +14542,57 @@
         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) => {
@@ -14271,7 +14614,21 @@
         });
       };
       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);