recker 1.0.73 → 1.0.75-next.2e5a94f

package/dist/browser/index.mini.iife.js

@@ -136,6 +136,85 @@ var recker = (() => {
     }
     return null;
   }
+  function classifyTransportError(error) {
+    var _a2;
+    if (error instanceof ReckerError && error.classification) {
+      return error.classification;
+    }
+    if (!error || typeof error !== "object") {
+      return void 0;
+    }
+    const anyError = error;
+    const name = anyError.name || "";
+    const message = anyError.message || "";
+    const code = (_a2 = anyError.code) == null ? void 0 : _a2.toUpperCase();
+    if (name === "AbortError" || code === "ABORT_ERR" || code === "UND_ERR_ABORTED" || message.includes("aborted") || message.includes("AbortError")) {
+      return {
+        category: "queue",
+        source: "client",
+        severity: "low",
+        canRetry: true,
+        reason: "Request was aborted"
+      };
+    }
+    if (name === "TimeoutError" || code === "UND_ERR_CONNECT_TIMEOUT" || code === "UND_ERR_HEADERS_TIMEOUT" || code === "UND_ERR_BODY_TIMEOUT" || message.includes("timeout")) {
+      return {
+        category: "timeout",
+        source: "transport",
+        severity: "medium",
+        canRetry: true,
+        reason: message || "Request timed out"
+      };
+    }
+    const networkCodes = /* @__PURE__ */ new Set([
+      "ECONNRESET",
+      "ECONNREFUSED",
+      "ENOTFOUND",
+      "EPIPE",
+      "ETIMEDOUT",
+      "EHOSTUNREACH",
+      "ENETUNREACH",
+      "ENETDOWN",
+      "EAI_AGAIN"
+    ]);
+    if (code && networkCodes.has(code)) {
+      return {
+        category: "network",
+        source: "transport",
+        severity: "medium",
+        canRetry: true,
+        reason: message || `Network error (${code})`
+      };
+    }
+    if (name === "Http2Error" || message.includes("HTTP/2") || message.includes("RST_STREAM") || message.includes("GOAWAY")) {
+      return {
+        category: "protocol",
+        source: "transport",
+        severity: "medium",
+        canRetry: true,
+        reason: message || "HTTP/2 protocol error"
+      };
+    }
+    if (name === "MaxSizeExceededError" || name === "ParseError") {
+      return {
+        category: "resource",
+        source: "server",
+        severity: "low",
+        canRetry: false,
+        reason: message || "Resource limitation"
+      };
+    }
+    if (name === "ConfigurationError" || name === "ValidationError" || name === "StateError") {
+      return {
+        category: "state",
+        source: "client",
+        severity: "high",
+        canRetry: false,
+        reason: message || "Request cannot be retried"
+      };
+    }
+    return void 0;
+  }
   function isRetryableStatus(status) {
     return [408, 425, 429, 500, 502, 503, 504].includes(status);
   }
@@ -148,20 +227,30 @@ var recker = (() => {
         response;
         suggestions;
         retriable;
-        constructor(message, request7, response, suggestions = [], retriable = false) {
+        classification;
+        constructor(message, request7, response, suggestions = [], retriable = false, classification) {
           super(message);
           this.name = "ReckerError";
           this.request = request7;
           this.response = response;
           this.suggestions = suggestions;
           this.retriable = retriable;
+          this.classification = classification;
         }
       };
       HttpError = class extends ReckerError {
         status;
         statusText;
         constructor(response, request7) {
-          super(`Request failed with status code ${response.status} ${response.statusText}`, request7, response, ["Check the upstream service response body for error details.", "Inspect request headers/body to ensure they match the API contract.", "Retry if this is a transient 5xx/429 error."], isRetryableStatus(response.status));
+          const retriable = isRetryableStatus(response.status);
+          super(`Request failed with status code ${response.status} ${response.statusText}`, request7, response, ["Check the upstream service response body for error details.", "Inspect request headers/body to ensure they match the API contract.", "Retry if this is a transient 5xx/429 error."], retriable, {
+            category: "http",
+            source: "server",
+            severity: response.status >= 500 ? "high" : "medium",
+            canRetry: retriable,
+            reason: `HTTP ${response.status}`,
+            statusCode: response.status
+          });
           this.name = "HttpError";
           this.status = response.status;
           this.statusText = response.statusText;
@@ -198,7 +287,13 @@ var recker = (() => {
             "Increase the specific timeout phase or optimize the upstream response time.",
             "Reduce concurrent requests if the connection pool is exhausted."
           ];
-          super(message, request7, void 0, suggestions, true);
+          super(message, request7, void 0, suggestions, true, {
+            category: "timeout",
+            source: "transport",
+            severity: "medium",
+            canRetry: true,
+            reason: `Timeout while ${phase}`
+          });
           this.name = "TimeoutError";
           this.phase = phase;
           this.timeout = timeout ?? 0;
@@ -214,7 +309,13 @@ var recker = (() => {
             "Check proxy/VPN/firewall settings that might block the request.",
             "Retry the request or switch transport if this is transient."
           ];
-          super(message, request7, void 0, suggestions, true);
+          super(message, request7, void 0, suggestions, true, {
+            category: "network",
+            source: "transport",
+            severity: code ? "medium" : "low",
+            canRetry: true,
+            reason: code ? `Network error (${code})` : message
+          });
           this.name = "NetworkError";
           this.code = code;
         }
@@ -228,7 +329,14 @@ var recker = (() => {
           const retriable = isRetriableHttp2Error(errorCode);
           const suggestFallback = shouldFallbackToHttp1(errorCode);
           const suggestions = getHttp2ErrorSuggestions(errorCode, suggestFallback);
-          super(message, options2.request, void 0, suggestions, retriable);
+          super(message, options2.request, void 0, suggestions, retriable, {
+            category: "protocol",
+            source: "transport",
+            severity: retriable ? "medium" : "high",
+            canRetry: retriable,
+            reason: `HTTP/2 ${errorCode}`,
+            statusCode: errorCode ? Number.parseInt(String(errorCode), 10) || void 0 : void 0
+          });
           this.name = "Http2Error";
           this.errorCode = errorCode;
           this.level = options2.level ?? "stream";
@@ -245,7 +353,13 @@ var recker = (() => {
             "Increase maxResponseSize if the larger payload is expected.",
             "Add pagination/streaming to reduce payload size.",
             "Ensure the upstream is not returning unexpected large responses."
-          ], false);
+          ], false, {
+            category: "resource",
+            source: "server",
+            severity: "medium",
+            canRetry: false,
+            reason: "Response size exceeded configured max"
+          });
           this.name = "MaxSizeExceededError";
           this.maxSize = maxSize;
           this.actualSize = actualSize;
@@ -258,7 +372,13 @@ var recker = (() => {
             "Check if the abort was intentional (user-triggered or timeout).",
             "Increase timeout if the request needs more time to complete.",
             "Ensure AbortController is not being triggered prematurely."
-          ], true);
+          ], true, {
+            category: "timeout",
+            source: "client",
+            severity: "low",
+            canRetry: true,
+            reason: reason ? `Request was aborted: ${reason}` : "Request was aborted"
+          });
           this.name = "AbortError";
           this.reason = reason;
         }
@@ -272,7 +392,13 @@ var recker = (() => {
             "Verify the host and port are correct and the service is running.",
             "Check network connectivity and firewall rules.",
             "Ensure the service is accepting connections on the specified port."
-          ], (options2 == null ? void 0 : options2.retriable) ?? true);
+          ], (options2 == null ? void 0 : options2.retriable) ?? true, {
+            category: "network",
+            source: "transport",
+            severity: (options2 == null ? void 0 : options2.retriable) === false ? "high" : "medium",
+            canRetry: (options2 == null ? void 0 : options2.retriable) ?? true,
+            reason: (options2 == null ? void 0 : options2.code) ? `Connection error (${options2.code})` : "Connection error"
+          });
           this.name = "ConnectionError";
           this.host = options2 == null ? void 0 : options2.host;
           this.port = options2 == null ? void 0 : options2.port;
@@ -430,7 +556,13 @@ var recker = (() => {
             "This is typically expected during shutdown.",
             "Check if the queue was manually cleared.",
             "Retry the operation if the queue is still active."
-          ], true);
+          ], true, {
+            category: "queue",
+            source: "client",
+            severity: "low",
+            canRetry: true,
+            reason: message || "Queue was cancelled"
+          });
           this.name = "QueueCancelledError";
           this.queueName = options2 == null ? void 0 : options2.queueName;
         }
@@ -7223,6 +7355,9 @@ var recker = (() => {
         }
         remove() {
           if (this.parentNode) {
+            if (typeof this.parentNode.invalidateSelectorCacheRecursively === "function") {
+              this.parentNode.invalidateSelectorCacheRecursively();
+            }
             const children = this.parentNode.childNodes;
             this.parentNode.childNodes = children.filter((child) => {
               return this !== child;
@@ -7231,6 +7366,8 @@ var recker = (() => {
           }
           return this;
         }
+        invalidateSelectorCacheRecursively() {
+        }
         get innerText() {
           return this.rawText;
         }
@@ -7773,11 +7910,32 @@ var recker = (() => {
         voidTag;
         _attrs;
         _rawAttrs;
+        _queryCache;
         _parseOptions;
         rawTagName;
         id;
         classList;
         nodeType = type_default.ELEMENT_NODE;
+        get isSelectorCacheEnabled() {
+          var _a2;
+          return ((_a2 = this._parseOptions) == null ? void 0 : _a2.selectorCache) !== false;
+        }
+        getQueryCache() {
+          if (!this._queryCache) {
+            this._queryCache = /* @__PURE__ */ new Map();
+          }
+          return this._queryCache;
+        }
+        clearQueryCache() {
+          this._queryCache = void 0;
+        }
+        invalidateSelectorCacheRecursively() {
+          let current = this;
+          while (current) {
+            current.clearQueryCache();
+            current = current.parentNode;
+          }
+        }
         quoteAttribute(attr) {
           if (attr == null) {
             return "null";
@@ -7814,6 +7972,7 @@ var recker = (() => {
           this.childNodes = this.childNodes.filter((child) => {
             return child !== node;
           });
+          this.invalidateSelectorCacheRecursively();
           return this;
         }
         exchangeChild(oldNode, newNode) {
@@ -7824,6 +7983,7 @@ var recker = (() => {
             }
             return child;
           });
+          this.invalidateSelectorCacheRecursively();
           return this;
         }
         get tagName() {
@@ -7852,6 +8012,7 @@ var recker = (() => {
         set textContent(val) {
           const content = [new TextNode(val, this)];
           this.childNodes = content;
+          this.invalidateSelectorCacheRecursively();
         }
         get text() {
           return decode(this.rawText);
@@ -7909,6 +8070,7 @@ var recker = (() => {
           resetParent(nodes, this);
           resetParent(this.childNodes, null);
           this.childNodes = nodes;
+          this.invalidateSelectorCacheRecursively();
         }
         set_content(content, options2 = {}) {
           if (content instanceof Node) {
@@ -7921,6 +8083,7 @@ var recker = (() => {
           resetParent(this.childNodes, null);
           resetParent(content, this);
           this.childNodes = content;
+          this.invalidateSelectorCacheRecursively();
           return this;
         }
         replaceWith(...nodes) {
@@ -7945,6 +8108,7 @@ var recker = (() => {
             ...resetParent(content, parent),
             ...parent.childNodes.slice(idx + 1)
           ];
+          parent.invalidateSelectorCacheRecursively();
           return this;
         }
         get outerHTML() {
@@ -7963,6 +8127,7 @@ var recker = (() => {
               }
             }
           }
+          this.invalidateSelectorCacheRecursively();
           return this;
         }
         get structure() {
@@ -8004,6 +8169,7 @@ var recker = (() => {
             this.childNodes[o++] = node;
           });
           this.childNodes.length = o;
+          this.invalidateSelectorCacheRecursively();
           const attrs = Object.keys(this.rawAttributes).map((key) => {
             const val = this.rawAttributes[key];
             return `${key}=${JSON.stringify(val)}`;
@@ -8013,16 +8179,49 @@ var recker = (() => {
           return this;
         }
         querySelectorAll(selector) {
-          return selectAll(selector, this, {
+          if (this.isSelectorCacheEnabled) {
+            const cached = this.getQueryCache().get(selector);
+            if (cached == null ? void 0 : cached.all) {
+              return cached.all.slice();
+            }
+          }
+          const nodes = selectAll(selector, this, {
             xmlMode: false,
             adapter: matcher_default
           });
+          if (this.isSelectorCacheEnabled) {
+            const cacheEntry = this.getQueryCache().get(selector) || {};
+            cacheEntry.all = nodes;
+            if (cacheEntry.first === void 0) {
+              cacheEntry.first = nodes[0] || null;
+            }
+            this.getQueryCache().set(selector, cacheEntry);
+          }
+          return nodes;
         }
         querySelector(selector) {
-          return selectOne(selector, this, {
+          if (this.isSelectorCacheEnabled) {
+            const cached = this.getQueryCache().get(selector);
+            if ((cached == null ? void 0 : cached.first) !== void 0) {
+              return cached.first || null;
+            }
+            if (cached == null ? void 0 : cached.all) {
+              const first = cached.all[0] || null;
+              cached.first = first;
+              this.getQueryCache().set(selector, cached);
+              return first;
+            }
+          }
+          const result = selectOne(selector, this, {
             xmlMode: false,
             adapter: matcher_default
           });
+          if (this.isSelectorCacheEnabled) {
+            const cacheEntry = this.getQueryCache().get(selector) || {};
+            cacheEntry.first = result;
+            this.getQueryCache().set(selector, cacheEntry);
+          }
+          return result;
         }
         getElementsByTagName(tagName) {
           const upperCasedTagName = tagName.toUpperCase();
@@ -8083,21 +8282,6 @@ var recker = (() => {
           const mapChild = /* @__PURE__ */ new Map();
           let el = this;
           let old = null;
-          function findOne4(test, elems) {
-            let elem = null;
-            for (let i = 0, l = elems.length; i < l && !elem; i++) {
-              const el2 = elems[i];
-              if (test(el2)) {
-                elem = el2;
-              } else {
-                const child = mapChild.get(el2);
-                if (child) {
-                  elem = findOne4(test, [child]);
-                }
-              }
-            }
-            return elem;
-          }
           while (el) {
             if (old)
               mapChild.set(el, old);
@@ -8185,6 +8369,7 @@ var recker = (() => {
           if (key === "id") {
             this.id = "";
           }
+          this.invalidateSelectorCacheRecursively();
           return this;
         }
         hasAttribute(key) {
@@ -8218,6 +8403,7 @@ var recker = (() => {
           if (key === "id") {
             this.id = value;
           }
+          this.invalidateSelectorCacheRecursively();
           return this;
         }
         setAttributes(attributes) {
@@ -8233,6 +8419,7 @@ var recker = (() => {
               return name;
             return `${name}=${this.quoteAttribute(String(val))}`;
           }).join(" ");
+          this.invalidateSelectorCacheRecursively();
           return this;
         }
         insertAdjacentHTML(where, html) {
@@ -8257,11 +8444,13 @@ var recker = (() => {
           const nodes = resolveInsertable(insertable, this._parseOptions);
           resetParent(nodes, this);
           this.childNodes.unshift(...nodes);
+          this.invalidateSelectorCacheRecursively();
         }
         append(...insertable) {
           const nodes = resolveInsertable(insertable, this._parseOptions);
           resetParent(nodes, this);
           this.childNodes.push(...nodes);
+          this.invalidateSelectorCacheRecursively();
         }
         before(...insertable) {
           if (!this.parentNode)
@@ -8270,6 +8459,7 @@ var recker = (() => {
           const siblings = this.parentNode.childNodes;
           resetParent(nodes, this.parentNode);
           siblings.splice(siblings.indexOf(this), 0, ...nodes);
+          this.parentNode.invalidateSelectorCacheRecursively();
         }
         after(...insertable) {
           if (!this.parentNode)
@@ -8278,6 +8468,7 @@ var recker = (() => {
           const siblings = this.parentNode.childNodes;
           resetParent(nodes, this.parentNode);
           siblings.splice(siblings.indexOf(this) + 1, 0, ...nodes);
+          this.parentNode.invalidateSelectorCacheRecursively();
         }
         get nextSibling() {
           if (this.parentNode) {
@@ -10695,6 +10886,32 @@ var recker = (() => {
   __export(undici_exports, {
     UndiciTransport: () => UndiciTransport
   });
+  function getAbortReason2(error) {
+    return (error == null ? void 0 : error.cause) ?? (error == null ? void 0 : error.reason);
+  }
+  function isTimeoutAbortReason(reason) {
+    if (reason instanceof TimeoutError) {
+      return true;
+    }
+    if (!reason || typeof reason !== "object") {
+      return false;
+    }
+    const timeoutReason = reason;
+    return timeoutReason.name === "TimeoutError";
+  }
+  function isTotalRequestTimeoutError(error, timeoutReason, timeoutMs) {
+    if (!timeoutMs) {
+      return false;
+    }
+    if (timeoutReason !== void 0) {
+      return true;
+    }
+    const causeOrReason = getAbortReason2(error);
+    const message = error == null ? void 0 : error.message;
+    const hasTimeoutMessage = typeof message === "string" && (message.includes("Request timed out (total time exceeded)") || message.includes("timed out (total time exceeded)"));
+    const hasRequestAbortMessage = typeof message === "string" && message.toLowerCase() === "request was aborted";
+    return error instanceof TimeoutError || isTimeoutAbortReason(causeOrReason) || isTimeoutAbortReason(error) || error instanceof errors5.RequestAbortedError || hasTimeoutMessage || hasRequestAbortMessage || (error == null ? void 0 : error.code) === "ABORT_ERR" || (error == null ? void 0 : error.code) === "UND_ERR_REQUEST_TIMEOUT";
+  }
   function mapTimeoutOptions(requestTimeout, transportDefaults) {
     return {
       connectTimeout: (requestTimeout == null ? void 0 : requestTimeout.connect) ?? (requestTimeout == null ? void 0 : requestTimeout.secureConnect) ?? (transportDefaults == null ? void 0 : transportDefaults.connectTimeout),
@@ -10959,7 +11176,7 @@ var recker = (() => {
           }
         }
       });
-      undiciBodySentChannel.subscribe((message) => {
+      undiciBodySentChannel.subscribe((_message) => {
         const store = requestStorage.getStore();
         if ((store == null ? void 0 : store.hooks) && store.hooks.onRequestSent) {
           store.hooks.onRequestSent();
@@ -11216,6 +11433,9 @@ var recker = (() => {
           });
           let timeoutController;
           let timeoutId;
+          let timeoutReason;
+          let timeoutError;
+          let cancelOriginalAbortListener;
           if (!this.observability) {
             return this.dispatchFast(req, headers, currentUrl, timeouts, handleRedirectsManually, maxRedirects, followRedirects, uploadTotal);
           }
@@ -11240,22 +11460,30 @@ var recker = (() => {
               let effectiveSignal = req.signal;
               if (timeouts.totalTimeout) {
                 timeoutController = new AbortController();
+                timeoutError = new TimeoutError(req, {
+                  phase: "request",
+                  timeout: timeouts.totalTimeout
+                });
                 if (req.signal) {
                   const originalSignal = req.signal;
                   effectiveSignal = timeoutController.signal;
                   const onOriginalAbort = () => {
-                    timeoutController.abort();
+                    timeoutReason = originalSignal.reason ?? new Error("Request aborted by external signal");
+                    timeoutController.abort(timeoutReason);
                   };
                   if (originalSignal.aborted) {
-                    timeoutController.abort();
+                    timeoutReason = originalSignal.reason ?? new Error("Request aborted by external signal");
+                    timeoutController.abort(timeoutReason);
                   } else {
                     originalSignal.addEventListener("abort", onOriginalAbort, { once: true });
+                    cancelOriginalAbortListener = () => originalSignal.removeEventListener("abort", onOriginalAbort);
                   }
                 } else {
                   effectiveSignal = timeoutController.signal;
                 }
                 timeoutId = setTimeout(() => {
-                  timeoutController.abort();
+                  timeoutReason = timeoutError;
+                  timeoutController.abort(timeoutReason);
                 }, timeouts.totalTimeout);
               }
               while (true) {
@@ -11469,8 +11697,8 @@ var recker = (() => {
                   timeout: timeouts.bodyTimeout
                 });
               }
-              if (error.name === "AbortError" || error.code === "ABORT_ERR") {
-                throw new TimeoutError(req, {
+              if (isTotalRequestTimeoutError(error, timeoutReason, timeouts.totalTimeout)) {
+                throw timeoutError ?? new TimeoutError(req, {
                   phase: "request",
                   timeout: timeouts.totalTimeout
                 });
@@ -11486,6 +11714,9 @@ var recker = (() => {
               }
               throw new NetworkError(error.message, code, req);
             } finally {
+              if (typeof cancelOriginalAbortListener === "function") {
+                cancelOriginalAbortListener();
+              }
               if (timeoutId) {
                 clearTimeout(timeoutId);
               }
@@ -11496,6 +11727,9 @@ var recker = (() => {
           var _a2, _b;
           let timeoutController;
           let timeoutId;
+          let timeoutReason;
+          let timeoutError;
+          let cancelOriginalAbortListener;
           try {
             let redirectCount = 0;
             let currentMethod = req.method;
@@ -11504,22 +11738,30 @@ var recker = (() => {
             let effectiveSignal = req.signal;
             if (timeouts.totalTimeout) {
               timeoutController = new AbortController();
+              timeoutError = new TimeoutError(req, {
+                phase: "request",
+                timeout: timeouts.totalTimeout
+              });
               if (req.signal) {
                 const originalSignal = req.signal;
                 effectiveSignal = timeoutController.signal;
                 const onOriginalAbort = () => {
-                  timeoutController.abort();
+                  timeoutReason = originalSignal.reason ?? new Error("Request aborted by external signal");
+                  timeoutController.abort(timeoutReason);
                 };
                 if (originalSignal.aborted) {
-                  timeoutController.abort();
+                  timeoutReason = originalSignal.reason ?? new Error("Request aborted by external signal");
+                  timeoutController.abort(timeoutReason);
                 } else {
                   originalSignal.addEventListener("abort", onOriginalAbort, { once: true });
+                  cancelOriginalAbortListener = () => originalSignal.removeEventListener("abort", onOriginalAbort);
                 }
               } else {
                 effectiveSignal = timeoutController.signal;
               }
               timeoutId = setTimeout(() => {
-                timeoutController.abort();
+                timeoutReason = timeoutError;
+                timeoutController.abort(timeoutReason);
               }, timeouts.totalTimeout);
             }
             while (true) {
@@ -11679,8 +11921,8 @@ var recker = (() => {
                 timeout: timeouts.bodyTimeout
               });
             }
-            if (error.name === "AbortError" || error.code === "ABORT_ERR") {
-              throw new TimeoutError(req, {
+            if (isTotalRequestTimeoutError(error, timeoutReason, timeouts.totalTimeout)) {
+              throw timeoutError ?? new TimeoutError(req, {
                 phase: "request",
                 timeout: timeouts.totalTimeout
               });
@@ -11696,6 +11938,9 @@ var recker = (() => {
             }
             throw new NetworkError(error.message, code, req);
           } finally {
+            if (typeof cancelOriginalAbortListener === "function") {
+              cancelOriginalAbortListener();
+            }
             if (timeoutId) {
               clearTimeout(timeoutId);
             }
@@ -12686,6 +12931,7 @@ var recker = (() => {
     XmlRpcClient: () => XmlRpcClient,
     browserCrypto: () => browserCrypto,
     circuitBreakerPlugin: () => circuitBreakerPlugin,
+    classifyTransportError: () => classifyTransportError,
     compression: () => compression2,
     consoleLogger: () => consoleLogger,
     cookieJarPlugin: () => cookieJarPlugin,
@@ -13659,6 +13905,32 @@ var recker = (() => {
     }
   };
 
+  // dist/browser/core-runtime/request-context.js
+  var requestSeq = 0;
+  function createRequestContext(seed = {}) {
+    requestSeq += 1;
+    const requestId = `${Date.now().toString(36)}-${requestSeq.toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
+    return {
+      requestId,
+      correlationId: seed.correlationId || requestId,
+      tenant: seed.tenant,
+      policyTags: seed.policyTags ?? [],
+      policySource: seed.policySource,
+      createdAt: Date.now(),
+      traceId: seed.traceId
+    };
+  }
+  function attachRequestContext(request7, context) {
+    if (!request7) {
+      return request7;
+    }
+    request7._runtime = context;
+    return request7;
+  }
+  function getRequestContext(request7) {
+    return request7._runtime;
+  }
+
   // dist/browser/core/request.js
   function normalizeTimeout(timeout) {
     if (timeout === void 0)
@@ -13684,6 +13956,11 @@ var recker = (() => {
     followRedirects;
     http2;
     useCurl;
+    correlationId;
+    tenant;
+    policyTags;
+    policySource;
+    traceId;
     constructor(url, options2 = {}) {
       this.url = url;
       this.method = options2.method || "GET";
@@ -13700,11 +13977,17 @@ var recker = (() => {
       this.followRedirects = options2.followRedirects;
       this.http2 = options2.http2;
       this.useCurl = options2.useCurl;
+      this.correlationId = options2.correlationId;
+      this.tenant = options2.tenant;
+      this.policyTags = options2.policyTags ?? [];
+      this.policySource = options2.policySource;
+      this.traceId = options2.traceId;
     }
     withHeader(name, value) {
+      const context = getRequestContext(this);
       const newHeaders = new Headers(this.headers);
       newHeaders.set(name, value);
-      return new _HttpRequest(this.url, {
+      const request7 = new _HttpRequest(this.url, {
         method: this.method,
         headers: newHeaders,
         body: this.body,
@@ -13718,11 +14001,21 @@ var recker = (() => {
         maxRedirects: this.maxRedirects,
         followRedirects: this.followRedirects,
         http2: this.http2,
-        useCurl: this.useCurl
+        useCurl: this.useCurl,
+        correlationId: this.correlationId,
+        tenant: this.tenant,
+        policyTags: this.policyTags,
+        policySource: this.policySource,
+        traceId: this.traceId
       });
+      if (context) {
+        return attachRequestContext(request7, context);
+      }
+      return request7;
     }
     withBody(body) {
-      return new _HttpRequest(this.url, {
+      const context = getRequestContext(this);
+      const request7 = new _HttpRequest(this.url, {
         method: this.method,
         headers: this.headers,
         body,
@@ -13736,8 +14029,17 @@ var recker = (() => {
         maxRedirects: this.maxRedirects,
         followRedirects: this.followRedirects,
         http2: this.http2,
-        useCurl: this.useCurl
+        useCurl: this.useCurl,
+        correlationId: this.correlationId,
+        tenant: this.tenant,
+        policyTags: this.policyTags,
+        policySource: this.policySource,
+        traceId: this.traceId
       });
+      if (context) {
+        return attachRequestContext(request7, context);
+      }
+      return request7;
     }
   };
 
@@ -13985,6 +14287,166 @@ var recker = (() => {
     }
   };
 
+  // dist/browser/core-runtime/typed-events.js
+  function createNoopEventBus() {
+    return {
+      on: () => () => void 0,
+      emit: () => void 0
+    };
+  }
+
+  // dist/browser/core-runtime/plugin-manifest.js
+  var DEFAULT_SCOPE = "request";
+  var DEFAULT_PRIORITY = 0;
+  function attachPluginManifest(plugin, manifest) {
+    plugin.__reckerManifest = normalizeManifest(plugin, manifest);
+    return plugin;
+  }
+  function normalizePluginManifest(plugin, options2 = {}) {
+    return normalizeManifest(plugin, options2);
+  }
+  function getPluginManifest(plugin) {
+    return plugin.__reckerManifest;
+  }
+  function normalizeManifest(plugin, manifest) {
+    const pluginId = (manifest == null ? void 0 : manifest.name) || inferPluginName(plugin);
+    return {
+      name: pluginId,
+      version: (manifest == null ? void 0 : manifest.version) || "1",
+      scope: (manifest == null ? void 0 : manifest.scope) || DEFAULT_SCOPE,
+      priority: (manifest == null ? void 0 : manifest.priority) ?? DEFAULT_PRIORITY,
+      dependsOn: (manifest == null ? void 0 : manifest.dependsOn) || [],
+      setup: manifest == null ? void 0 : manifest.setup,
+      teardown: manifest == null ? void 0 : manifest.teardown
+    };
+  }
+  function inferPluginName(plugin) {
+    return plugin.name && plugin.name !== "anonymous" ? plugin.name : `plugin-${Math.random().toString(16).slice(2, 10)}`;
+  }
+  function assertUniqueName(name, existing, source) {
+    if (existing.has(name)) {
+      throw new Error(`Invalid plugin manifest: duplicate plugin name '${name}'. ${source}`);
+    }
+    existing.add(name);
+  }
+  function buildDependencyError(path, target) {
+    return `${target} -> ${path.join(" -> ")} -> ${target}`;
+  }
+  function formatSortState(names) {
+    return names.join(" -> ");
+  }
+  function toSortedPlugins(plugins) {
+    return plugins.map((plugin, registrationIndex) => ({
+      plugin,
+      manifest: normalizePluginManifest(plugin, getPluginManifest(plugin)),
+      registrationIndex
+    }));
+  }
+  function normalizePlugins(registrations) {
+    const byName = /* @__PURE__ */ new Map();
+    const seenNames = /* @__PURE__ */ new Set();
+    registrations.forEach((entry) => {
+      const manifest = entry.manifest;
+      const name = manifest.name;
+      assertUniqueName(name, seenNames, "Use explicit `manifest.name` to avoid collisions for anonymous plugin factories.");
+      byName.set(name, entry);
+    });
+    const edges = /* @__PURE__ */ new Map();
+    const indegree = /* @__PURE__ */ new Map();
+    registrations.forEach((entry) => {
+      const { name, dependsOn } = entry.manifest;
+      indegree.set(name, 0);
+      edges.set(name, /* @__PURE__ */ new Set());
+      for (const dependency of dependsOn) {
+        if (!byName.has(dependency)) {
+          throw new Error(`Invalid plugin dependency for '${name}': missing plugin '${dependency}'. Available plugins: ` + Array.from(byName.keys()).sort().join(", "));
+        }
+        edges.get(dependency).add(name);
+        indegree.set(name, (indegree.get(name) || 0) + 1);
+      }
+    });
+    const queue = [];
+    byName.forEach((_entry, name) => {
+      if ((indegree.get(name) || 0) === 0) {
+        queue.push(name);
+      }
+    });
+    const ordered = [];
+    const nextReady = (names) => names.sort((a, b) => {
+      const aMeta = byName.get(a);
+      const bMeta = byName.get(b);
+      const priorityDiff = bMeta.manifest.priority - aMeta.manifest.priority;
+      if (priorityDiff !== 0) {
+        return priorityDiff;
+      }
+      return aMeta.registrationIndex - bMeta.registrationIndex;
+    });
+    while (queue.length > 0) {
+      const current = nextReady(queue).splice(0, 1)[0];
+      const index = queue.indexOf(current);
+      if (index >= 0) {
+        queue.splice(index, 1);
+      }
+      const currentEntry = byName.get(current);
+      if (!currentEntry) {
+        continue;
+      }
+      ordered.push(currentEntry);
+      const dependents = edges.get(current);
+      if (!dependents) {
+        continue;
+      }
+      for (const dependentName of dependents) {
+        const currentDegree = (indegree.get(dependentName) || 0) - 1;
+        indegree.set(dependentName, currentDegree);
+        if (currentDegree === 0) {
+          queue.push(dependentName);
+        }
+      }
+    }
+    if (ordered.length !== registrations.length) {
+      const unresolved = Array.from(indegree.entries()).filter(([, degree]) => degree > 0).map(([name]) => name);
+      const cycle = detectCycle(unresolved, edges);
+      throw new Error(`Invalid plugin manifest: circular dependency detected. Unresolved nodes: ${formatSortState(unresolved)}. ` + (cycle ? `Detected cycle: ${cycle}.` : "Refactor dependency graph to a DAG."));
+    }
+    const debugOrder = ordered.map((entry) => `${entry.manifest.name}:${entry.manifest.scope}:${entry.manifest.priority}`);
+    return { ordered, debugOrder };
+  }
+  function detectCycle(nodes, edges) {
+    const visited = /* @__PURE__ */ new Set();
+    const inStack = /* @__PURE__ */ new Set();
+    const dfs = (node, stack) => {
+      if (inStack.has(node)) {
+        const cycleStart = stack.indexOf(node);
+        if (cycleStart >= 0) {
+          return buildDependencyError(stack.slice(cycleStart), node);
+        }
+        return null;
+      }
+      if (visited.has(node)) {
+        return null;
+      }
+      visited.add(node);
+      inStack.add(node);
+      const nextNodes = edges.get(node) || /* @__PURE__ */ new Set();
+      for (const next of nextNodes) {
+        const hit = dfs(next, [...stack, next]);
+        if (hit) {
+          return hit;
+        }
+      }
+      inStack.delete(node);
+      return null;
+    };
+    for (const node of nodes) {
+      const cycle = dfs(node, [node]);
+      if (cycle) {
+        return cycle;
+      }
+    }
+    return null;
+  }
+
   // dist/browser/utils/concurrency.js
   var DEFAULT_INTERVAL = 1 * 1e3;
   function normalizeConcurrency(options2) {
@@ -14244,6 +14706,7 @@ var recker = (() => {
 
   // dist/browser/transport/fetch.js
   init_progress();
+  init_errors();
   function parseContentLength(headers) {
     const raw = headers.get("content-length");
     if (!raw)
@@ -14251,6 +14714,19 @@ var recker = (() => {
     const parsed = parseInt(raw, 10);
     return Number.isFinite(parsed) ? parsed : void 0;
   }
+  function getAbortReason(error) {
+    return (error == null ? void 0 : error.cause) ?? (error == null ? void 0 : error.reason);
+  }
+  function isTimeoutReason(reason) {
+    if (reason instanceof TimeoutError) {
+      return true;
+    }
+    if (!reason || typeof reason !== "object") {
+      return false;
+    }
+    const timeoutReason = reason;
+    return timeoutReason.name === "TimeoutError";
+  }
   function wrapDownloadResponse(response, onProgress) {
     if (!onProgress || !response.body)
       return response;
@@ -14308,10 +14784,16 @@ var recker = (() => {
       let abortController;
       const timeoutMs = typeof req.timeout === "number" ? req.timeout : (_a2 = req.timeout) == null ? void 0 : _a2.request;
       let signal = req.signal;
+      const requestTimeoutError = timeoutMs ? new TimeoutError(req, {
+        phase: "request",
+        timeout: timeoutMs
+      }) : void 0;
       if (timeoutMs && !signal) {
         abortController = new AbortController();
         signal = abortController.signal;
-        timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+        timeoutId = setTimeout(() => {
+          timeoutControllerAbort(abortController, requestTimeoutError);
+        }, timeoutMs);
       }
       const followRedirects = req.followRedirects !== false;
       const maxRedirects = req.maxRedirects ?? 20;
@@ -14387,10 +14869,11 @@ var recker = (() => {
           return new FetchResponseWrapper(finalResponse, timings);
         }
       } catch (error) {
-        if (error.name === "AbortError" && abortController) {
-          const timeoutError = new Error(`Request timeout after ${timeoutMs}ms`);
-          timeoutError.name = "TimeoutError";
-          throw timeoutError;
+        if (timeoutMs && (error.name === "AbortError" || error.name === "TimeoutError")) {
+          const timeoutReason = getAbortReason(error);
+          if (isTimeoutReason(timeoutReason) || isTimeoutReason(getAbortReason(signal)) || abortController && isTimeoutReason(requestTimeoutError)) {
+            throw timeoutReason instanceof TimeoutError ? timeoutReason : requestTimeoutError ?? error;
+          }
         }
         throw error;
       } finally {
@@ -14399,6 +14882,15 @@ var recker = (() => {
       }
     }
   };
+  function timeoutControllerAbort(controller, reason) {
+    if (!controller.signal.aborted) {
+      if (reason) {
+        controller.abort(reason);
+      } else {
+        controller.abort();
+      }
+    }
+  }
   var FetchResponseWrapper = class _FetchResponseWrapper {
     raw;
     timings;
@@ -14667,6 +15159,13 @@ var recker = (() => {
       if (error instanceof HttpError) {
         return statusCodes.includes(error.status);
       }
+      const classification = classifyTransportError(error);
+      if (classification && classification.canRetry === false) {
+        return false;
+      }
+      if (classification) {
+        return classification.canRetry;
+      }
       if (error && typeof error === "object" && "code" in error) {
         const code = error.code;
         return code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ENOTFOUND";
@@ -14675,6 +15174,24 @@ var recker = (() => {
     };
     const shouldRetry = options2.shouldRetry || defaultShouldRetry;
     return (client) => {
+      const emitRequestRetry = (error, attempt, delayMs, req) => {
+        const eventBus = client.runtimeEventBus;
+        if (!(eventBus == null ? void 0 : eventBus.emit)) {
+          return;
+        }
+        const context = getRequestContext(req);
+        if (!context) {
+          return;
+        }
+        const classification = classifyTransportError(error);
+        eventBus.emit("request:retry", {
+          context,
+          req,
+          attempt,
+          delayMs,
+          reason: (classification == null ? void 0 : classification.reason) || (error == null ? void 0 : error.message) || "retry requested"
+        });
+      };
       const middleware = async (req, next) => {
         var _a2, _b;
         let attempt = 0;
@@ -14691,6 +15208,7 @@ var recker = (() => {
                 delayMs = calculateDelay(attempt, baseDelay, maxDelay, backoffStrategy, useJitter);
               }
               const err = new HttpError(res, req);
+              emitRequestRetry(err, attempt, delayMs, req);
               if (onRetry) {
                 onRetry(attempt, err, delayMs);
               }
@@ -14706,6 +15224,7 @@ var recker = (() => {
           } catch (error) {
             if (attempt < maxAttempts && shouldRetry(error)) {
               const delayMs = calculateDelay(attempt, baseDelay, maxDelay, backoffStrategy, useJitter);
+              emitRequestRetry(error, attempt, delayMs, req);
               if (onRetry) {
                 onRetry(attempt, error, delayMs);
               }
@@ -15945,6 +16464,7 @@ var recker = (() => {
   init_csv();
 
   // dist/browser/runner/request-runner.js
+  init_errors();
   var SimpleEmitter = class {
     listeners = /* @__PURE__ */ new Map();
     on(event, listener) {
@@ -15990,10 +16510,14 @@ var recker = (() => {
     queue = [];
     activeCount = 0;
     paused = false;
-    results = /* @__PURE__ */ new Map();
     stats = { total: 0, successful: 0, failed: 0 };
     startTime = 0;
     pendingRetries = 0;
+    isCancelled = false;
+    cancelReason = new QueueCancelledError("Request runner cancelled");
+    retryTimers = /* @__PURE__ */ new Map();
+    timeoutId;
+    abortUnsubscribe;
     constructor(options2 = {}) {
       super();
       this.concurrency = options2.concurrency || 5;
@@ -16014,49 +16538,140 @@ var recker = (() => {
       this.processNext();
     }
     async run(items, processor, options2 = {}) {
+      this.queue = [];
+      this.activeCount = 0;
+      this.pendingRetries = 0;
+      this.stats = { total: 0, successful: 0, failed: 0 };
+      this.isCancelled = false;
+      if (this.retryTimers.size > 0) {
+        for (const [, timer] of this.retryTimers) {
+          clearTimeout(timer);
+        }
+        this.retryTimers.clear();
+      }
+      if (this.timeoutId) {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = void 0;
+      }
+      if (this.abortUnsubscribe) {
+        this.abortUnsubscribe();
+        this.abortUnsubscribe = void 0;
+      }
       this.startTime = Date.now();
       this.stats = { total: items.length, successful: 0, failed: 0 };
-      this.results.clear();
-      const promises6 = items.map((item, index) => {
-        return new Promise((resolve8) => {
-          this.add(() => processor(item, index), {
-            priority: options2.priority,
-            id: String(index),
-            retries: options2.retries,
-            resolve: resolve8,
-            trackTotal: false
+      this.isCancelled = false;
+      this.cancelReason = new QueueCancelledError("Request runner cancelled", {
+        queueName: "request-runner",
+        request: void 0
+      });
+      if (options2.signal) {
+        const signal = options2.signal;
+        if (signal.aborted) {
+          const reason = signal.reason instanceof Error ? signal.reason : new QueueCancelledError("Request runner signal was aborted", {
+            queueName: "request-runner",
+            request: void 0
+          });
+          this.cancelAll(reason);
+        } else {
+          const handleAbort = () => {
+            const reason = signal.reason instanceof Error ? signal.reason : new QueueCancelledError("Request runner signal was aborted", {
+              queueName: "request-runner",
+              request: void 0
+            });
+            this.cancelAll(reason);
+          };
+          signal.addEventListener("abort", handleAbort, { once: true });
+          this.abortUnsubscribe = () => signal.removeEventListener("abort", handleAbort);
+        }
+      }
+      if (options2.deadlineMs !== void 0) {
+        const deadline = options2.deadlineMs;
+        if (deadline <= 0) {
+          this.cancelAll(new QueueCancelledError("Request runner deadline elapsed", {
+            queueName: "request-runner",
+            request: void 0
+          }));
+        } else {
+          this.timeoutId = setTimeout(() => {
+            this.cancelAll(new QueueCancelledError("Request runner deadline exceeded", {
+              queueName: "request-runner",
+              request: void 0
+            }));
+          }, deadline);
+        }
+      }
+      try {
+        const promises6 = items.map((item, index) => {
+          return new Promise((resolve8) => {
+            this.add(() => processor(item, index), {
+              priority: options2.priority,
+              id: String(index),
+              retries: options2.retries,
+              resolve: resolve8,
+              trackTotal: false
+            });
           });
         });
-      });
-      const results = await Promise.all(promises6);
-      return {
-        results,
-        stats: {
-          ...this.stats,
-          duration: Date.now() - this.startTime
+        const results = await Promise.all(promises6);
+        return {
+          results,
+          stats: {
+            ...this.stats,
+            duration: Date.now() - this.startTime
+          }
+        };
+      } finally {
+        if (this.timeoutId) {
+          clearTimeout(this.timeoutId);
+          this.timeoutId = void 0;
         }
-      };
+        if (this.abortUnsubscribe) {
+          this.abortUnsubscribe();
+          this.abortUnsubscribe = void 0;
+        }
+      }
     }
     queueTask(task) {
       this.queue.push(task);
       this.queue.sort((a, b) => b.priority - a.priority);
     }
     scheduleRetry(task, delay) {
-      this.pendingRetries++;
-      if (delay > 0) {
-        setTimeout(() => {
-          this.pendingRetries--;
-          this.queueTask(task);
-          this.processNext();
-        }, delay);
+      if (this.isCancelled) {
+        this.resolveTask(task, this.cancelReason);
         return;
       }
-      this.pendingRetries--;
-      this.queueTask(task);
-      this.processNext();
+      if (delay <= 0) {
+        this.queueTask(task);
+        this.processNext();
+        return;
+      }
+      const timerKey = `${task.id}-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+      const enqueueTask = () => {
+        this.retryTimers.delete(timerKey);
+        this.pendingRetries--;
+        if (this.isCancelled) {
+          return;
+        }
+        this.queueTask(task);
+        this.processNext();
+      };
+      this.retryTimers.set(timerKey, setTimeout(() => {
+        if (this.isCancelled) {
+          this.pendingRetries--;
+          this.retryTimers.delete(timerKey);
+          this.resolveTask(task, this.cancelReason);
+          return;
+        }
+        enqueueTask();
+      }, delay));
+      this.pendingRetries++;
     }
     async processNext() {
-      var _a2, _b;
+      var _a2;
+      if (this.isCancelled) {
+        this.resolveQueue();
+        return;
+      }
       if (this.paused || this.activeCount >= this.concurrency || this.queue.length === 0) {
         return;
       }
@@ -16071,14 +16686,17 @@ var recker = (() => {
         (_a2 = task.resolve) == null ? void 0 : _a2.call(task, result);
         this.emit("taskComplete", { task, result });
       } catch (error) {
+        if (this.isCancelled) {
+          this.resolveTask(task, this.cancelReason);
+          return;
+        }
         const remaining = task.retries ?? 0;
         if (remaining > 0) {
           task.retries = remaining - 1;
           this.emit("taskRetry", { task, error, remaining: task.retries, delay: this.retryDelay });
           this.scheduleRetry(task, this.retryDelay);
         } else {
-          this.stats.failed++;
-          (_b = task.resolve) == null ? void 0 : _b.call(task, error);
+          this.resolveTask(task, error);
           this.emit("taskError", { task, error });
         }
       } finally {
@@ -16090,6 +16708,35 @@ var recker = (() => {
         this.processNext();
       }
     }
+    cancelAll(reason) {
+      if (this.isCancelled) {
+        return;
+      }
+      this.isCancelled = true;
+      this.cancelReason = reason;
+      for (const [, timer] of this.retryTimers) {
+        clearTimeout(timer);
+      }
+      this.retryTimers.clear();
+      this.pendingRetries = 0;
+      this.resolveQueue();
+    }
+    resolveQueue() {
+      while (this.queue.length > 0) {
+        const task = this.queue.shift();
+        if (task) {
+          this.resolveTask(task, this.cancelReason);
+        }
+      }
+    }
+    resolveTask(task, error) {
+      var _a2;
+      if (!task.resolve) {
+        return;
+      }
+      this.stats.failed++;
+      (_a2 = task.resolve) == null ? void 0 : _a2.call(task, error);
+    }
     getProgress() {
       const completed = this.stats.successful + this.stats.failed;
       return {
@@ -17133,6 +17780,10 @@ var recker = (() => {
     concurrencyConfig;
     requestPool;
     maxResponseSize;
+    runtimeEventBus;
+    shouldEmitRuntimeEvents;
+    runtimeEventBusProviderAttached = false;
+    runtimeEventListenerCount = 0;
     cookieJar;
     cookieIgnoreInvalid = false;
     defaultTimeout;
@@ -17161,6 +17812,17 @@ var recker = (() => {
       this.defaultParams = ((_f = options2.defaults) == null ? void 0 : _f.params) || {};
       this.paginationConfig = options2.pagination;
       this.maxResponseSize = options2.maxResponseSize;
+      const runtimeEventBus = options2.runtimeEventBus;
+      if (runtimeEventBus) {
+        this.runtimeEventBus = {
+          on: (name, handler) => runtimeEventBus.on(name, handler),
+          emit: (name, event) => runtimeEventBus.emit(name, event)
+        };
+      } else {
+        this.runtimeEventBus = createNoopEventBus();
+      }
+      this.shouldEmitRuntimeEvents = runtimeEventBus !== void 0;
+      this.runtimeEventBusProviderAttached = runtimeEventBus !== void 0;
       this.debugEnabled = options2.debug === true;
       if (this.debugEnabled) {
         this.logger = options2.logger ?? consoleLogger;
@@ -17218,8 +17880,20 @@ var recker = (() => {
         this.transport = new FetchTransport();
         this.transportKind = "fetch";
       }
+      const registerPlugin = (plugin, manifest = {}) => {
+        const existingManifest = getPluginManifest(plugin);
+        pluginRegistrations.push(attachPluginManifest(plugin, {
+          ...existingManifest,
+          ...manifest
+        }));
+      };
+      const pluginRegistrations = [];
       if (options2.retry) {
-        retryPlugin(options2.retry)(this);
+        registerPlugin(retryPlugin(options2.retry), {
+          name: "recker:retry",
+          priority: 120,
+          scope: "request"
+        });
       }
       if (this.concurrencyConfig.max < Infinity || this.concurrencyConfig.requestsPerInterval < Infinity) {
         this.requestPool = new RequestPool({
@@ -17227,7 +17901,13 @@ var recker = (() => {
           requestsPerInterval: this.concurrencyConfig.requestsPerInterval,
           interval: this.concurrencyConfig.interval
         });
-        this.middlewares.unshift(this.requestPool.asMiddleware());
+        registerPlugin((client) => {
+          client.middlewares.unshift(this.requestPool.asMiddleware());
+        }, {
+          name: "recker:request-pool",
+          priority: 130,
+          scope: "runtime"
+        });
         if (this.debugEnabled && this.logger) {
           this.logger.debug(`Global concurrency limit: ${this.concurrencyConfig.max} concurrent requests`);
         }
@@ -17237,7 +17917,11 @@ var recker = (() => {
         }
       }
       if (options2.dedup) {
-        dedupPlugin(options2.dedup)(this);
+        registerPlugin(dedupPlugin(options2.dedup), {
+          name: "recker:dedup",
+          priority: 110,
+          scope: "request"
+        });
       }
       if (options2.cache) {
         let storage;
@@ -17248,13 +17932,31 @@ var recker = (() => {
         } else {
           storage = createDefaultCacheStorage();
         }
-        cachePlugin({
+        registerPlugin(cachePlugin({
           ...options2.cache,
           storage
-        })(this);
+        }), {
+          name: "recker:cache",
+          priority: 100,
+          scope: "request"
+        });
       }
       if (options2.plugins) {
-        options2.plugins.forEach((plugin) => plugin(this));
+        options2.plugins.forEach((plugin, index) => {
+          const existingManifest = getPluginManifest(plugin);
+          registerPlugin(plugin, {
+            name: (existingManifest == null ? void 0 : existingManifest.name) || `user-plugin:${index}`,
+            priority: (existingManifest == null ? void 0 : existingManifest.priority) ?? 90 - index,
+            scope: (existingManifest == null ? void 0 : existingManifest.scope) || "request"
+          });
+        });
+      }
+      const { ordered, debugOrder } = normalizePlugins(toSortedPlugins(pluginRegistrations));
+      ordered.forEach(({ plugin }) => {
+        plugin(this);
+      });
+      if (this.debugEnabled && this.logger) {
+        this.logger.debug(`Applied plugins in order: ${debugOrder.join(" | ")}`);
       }
       if (options2.compression) {
         const compressionMiddleware = createCompressionMiddleware(options2.compression);
@@ -17385,13 +18087,45 @@ var recker = (() => {
       return header.split(/,(?=\s*[a-zA-Z0-9_-]+=)/g).map((s) => s.trim());
     }
     async dispatch(req) {
-      if (req.useCurl && this.transportKind !== "curl") {
-        if (!this.curlTransport) {
-          this.curlTransport = createLazyCurlTransport();
+      const context = getRequestContext(req);
+      const transportStart = context ? Date.now() : 0;
+      if (context) {
+        this.runtimeEventBus.emit("transport:start", { context, req });
+      }
+      try {
+        if (req.useCurl && this.transportKind !== "curl") {
+          if (!this.curlTransport) {
+            this.curlTransport = createLazyCurlTransport();
+          }
+          const response2 = await this.curlTransport.dispatch(req);
+          if (context) {
+            this.runtimeEventBus.emit("transport:finish", {
+              context,
+              req,
+              durationMs: Date.now() - transportStart
+            });
+          }
+          return response2;
+        }
+        const response = await this.transport.dispatch(req);
+        if (context) {
+          this.runtimeEventBus.emit("transport:finish", {
+            context,
+            req,
+            durationMs: Date.now() - transportStart
+          });
+        }
+        return response;
+      } catch (error) {
+        if (context) {
+          this.runtimeEventBus.emit("transport:error", {
+            context,
+            req,
+            error: error instanceof Error ? error : new Error(String(error))
+          });
         }
-        return this.curlTransport.dispatch(req);
+        throw error;
       }
-      return this.transport.dispatch(req);
     }
     composeMiddlewares() {
       var _a2, _b;
@@ -17490,6 +18224,20 @@ var recker = (() => {
       this.canFastPath = false;
       return this;
     }
+    onRuntimeEvent(name, handler) {
+      this.shouldEmitRuntimeEvents = true;
+      this.runtimeEventListenerCount += 1;
+      const unsubscribe = this.runtimeEventBus.on(name, handler);
+      return () => {
+        unsubscribe();
+        if (this.runtimeEventListenerCount > 0) {
+          this.runtimeEventListenerCount -= 1;
+        }
+        if (!this.runtimeEventBusProviderAttached && this.runtimeEventListenerCount === 0) {
+          this.shouldEmitRuntimeEvents = false;
+        }
+      };
+    }
     buildUrl(path, requestParams) {
       const hasRequestParams = requestParams && Object.keys(requestParams).length > 0;
       const hasDefaultParams = Object.keys(this.defaultParams).length > 0;
@@ -17508,7 +18256,7 @@ var recker = (() => {
       const mergedParams = { ...this.defaultParams, ...requestParams };
       const usedParams = /* @__PURE__ */ new Set();
       if (finalPath.includes(":")) {
-        finalPath = finalPath.replace(/:([a-zA-Z0-9_]+)/g, (match, paramName) => {
+        finalPath = finalPath.replace(/:([a-zA-Z0-9_]+)/g, (_match, paramName) => {
           if (mergedParams && paramName in mergedParams) {
             usedParams.add(paramName);
             return encodeURIComponent(String(mergedParams[paramName]));
@@ -17540,16 +18288,54 @@ var recker = (() => {
       return finalUrl;
     }
     request(path, options2 = {}) {
+      var _a2, _b;
       const url = this.buildUrl(path, options2.params);
+      const canRequestMutateHeaders = (((_a2 = this.hooks.beforeRequest) == null ? void 0 : _a2.length) ?? 0) > 0 || this.middlewares.length > 0;
+      const shouldAttachContext = this.shouldEmitRuntimeEvents || !!options2.correlationId || !!options2.tenant || !!options2.traceId || !!options2.policySource || (((_b = options2.policyTags) == null ? void 0 : _b.length) ?? 0) > 0;
+      const createContextSeed = () => createRequestContext({
+        correlationId: options2.correlationId,
+        tenant: options2.tenant,
+        policyTags: options2.policyTags,
+        policySource: options2.policySource,
+        traceId: options2.traceId
+      });
       const usesFastPath = this.canFastPath && !options2.headers && !options2.timeout && !options2.signal && options2.maxResponseSize === void 0;
       if (usesFastPath) {
-        const req2 = new HttpRequest(url, {
+        let req2 = new HttpRequest(url, {
           method: options2.method || "GET",
           body: options2.body,
           headers: this.defaultHeadersObj,
           throwHttpErrors: options2.throwHttpErrors
         });
-        const responsePromise2 = this.fastHandler(req2);
+        if (shouldAttachContext) {
+          req2 = attachRequestContext(req2, createContextSeed());
+        }
+        const requestContext2 = getRequestContext(req2);
+        const startTime2 = Date.now();
+        if (requestContext2) {
+          this.runtimeEventBus.emit("request:start", { context: requestContext2, req: req2 });
+        }
+        let responsePromise2 = this.fastHandler(req2);
+        if (requestContext2) {
+          responsePromise2 = responsePromise2.then((response) => {
+            this.runtimeEventBus.emit("request:success", {
+              context: requestContext2,
+              req: req2,
+              res: response,
+              durationMs: Date.now() - startTime2
+            });
+            return response;
+          }, (error) => {
+            const requestError = error instanceof Error ? error : new Error(String(error));
+            this.runtimeEventBus.emit("request:failed", {
+              context: requestContext2,
+              req: req2,
+              error: requestError,
+              durationMs: Date.now() - startTime2
+            });
+            throw error;
+          });
+        }
         return new RequestPromise(responsePromise2);
       }
       let mergedHeaders;
@@ -17557,6 +18343,8 @@ var recker = (() => {
         mergedHeaders = new Headers(this.defaultHeadersObj);
         const optHeaders = options2.headers instanceof Headers ? options2.headers : new Headers(options2.headers);
         optHeaders.forEach((value, key) => mergedHeaders.set(key, value));
+      } else if (canRequestMutateHeaders) {
+        mergedHeaders = new Headers(this.defaultHeadersObj);
       } else {
         mergedHeaders = this.defaultHeadersObj;
       }
@@ -17589,13 +18377,41 @@ var recker = (() => {
           }
         }
       }
-      const req = new HttpRequest(url, {
+      let req = new HttpRequest(url, {
         ...options2,
         headers: mergedHeaders,
         signal,
         maxResponseSize: options2.maxResponseSize ?? this.maxResponseSize
       });
-      const responsePromise = this.handler(req);
+      if (shouldAttachContext) {
+        req = attachRequestContext(req, createContextSeed());
+      }
+      const requestContext = getRequestContext(req);
+      const startTime = Date.now();
+      if (requestContext) {
+        this.runtimeEventBus.emit("request:start", { context: requestContext, req });
+      }
+      let responsePromise = this.handler(req);
+      if (requestContext) {
+        responsePromise = responsePromise.then((response) => {
+          this.runtimeEventBus.emit("request:success", {
+            context: requestContext,
+            req,
+            res: response,
+            durationMs: Date.now() - startTime
+          });
+          return response;
+        }, (error) => {
+          const requestError = error instanceof Error ? error : new Error(String(error));
+          this.runtimeEventBus.emit("request:failed", {
+            context: requestContext,
+            req,
+            error: requestError,
+            durationMs: Date.now() - startTime
+          });
+          throw error;
+        });
+      }
       if (timeoutId || externalAbortCleanup) {
         responsePromise.finally(() => {
           if (timeoutId)
@@ -17625,6 +18441,9 @@ var recker = (() => {
       const runnerResult = await runner.run(requests, async (item) => {
         const res = await this.request(item.path, item.options);
         return mapResponse(res);
+      }, {
+        signal: options2.signal,
+        deadlineMs: options2.deadlineMs
       });
       return runnerResult;
     }
@@ -17760,7 +18579,6 @@ var recker = (() => {
     page(path, pageNumber, options2 = {}) {
       var _a2;
       const pageParam = options2.pageParam || ((_a2 = this.paginationConfig) == null ? void 0 : _a2.pageParam) || "page";
-      const url = new URL(path.startsWith("http") ? path : `http://base${path}`);
       const params = { ...options2.params, [pageParam]: pageNumber };
       return this.request(path, { ...options2, params });
     }
@@ -17972,13 +18790,11 @@ self.onmessage = async (event) => {
 };
 `;
   var WorkerTransport = class _WorkerTransport {
-    options;
     workers = [];
     workerIndex = 0;
     pendingRequests = /* @__PURE__ */ new Map();
     workerUrl;
     constructor(options2 = {}) {
-      this.options = options2;
       const poolSize = options2.poolSize ?? (typeof navigator !== "undefined" ? navigator.hardwareConcurrency : 4) ?? 4;
       const blob = new Blob([WORKER_SCRIPT], { type: "application/javascript" });
       this.workerUrl = URL.createObjectURL(blob);
@@ -18074,7 +18890,7 @@ self.onmessage = async (event) => {
       }
       this.workers = [];
       URL.revokeObjectURL(this.workerUrl);
-      for (const [id, pending] of this.pendingRequests) {
+      for (const pending of this.pendingRequests.values()) {
         pending.reject(new Error("Transport terminated"));
       }
       this.pendingRequests.clear();