@newtalaria/browser 0.1.16 → 0.1.18

package/dist/index.js

@@ -98,9 +98,46 @@ function isSdkInternalNoise(opts) {
 }
 
 // src/utils/browser_context.ts
+var BOT_RULES = [
+  { name: "Baiduspider", re: /Baiduspider/i },
+  { name: "Googlebot", re: /Googlebot/i },
+  { name: "Bingbot", re: /bingbot/i },
+  { name: "DuckDuckBot", re: /DuckDuckBot/i },
+  { name: "YandexBot", re: /Yandex(Bot|Images)/i },
+  { name: "Applebot", re: /Applebot/i },
+  { name: "facebookexternalhit", re: /facebookexternalhit|Facebot/i },
+  { name: "Twitterbot", re: /Twitterbot/i },
+  { name: "LinkedInBot", re: /LinkedInBot/i },
+  { name: "Slackbot", re: /Slackbot/i },
+  { name: "Discordbot", re: /Discordbot/i },
+  { name: "Bytespider", re: /Bytespider/i },
+  { name: "PetalBot", re: /PetalBot/i },
+  { name: "SemrushBot", re: /SemrushBot/i },
+  { name: "AhrefsBot", re: /AhrefsBot/i },
+  { name: "DotBot", re: /DotBot/i },
+  { name: "GPTBot", re: /GPTBot/i },
+  { name: "ClaudeBot", re: /ClaudeBot|anthropic-ai/i },
+  { name: "Amazonbot", re: /Amazonbot/i },
+  { name: "Sogou", re: /Sogou/i },
+  // Generic last — still mark as bot without inventing a browser name.
+  { name: "bot", re: /\b(?:bot|crawler|spider|slurp)\b/i }
+];
+function detectBot(ua) {
+  if (!ua) return { bot: false };
+  for (const rule2 of BOT_RULES) {
+    if (rule2.re.test(ua)) {
+      return {
+        bot: true,
+        botName: rule2.name === "bot" ? void 0 : rule2.name
+      };
+    }
+  }
+  return { bot: false };
+}
 function parseBrowserContext(ua = typeof navigator !== "undefined" ? navigator.userAgent : "", language = typeof navigator !== "undefined" ? navigator.language : "") {
   const userAgent = ua || "";
   const lang = language || "";
+  const botInfo = detectBot(userAgent);
   let name = "unknown";
   let version = "";
   const rules = [
@@ -111,18 +148,20 @@ function parseBrowserContext(ua = typeof navigator !== "undefined" ? navigator.u
     { name: "Chrome", re: /(?:Chrome|CriOS)\/([\d.]+)/ },
     { name: "Safari", re: /Version\/([\d.]+).*Safari/ }
   ];
-  for (const rule2 of rules) {
-    const m = userAgent.match(rule2.re);
-    if (m) {
-      name = rule2.name;
-      version = m[1] ?? "";
-      break;
+  if (!botInfo.bot) {
+    for (const rule2 of rules) {
+      const m = userAgent.match(rule2.re);
+      if (m) {
+        name = rule2.name;
+        version = m[1] ?? "";
+        break;
+      }
+    }
+    if (name === "unknown" && /iPhone|iPad|iPod/.test(userAgent) && /AppleWebKit/.test(userAgent)) {
+      name = "Safari";
+      const m = userAgent.match(/OS ([\d_]+)/);
+      if (m?.[1]) version = m[1].replace(/_/g, ".");
     }
-  }
-  if (name === "unknown" && /iPhone|iPad|iPod/.test(userAgent) && /AppleWebKit/.test(userAgent)) {
-    name = "Safari";
-    const m = userAgent.match(/OS ([\d_]+)/);
-    if (m?.[1]) version = m[1].replace(/_/g, ".");
   }
   let os = "unknown";
   let osVersion = "";
@@ -168,7 +207,9 @@ function parseBrowserContext(ua = typeof navigator !== "undefined" ? navigator.u
     osVersion,
     device,
     language: lang,
-    userAgent
+    userAgent,
+    bot: botInfo.bot,
+    ...botInfo.botName ? { botName: botInfo.botName } : {}
   };
 }
 function browserContextTags(ctx) {
@@ -177,11 +218,16 @@ function browserContextTags(ctx) {
     "browser.version": ctx.version || "unknown",
     "os.name": ctx.os,
     "os.version": ctx.osVersion || "unknown",
-    device: ctx.device
+    device: ctx.device,
+    ...ctx.bot ? {
+      bot: "true",
+      ...ctx.botName ? { "bot.name": ctx.botName } : {}
+    } : {}
   };
 }
 async function collectBrowserContext() {
   const base = parseBrowserContext();
+  if (base.bot) return base;
   const nav = typeof navigator !== "undefined" ? navigator : void 0;
   const uad = nav?.userAgentData;
   if (!uad) return base;
@@ -226,7 +272,7 @@ async function collectBrowserContext() {
 
 // src/sdk_meta.ts
 var SDK_NAME = "@newtalaria/browser";
-var SDK_VERSION = "0.1.16";
+var SDK_VERSION = "0.1.18";
 
 // src/transport/serverpod.ts
 var ServerpodTransport = class {
@@ -13436,18 +13482,22 @@ var { freezePage } = record;
 var { takeFullSnapshot } = record;
 
 // src/replay/privacy.ts
-var SENSITIVE_QUERY = /(?:^|[?&])(token|secret|password|auth|api[_-]?key|access[_-]?token)=([^&#]*)/gi;
+var SENSITIVE_QUERY_KEY = /^(?:token|secret|password|auth|api[_-]?key|access[_-]?token|gclid|fbclid|gcl_au|msclkid|_ga(?:_.*)?|cid|sid)$/i;
+var SENSITIVE_QUERY_LEGACY = /(?:^|[?&])(token|secret|password|auth|api[_-]?key|access[_-]?token|gclid|fbclid|gcl_au|msclkid|_ga(?:_[^=&#]*)?|cid|sid)=([^&#]*)/gi;
+function isSensitiveQueryKey(key) {
+  return SENSITIVE_QUERY_KEY.test(key);
+}
 function redactUrl(raw) {
   try {
     const url = new URL(raw, typeof location !== "undefined" ? location.href : void 0);
     for (const key of [...url.searchParams.keys()]) {
-      if (/token|secret|password|auth|api[_-]?key|access[_-]?token/i.test(key)) {
+      if (isSensitiveQueryKey(key)) {
         url.searchParams.set(key, "[Filtered]");
       }
     }
     return url.toString();
   } catch {
-    return raw.replace(SENSITIVE_QUERY, (_m, name) => `${name}=[Filtered]`);
+    return raw.replace(SENSITIVE_QUERY_LEGACY, (_m, name) => `${name}=[Filtered]`);
   }
 }
 function sanitizeNetworkUrl(raw, opts) {
@@ -13544,27 +13594,40 @@ function startRecorder(options) {
 function isAbortError(error) {
   return error instanceof Error && error.name === "AbortError";
 }
+function isTimeoutError(error) {
+  return error instanceof Error && error.name === "TimeoutError";
+}
 function isLikelyNetworkFetchError(error) {
   if (!(error instanceof Error)) return false;
-  if (error.name === "AbortError") return false;
+  if (error.name === "AbortError" || error.name === "TimeoutError") 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 isCorrelatableTransportError(error) {
+  return isLikelyNetworkFetchError(error) || isTimeoutError(error);
+}
 function describeUnknownError(error) {
   if (error instanceof Error) {
     return {
       errorName: error.name || "Error",
       errorMessage: (error.message || "").slice(0, 500),
-      aborted: error.name === "AbortError"
+      aborted: error.name === "AbortError",
+      timedOut: error.name === "TimeoutError"
     };
   }
   return {
     errorName: "Error",
     errorMessage: String(error).slice(0, 500),
-    aborted: false
+    aborted: false,
+    timedOut: false
   };
 }
+function classifyTransportFailure(opts) {
+  if (opts.aborted || opts.errorName === "AbortError") return "abort";
+  if (opts.timedOut || opts.errorName === "TimeoutError") return "timeout";
+  return "network";
+}
 
 // src/replay/hooks.ts
 function installVisibilityResumeHook(onResume) {
@@ -13691,6 +13754,56 @@ function urlMatchesIgnoreList(url, ignoreUrls) {
   }
   return false;
 }
+function normalizeNetworkOrigin(raw) {
+  const trimmed = (raw || "").trim();
+  if (!trimmed || trimmed === "*") return trimmed;
+  try {
+    return new URL(trimmed).origin;
+  } catch {
+    try {
+      return new URL(`https://${trimmed}`).origin;
+    } catch {
+      return trimmed.replace(/\/+$/, "");
+    }
+  }
+}
+function resolvePageOrigin(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 = resolvePageOrigin(opts.pageOrigin);
+  if (page && requestOrigin === page) return true;
+  return allow.includes(requestOrigin);
+}
+function classifyNetworkParty(requestOrigin, pageOrigin) {
+  const page = resolvePageOrigin(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;
@@ -13701,17 +13814,33 @@ function shouldPromoteFailedRequest(meta, opts) {
     opts.talariaBaseUrl
   );
   if (urlMatchesIgnoreList(meta.url || "", ignore)) return false;
+  const requestOrigin = meta.origin || resolveRequestOrigin(meta.url || "", opts.pageOrigin);
+  if (!isAllowedNetworkOrigin(requestOrigin, {
+    networkErrorOrigins: opts.networkErrorOrigins ?? [],
+    pageOrigin: opts.pageOrigin
+  })) {
+    return false;
+  }
   return true;
 }
 function shouldPromoteNetworkError(meta, opts) {
   if (!opts.captureNetworkErrors) return false;
-  if (meta.aborted) return false;
-  if (meta.failureKind !== "network") return false;
+  if (meta.aborted || meta.failureKind === "abort") return false;
+  if (meta.failureKind !== "network" && meta.failureKind !== "timeout") {
+    return false;
+  }
   const ignore = buildFailedRequestIgnoreUrls(
     opts.failedRequestIgnoreUrls,
     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) {
@@ -13722,18 +13851,27 @@ function enrichNetworkMeta(meta) {
       failureKind: meta.ok === false ? "http" : meta.failureKind
     };
   }
-  if (meta.ok === false || meta.errorName || meta.errorMessage) {
+  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
+    });
     return {
       ...meta,
-      failureKind: "network"
+      failureKind,
+      aborted: meta.aborted ?? failureKind === "abort"
     };
   }
   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 } : {}
@@ -13749,14 +13887,22 @@ function installNetworkHook(options = {}) {
     captureNetworkErrors: options.captureNetworkErrors ?? true,
     failedRequestStatusCodes: options.failedRequestStatusCodes ?? [[500, 599]],
     failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? [],
+    networkErrorOrigins: options.networkErrorOrigins ?? [],
+    pageOrigin: options.pageOrigin,
     talariaBaseUrl: options.talariaBaseUrl
   };
-  const includeQuery = options.includeNetworkUrlQuery ?? false;
+  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);
@@ -13776,27 +13922,32 @@ function installNetworkHook(options = {}) {
       const rawUrl = typeof input2 === "string" ? input2 : input2 instanceof URL ? input2.toString() : input2.url;
       try {
         const response = await originalFetch(input2, init);
+        const opaque = response.type === "opaque" || response.type === "opaqueredirect";
         handleMeta({
           method,
           rawUrl,
           url: rawUrl,
+          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) {
         const described = describeUnknownError(error);
+        const failureKind = classifyTransportFailure(described);
         handleMeta({
           method,
           rawUrl,
           url: rawUrl,
+          transport: "fetch",
           durationMs: Date.now() - started,
           ok: false,
           errorName: described.errorName,
           errorMessage: described.errorMessage,
           aborted: described.aborted,
-          failureKind: "network"
+          failureKind
         });
         throw error;
       }
@@ -13810,25 +13961,48 @@ function installNetworkHook(options = {}) {
     };
     XHR.prototype.send = function(body) {
       this.__talariaStarted = Date.now();
+      this.__talariaTimedOut = false;
+      this.__talariaAborted = false;
+      this.addEventListener(
+        "timeout",
+        () => {
+          this.__talariaTimedOut = true;
+        },
+        { once: true }
+      );
+      this.addEventListener(
+        "abort",
+        () => {
+          this.__talariaAborted = true;
+        },
+        { once: true }
+      );
       const onDone = () => {
         const status = this.status;
-        const networkFail = status === 0;
+        const transportFail = status === 0;
         const rawUrl = this.__talariaUrl ?? "";
+        const aborted = !!this.__talariaAborted;
+        const timedOut = !!this.__talariaTimedOut;
+        const failureKind = transportFail ? classifyTransportFailure({ aborted, timedOut }) : void 0;
+        const errorName = transportFail ? failureKind === "abort" ? "AbortError" : failureKind === "timeout" ? "TimeoutError" : "NetworkError" : void 0;
+        const errorMessage = transportFail ? failureKind === "abort" ? "XMLHttpRequest aborted" : failureKind === "timeout" ? "XMLHttpRequest timed out" : "XMLHttpRequest failed (status 0)" : void 0;
         handleMeta({
           method: this.__talariaMethod ?? "GET",
           rawUrl,
           url: rawUrl,
+          transport: "xhr",
           status,
           durationMs: Date.now() - (this.__talariaStarted ?? Date.now()),
-          ok: status >= 200 && status < 400,
-          ...networkFail ? {
-            failureKind: "network",
-            errorName: "NetworkError",
-            errorMessage: "XMLHttpRequest failed (status 0)"
+          ok: isHttpOkStatus(status),
+          ...transportFail ? {
+            failureKind,
+            errorName,
+            errorMessage,
+            aborted
           } : {}
         });
       };
-      this.addEventListener("loadend", onDone);
+      this.addEventListener("loadend", onDone, { once: true });
       return originalSend.call(this, body);
     };
   }
@@ -13840,20 +14014,54 @@ function installNetworkHook(options = {}) {
 }
 
 // src/client.ts
-function networkFailureExtra(failure) {
+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 } : {}
+  };
+}
+function networkFailureExtra(failure) {
+  const http = {
     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 } : {},
+    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;
+  if (typeof failure.status === "number" && failure.status > 0) {
+    http.status = failure.status;
+  }
+  if (failure.transport) http.transport = failure.transport;
+  const fail = {
+    kind: failure.failureKind ?? "network"
+  };
+  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_code: statusCode,
+    exception_class: networkExceptionClass(failure),
     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 } : {}
+    ok: failure.ok ?? false
   };
 }
 function mergeNetworkFailureContext(context, failure) {
@@ -13861,13 +14069,11 @@ function mergeNetworkFailureContext(context, failure) {
     ...context,
     tags: {
       ...context?.tags ?? {},
-      "http.method": failure.method || "GET",
-      "network.failure_kind": "network",
-      ...failure.errorName ? { "network.error_name": failure.errorName } : {}
+      ...networkFailureTags(failure)
     },
     extra: {
       ...context?.extra ?? {},
-      network: networkFailureExtra(failure)
+      ...networkFailureExtra(failure)
     }
   };
 }
@@ -13898,7 +14104,8 @@ function resolveOptions(options) {
     disableDefaultIntegrations: options.disableDefaultIntegrations ?? false,
     captureFailedRequests: options.captureFailedRequests ?? true,
     captureNetworkErrors: options.captureNetworkErrors ?? true,
-    includeNetworkUrlQuery: options.includeNetworkUrlQuery ?? false,
+    networkErrorOrigins: options.networkErrorOrigins ?? [],
+    includeNetworkUrlQuery: options.captureRequestQueryParameters ?? options.includeNetworkUrlQuery ?? false,
     failedRequestStatusCodes: options.failedRequestStatusCodes ?? [[500, 599]],
     failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? []
   };
@@ -14027,12 +14234,14 @@ var TalariaClient = class {
       installNetworkHook({
         captureFailedRequests: this.options.captureFailedRequests,
         captureNetworkErrors: this.options.captureNetworkErrors,
+        networkErrorOrigins: this.options.networkErrorOrigins,
+        pageOrigin: typeof location !== "undefined" ? location.origin : void 0,
         includeNetworkUrlQuery: this.options.includeNetworkUrlQuery,
         failedRequestStatusCodes: this.options.failedRequestStatusCodes,
         failedRequestIgnoreUrls: this.options.failedRequestIgnoreUrls,
         talariaBaseUrl: this.options.baseUrl,
         onNetwork: (meta) => {
-          if (meta.failureKind === "network" && !meta.aborted) {
+          if ((meta.failureKind === "network" || meta.failureKind === "timeout") && !meta.aborted) {
             this.rememberNetworkFailure(meta, { promoted: false });
           }
         },
@@ -14040,22 +14249,20 @@ var TalariaClient = class {
           const status = meta.status;
           const method = meta.method || "GET";
           const url = meta.url || "(unknown url)";
+          const enriched = {
+            ...meta,
+            failureKind: "http",
+            aborted: false
+          };
           void this.captureMessage(
             `HTTP ${status}: ${method} ${url}`,
             status >= 500 ? "error" : "warning",
             {
               tags: {
-                "http.status_code": String(status),
-                "http.method": method,
-                "network.failure_kind": "http"
+                ...networkFailureTags(enriched),
+                "http.status_code": String(status)
               },
-              extra: {
-                ...networkFailureExtra({
-                  ...meta,
-                  failureKind: "http",
-                  aborted: false
-                })
-              }
+              extra: networkFailureExtra(enriched)
             }
           );
         },
@@ -14064,20 +14271,13 @@ var TalariaClient = class {
           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";
+          const prefix = meta.failureKind === "timeout" ? "Timeout error" : "Network error";
           void this.captureMessage(
-            `Network error: ${method} ${url} \u2014 ${errLabel}`,
+            `${prefix}: ${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
-              })
+              tags: networkFailureTags(meta),
+              extra: networkFailureExtra(meta)
             }
           );
         }
@@ -14129,6 +14329,7 @@ var TalariaClient = class {
     }
     const correlated = this.consumeCorrelatedNetworkFailure(err);
     if (correlated?.promoted) return;
+    if (correlated && correlated.party === "third_party") return;
     const mergedContext = correlated ? mergeNetworkFailureContext(context, correlated) : context;
     this.capturing = true;
     try {
@@ -14333,7 +14534,9 @@ var TalariaClient = class {
             osVersion: this.browserContext.osVersion,
             device: this.browserContext.device,
             language: this.browserContext.language,
-            userAgent: this.browserContext.userAgent
+            userAgent: this.browserContext.userAgent,
+            bot: this.browserContext.bot,
+            ...this.browserContext.botName ? { botName: this.browserContext.botName } : {}
           }
         } : {},
         sdk: {
@@ -14609,6 +14812,13 @@ var TalariaClient = class {
     );
   }
   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--) {
@@ -14619,6 +14829,8 @@ var TalariaClient = class {
         existing.errorName = meta.errorName ?? existing.errorName;
         existing.aborted = meta.aborted ?? existing.aborted;
         existing.failureKind = meta.failureKind ?? existing.failureKind;
+        existing.party = meta.party ?? existing.party;
+        existing.origin = meta.origin ?? existing.origin;
         return;
       }
     }
@@ -14629,11 +14841,12 @@ var TalariaClient = class {
     });
   }
   /**
-   * Find a recent transport failure for a bare fetch TypeError.
+   * Find a recent transport failure for a bare fetch TypeError / TimeoutError.
    * Consumes the entry so a later duplicate path cannot reuse it.
    */
   consumeCorrelatedNetworkFailure(error) {
-    if (!isLikelyNetworkFetchError(error)) return null;
+    if (!isCorrelatableTransportError(error)) return null;
+    const wantKind = isTimeoutError(error) ? "timeout" : "network";
     const now = Date.now();
     this.pruneRecentNetworkFailures(now);
     const takeAt = (index2) => {
@@ -14642,14 +14855,14 @@ var TalariaClient = class {
     };
     for (let i = this.recentNetworkFailures.length - 1; i >= 0; i--) {
       const failure = this.recentNetworkFailures[i];
-      if (failure.aborted || failure.failureKind !== "network") continue;
+      if (failure.aborted || failure.failureKind !== wantKind) continue;
       if (failure.errorMessage && failure.errorMessage === error.message) {
         return takeAt(i);
       }
     }
     for (let i = this.recentNetworkFailures.length - 1; i >= 0; i--) {
       const failure = this.recentNetworkFailures[i];
-      if (failure.aborted || failure.failureKind !== "network") continue;
+      if (failure.aborted || failure.failureKind !== wantKind) continue;
       return takeAt(i);
     }
     return null;