@newtalaria/browser 0.1.16 → 0.1.18

package/dist/talaria.browser.iife.js

@@ -100,9 +100,46 @@
   }
 
   // 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 = [
@@ -113,18 +150,20 @@
       { 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 = "";
@@ -170,7 +209,9 @@
       osVersion,
       device,
       language: lang,
-      userAgent
+      userAgent,
+      bot: botInfo.bot,
+      ...botInfo.botName ? { botName: botInfo.botName } : {}
     };
   }
   function browserContextTags(ctx) {
@@ -179,11 +220,16 @@
       "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;
@@ -228,7 +274,7 @@
 
   // 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 {
@@ -13438,18 +13484,22 @@
   var { takeFullSnapshot } = record;
 
   // src/replay/privacy.ts
-  var SENSITIVE_QUERY = /(?:^|[?&])(token|secret|password|auth|api[_-]?key|access[_-]?token)=([^&#]*)/gi;
+  var SENSITIVE_QUERY_KEY = /^(?:token|secret|password|auth|api[_-]?key|access[_-]?token|gclid|fbclid|gcl_au|msclkid|_ga(?:_.*)?|cid|sid)$/i;
+  var SENSITIVE_QUERY_LEGACY = /(?:^|[?&])(token|secret|password|auth|api[_-]?key|access[_-]?token|gclid|fbclid|gcl_au|msclkid|_ga(?:_[^=&#]*)?|cid|sid)=([^&#]*)/gi;
+  function isSensitiveQueryKey(key) {
+    return SENSITIVE_QUERY_KEY.test(key);
+  }
   function redactUrl(raw) {
     try {
       const url = new URL(raw, typeof location !== "undefined" ? location.href : void 0);
       for (const key of [...url.searchParams.keys()]) {
-        if (/token|secret|password|auth|api[_-]?key|access[_-]?token/i.test(key)) {
+        if (isSensitiveQueryKey(key)) {
           url.searchParams.set(key, "[Filtered]");
         }
       }
       return url.toString();
     } catch {
-      return raw.replace(SENSITIVE_QUERY, (_m, name) => `${name}=[Filtered]`);
+      return raw.replace(SENSITIVE_QUERY_LEGACY, (_m, name) => `${name}=[Filtered]`);
     }
   }
   function sanitizeNetworkUrl(raw, opts) {
@@ -13546,27 +13596,40 @@
   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) {
@@ -13693,6 +13756,56 @@
     }
     return false;
   }
+  function normalizeNetworkOrigin(raw) {
+    const trimmed = (raw || "").trim();
+    if (!trimmed || trimmed === "*") return trimmed;
+    try {
+      return new URL(trimmed).origin;
+    } catch {
+      try {
+        return new URL(`https://${trimmed}`).origin;
+      } catch {
+        return trimmed.replace(/\/+$/, "");
+      }
+    }
+  }
+  function 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;
@@ -13703,17 +13816,33 @@
       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) {
@@ -13724,18 +13853,27 @@
         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 } : {}
@@ -13751,14 +13889,22 @@
       captureNetworkErrors: options.captureNetworkErrors ?? true,
       failedRequestStatusCodes: options.failedRequestStatusCodes ?? [[500, 599]],
       failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? [],
+      networkErrorOrigins: options.networkErrorOrigins ?? [],
+      pageOrigin: options.pageOrigin,
       talariaBaseUrl: options.talariaBaseUrl
     };
-    const includeQuery = options.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);
@@ -13778,27 +13924,32 @@
         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;
         }
@@ -13812,25 +13963,48 @@
       };
       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);
       };
     }
@@ -13842,20 +14016,54 @@
   }
 
   // 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) {
@@ -13863,13 +14071,11 @@
       ...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)
       }
     };
   }
@@ -13900,7 +14106,8 @@
       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 ?? []
     };
@@ -14029,12 +14236,14 @@
         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 });
             }
           },
@@ -14042,22 +14251,20 @@
             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)
               }
             );
           },
@@ -14066,20 +14273,13 @@
             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)
               }
             );
           }
@@ -14131,6 +14331,7 @@
       }
       const correlated = this.consumeCorrelatedNetworkFailure(err);
       if (correlated?.promoted) return;
+      if (correlated && correlated.party === "third_party") return;
       const mergedContext = correlated ? mergeNetworkFailureContext(context, correlated) : context;
       this.capturing = true;
       try {
@@ -14335,7 +14536,9 @@
               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: {
@@ -14611,6 +14814,13 @@
       );
     }
     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--) {
@@ -14621,6 +14831,8 @@
           existing.errorName = meta.errorName ?? existing.errorName;
           existing.aborted = meta.aborted ?? existing.aborted;
           existing.failureKind = meta.failureKind ?? existing.failureKind;
+          existing.party = meta.party ?? existing.party;
+          existing.origin = meta.origin ?? existing.origin;
           return;
         }
       }
@@ -14631,11 +14843,12 @@
       });
     }
     /**
-     * Find a recent transport failure for a bare fetch TypeError.
+     * Find a recent transport failure for a bare fetch TypeError / TimeoutError.
      * Consumes the entry so a later duplicate path cannot reuse it.
      */
     consumeCorrelatedNetworkFailure(error) {
-      if (!isLikelyNetworkFetchError(error)) return null;
+      if (!isCorrelatableTransportError(error)) return null;
+      const wantKind = isTimeoutError(error) ? "timeout" : "network";
       const now = Date.now();
       this.pruneRecentNetworkFailures(now);
       const takeAt = (index2) => {
@@ -14644,14 +14857,14 @@
       };
       for (let i = this.recentNetworkFailures.length - 1; i >= 0; i--) {
         const failure = this.recentNetworkFailures[i];
-        if (failure.aborted || failure.failureKind !== "network") continue;
+        if (failure.aborted || failure.failureKind !== wantKind) continue;
         if (failure.errorMessage && failure.errorMessage === error.message) {
           return takeAt(i);
         }
       }
       for (let i = this.recentNetworkFailures.length - 1; i >= 0; i--) {
         const failure = this.recentNetworkFailures[i];
-        if (failure.aborted || failure.failureKind !== "network") continue;
+        if (failure.aborted || failure.failureKind !== wantKind) continue;
         return takeAt(i);
       }
       return null;