@cloudflare/vitest-pool-workers 0.8.52 → 0.8.54

package/dist/worker/lib/cloudflare/mock-agent.cjs

@@ -4,9 +4,10 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/symbols.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/symbols.js
 var require_symbols = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/symbols.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/symbols.js"(exports2, module2) {
+    "use strict";
     module2.exports = {
       kClose: Symbol("close"),
       kDestroy: Symbol("destroy"),
@@ -17,7 +18,6 @@ var require_symbols = __commonJS({
       kQueue: Symbol("queue"),
       kConnect: Symbol("connect"),
       kConnecting: Symbol("connecting"),
-      kHeadersList: Symbol("headers list"),
       kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"),
       kKeepAliveMaxTimeout: Symbol("max keep alive timeout"),
       kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"),
@@ -30,6 +30,7 @@ var require_symbols = __commonJS({
       kHost: Symbol("host"),
       kNoRef: Symbol("no ref"),
       kBodyUsed: Symbol("used"),
+      kBody: Symbol("abstracted request body"),
       kRunning: Symbol("running"),
       kBlocking: Symbol("blocking"),
       kPending: Symbol("pending"),
@@ -42,6 +43,8 @@ var require_symbols = __commonJS({
       kNeedDrain: Symbol("need drain"),
       kReset: Symbol("reset"),
       kDestroyed: Symbol.for("nodejs.stream.destroyed"),
+      kResume: Symbol("resume"),
+      kOnError: Symbol("on error"),
       kMaxHeadersSize: Symbol("max headers size"),
       kRunningIdx: Symbol("running index"),
       kPendingIdx: Symbol("pending index"),
@@ -59,71 +62,67 @@ var require_symbols = __commonJS({
       kMaxRequests: Symbol("maxRequestsPerClient"),
       kProxy: Symbol("proxy agent options"),
       kCounter: Symbol("socket request counter"),
-      kInterceptors: Symbol("dispatch interceptors"),
       kMaxResponseSize: Symbol("max response size"),
       kHTTP2Session: Symbol("http2Session"),
       kHTTP2SessionState: Symbol("http2Session state"),
-      kHTTP2BuildRequest: Symbol("http2 build request"),
-      kHTTP1BuildRequest: Symbol("http1 build request"),
-      kHTTP2CopyHeaders: Symbol("http2 copy headers"),
-      kHTTPConnVersion: Symbol("http connection version"),
       kRetryHandlerDefaultRetry: Symbol("retry agent default retry"),
-      kConstruct: Symbol("constructable")
+      kConstruct: Symbol("constructable"),
+      kListeners: Symbol("listeners"),
+      kHTTPContext: Symbol("http context"),
+      kMaxConcurrentStreams: Symbol("max concurrent streams"),
+      kNoProxyAgent: Symbol("no proxy agent"),
+      kHttpProxyAgent: Symbol("http proxy agent"),
+      kHttpsProxyAgent: Symbol("https proxy agent")
     };
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/errors.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/errors.js
 var require_errors = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/errors.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/errors.js"(exports2, module2) {
     "use strict";
     var UndiciError = class extends Error {
-      constructor(message) {
-        super(message);
+      constructor(message, options) {
+        super(message, options);
         this.name = "UndiciError";
         this.code = "UND_ERR";
       }
     };
-    var ConnectTimeoutError = class _ConnectTimeoutError extends UndiciError {
+    var ConnectTimeoutError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _ConnectTimeoutError);
         this.name = "ConnectTimeoutError";
         this.message = message || "Connect Timeout Error";
         this.code = "UND_ERR_CONNECT_TIMEOUT";
       }
     };
-    var HeadersTimeoutError = class _HeadersTimeoutError extends UndiciError {
+    var HeadersTimeoutError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _HeadersTimeoutError);
         this.name = "HeadersTimeoutError";
         this.message = message || "Headers Timeout Error";
         this.code = "UND_ERR_HEADERS_TIMEOUT";
       }
     };
-    var HeadersOverflowError = class _HeadersOverflowError extends UndiciError {
+    var HeadersOverflowError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _HeadersOverflowError);
         this.name = "HeadersOverflowError";
         this.message = message || "Headers Overflow Error";
         this.code = "UND_ERR_HEADERS_OVERFLOW";
       }
     };
-    var BodyTimeoutError = class _BodyTimeoutError extends UndiciError {
+    var BodyTimeoutError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _BodyTimeoutError);
         this.name = "BodyTimeoutError";
         this.message = message || "Body Timeout Error";
         this.code = "UND_ERR_BODY_TIMEOUT";
       }
     };
-    var ResponseStatusCodeError = class _ResponseStatusCodeError extends UndiciError {
+    var ResponseStatusCodeError = class extends UndiciError {
       constructor(message, statusCode, headers, body) {
         super(message);
-        Error.captureStackTrace(this, _ResponseStatusCodeError);
         this.name = "ResponseStatusCodeError";
         this.message = message || "Response Status Code Error";
         this.code = "UND_ERR_RESPONSE_STATUS_CODE";
@@ -133,92 +132,89 @@ var require_errors = __commonJS({
         this.headers = headers;
       }
     };
-    var InvalidArgumentError = class _InvalidArgumentError extends UndiciError {
+    var InvalidArgumentError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _InvalidArgumentError);
         this.name = "InvalidArgumentError";
         this.message = message || "Invalid Argument Error";
         this.code = "UND_ERR_INVALID_ARG";
       }
     };
-    var InvalidReturnValueError = class _InvalidReturnValueError extends UndiciError {
+    var InvalidReturnValueError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _InvalidReturnValueError);
         this.name = "InvalidReturnValueError";
         this.message = message || "Invalid Return Value Error";
         this.code = "UND_ERR_INVALID_RETURN_VALUE";
       }
     };
-    var RequestAbortedError = class _RequestAbortedError extends UndiciError {
+    var AbortError = class extends UndiciError {
+      constructor(message) {
+        super(message);
+        this.name = "AbortError";
+        this.message = message || "The operation was aborted";
+      }
+    };
+    var RequestAbortedError = class extends AbortError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _RequestAbortedError);
         this.name = "AbortError";
         this.message = message || "Request aborted";
         this.code = "UND_ERR_ABORTED";
       }
     };
-    var InformationalError = class _InformationalError extends UndiciError {
+    var InformationalError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _InformationalError);
         this.name = "InformationalError";
         this.message = message || "Request information";
         this.code = "UND_ERR_INFO";
       }
     };
-    var RequestContentLengthMismatchError = class _RequestContentLengthMismatchError extends UndiciError {
+    var RequestContentLengthMismatchError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _RequestContentLengthMismatchError);
         this.name = "RequestContentLengthMismatchError";
         this.message = message || "Request body length does not match content-length header";
         this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
       }
     };
-    var ResponseContentLengthMismatchError = class _ResponseContentLengthMismatchError extends UndiciError {
+    var ResponseContentLengthMismatchError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _ResponseContentLengthMismatchError);
         this.name = "ResponseContentLengthMismatchError";
         this.message = message || "Response body length does not match content-length header";
         this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
       }
     };
-    var ClientDestroyedError = class _ClientDestroyedError extends UndiciError {
+    var ClientDestroyedError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _ClientDestroyedError);
         this.name = "ClientDestroyedError";
         this.message = message || "The client is destroyed";
         this.code = "UND_ERR_DESTROYED";
       }
     };
-    var ClientClosedError = class _ClientClosedError extends UndiciError {
+    var ClientClosedError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _ClientClosedError);
         this.name = "ClientClosedError";
         this.message = message || "The client is closed";
         this.code = "UND_ERR_CLOSED";
       }
     };
-    var SocketError = class _SocketError extends UndiciError {
+    var SocketError = class extends UndiciError {
       constructor(message, socket) {
         super(message);
-        Error.captureStackTrace(this, _SocketError);
         this.name = "SocketError";
         this.message = message || "Socket error";
         this.code = "UND_ERR_SOCKET";
         this.socket = socket;
       }
     };
-    var NotSupportedError = class _NotSupportedError extends UndiciError {
+    var NotSupportedError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _NotSupportedError);
         this.name = "NotSupportedError";
         this.message = message || "Not supported error";
         this.code = "UND_ERR_NOT_SUPPORTED";
@@ -227,34 +223,30 @@ var require_errors = __commonJS({
     var BalancedPoolMissingUpstreamError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, NotSupportedError);
         this.name = "MissingUpstreamError";
         this.message = message || "No upstream has been added to the BalancedPool";
         this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
       }
     };
-    var HTTPParserError = class _HTTPParserError extends Error {
+    var HTTPParserError = class extends Error {
       constructor(message, code, data) {
         super(message);
-        Error.captureStackTrace(this, _HTTPParserError);
         this.name = "HTTPParserError";
         this.code = code ? `HPE_${code}` : void 0;
         this.data = data ? data.toString() : void 0;
       }
     };
-    var ResponseExceededMaxSizeError = class _ResponseExceededMaxSizeError extends UndiciError {
+    var ResponseExceededMaxSizeError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _ResponseExceededMaxSizeError);
         this.name = "ResponseExceededMaxSizeError";
         this.message = message || "Response content exceeded max size";
         this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
       }
     };
-    var RequestRetryError = class _RequestRetryError extends UndiciError {
+    var RequestRetryError = class extends UndiciError {
       constructor(message, code, { headers, data }) {
         super(message);
-        Error.captureStackTrace(this, _RequestRetryError);
         this.name = "RequestRetryError";
         this.message = message || "Request retry error";
         this.code = "UND_ERR_REQ_RETRY";
@@ -263,7 +255,28 @@ var require_errors = __commonJS({
         this.headers = headers;
       }
     };
+    var ResponseError = class extends UndiciError {
+      constructor(message, code, { headers, body }) {
+        super(message);
+        this.name = "ResponseError";
+        this.message = message || "Response error";
+        this.code = "UND_ERR_RESPONSE";
+        this.statusCode = code;
+        this.body = body;
+        this.headers = headers;
+      }
+    };
+    var SecureProxyConnectionError = class extends UndiciError {
+      constructor(cause, message, options = {}) {
+        super(message, { cause, ...options });
+        this.name = "SecureProxyConnectionError";
+        this.message = message || "Secure Proxy Connection failed";
+        this.code = "UND_ERR_PRX_TLS";
+        this.cause = cause;
+      }
+    };
     module2.exports = {
+      AbortError,
       HTTPParserError,
       UndiciError,
       HeadersTimeoutError,
@@ -283,385 +296,699 @@ var require_errors = __commonJS({
       ResponseContentLengthMismatchError,
       BalancedPoolMissingUpstreamError,
       ResponseExceededMaxSizeError,
-      RequestRetryError
+      RequestRetryError,
+      ResponseError,
+      SecureProxyConnectionError
     };
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/dispatcher.js
-var require_dispatcher = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/dispatcher.js"(exports2, module2) {
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/handler/wrap-handler.js
+var require_wrap_handler = __commonJS({
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/handler/wrap-handler.js"(exports2, module2) {
     "use strict";
-    var EventEmitter = require("events");
-    var Dispatcher = class extends EventEmitter {
-      dispatch() {
-        throw new Error("not implemented");
+    var { InvalidArgumentError } = require_errors();
+    module2.exports = class WrapHandler {
+      #handler;
+      constructor(handler) {
+        this.#handler = handler;
       }
-      close() {
-        throw new Error("not implemented");
+      static wrap(handler) {
+        return handler.onRequestStart ? handler : new WrapHandler(handler);
       }
-      destroy() {
-        throw new Error("not implemented");
+      // Unwrap Interface
+      onConnect(abort, context) {
+        return this.#handler.onConnect?.(abort, context);
       }
-    };
-    module2.exports = Dispatcher;
-  }
-});
-
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/dispatcher-base.js
-var require_dispatcher_base = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/dispatcher-base.js"(exports2, module2) {
-    "use strict";
-    var Dispatcher = require_dispatcher();
-    var {
-      ClientDestroyedError,
-      ClientClosedError,
-      InvalidArgumentError
-    } = require_errors();
-    var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols();
-    var kDestroyed = Symbol("destroyed");
-    var kClosed = Symbol("closed");
-    var kOnDestroyed = Symbol("onDestroyed");
-    var kOnClosed = Symbol("onClosed");
-    var kInterceptedDispatch = Symbol("Intercepted Dispatch");
-    var DispatcherBase = class extends Dispatcher {
-      constructor() {
-        super();
-        this[kDestroyed] = false;
-        this[kOnDestroyed] = null;
-        this[kClosed] = false;
-        this[kOnClosed] = [];
+      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+        return this.#handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage);
       }
-      get destroyed() {
-        return this[kDestroyed];
+      onUpgrade(statusCode, rawHeaders, socket) {
+        return this.#handler.onUpgrade?.(statusCode, rawHeaders, socket);
       }
-      get closed() {
-        return this[kClosed];
+      onData(data) {
+        return this.#handler.onData?.(data);
       }
-      get interceptors() {
-        return this[kInterceptors];
+      onComplete(trailers) {
+        return this.#handler.onComplete?.(trailers);
       }
-      set interceptors(newInterceptors) {
-        if (newInterceptors) {
-          for (let i = newInterceptors.length - 1; i >= 0; i--) {
-            const interceptor = this[kInterceptors][i];
-            if (typeof interceptor !== "function") {
-              throw new InvalidArgumentError("interceptor must be an function");
-            }
-          }
+      onError(err) {
+        if (!this.#handler.onError) {
+          throw err;
         }
-        this[kInterceptors] = newInterceptors;
+        return this.#handler.onError?.(err);
       }
-      close(callback) {
-        if (callback === void 0) {
-          return new Promise((resolve, reject) => {
-            this.close((err, data) => {
-              return err ? reject(err) : resolve(data);
-            });
-          });
-        }
-        if (typeof callback !== "function") {
-          throw new InvalidArgumentError("invalid callback");
-        }
-        if (this[kDestroyed]) {
-          queueMicrotask(() => callback(new ClientDestroyedError(), null));
-          return;
-        }
-        if (this[kClosed]) {
-          if (this[kOnClosed]) {
-            this[kOnClosed].push(callback);
-          } else {
-            queueMicrotask(() => callback(null, null));
-          }
-          return;
-        }
-        this[kClosed] = true;
-        this[kOnClosed].push(callback);
-        const onClosed = () => {
-          const callbacks = this[kOnClosed];
-          this[kOnClosed] = null;
-          for (let i = 0; i < callbacks.length; i++) {
-            callbacks[i](null, null);
-          }
-        };
-        this[kClose]().then(() => this.destroy()).then(() => {
-          queueMicrotask(onClosed);
-        });
+      // Wrap Interface
+      onRequestStart(controller, context) {
+        this.#handler.onConnect?.((reason) => controller.abort(reason), context);
       }
-      destroy(err, callback) {
-        if (typeof err === "function") {
-          callback = err;
-          err = null;
+      onRequestUpgrade(controller, statusCode, headers, socket) {
+        const rawHeaders = [];
+        for (const [key, val] of Object.entries(headers)) {
+          rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
         }
-        if (callback === void 0) {
-          return new Promise((resolve, reject) => {
-            this.destroy(err, (err2, data) => {
-              return err2 ? (
-                /* istanbul ignore next: should never error */
-                reject(err2)
-              ) : resolve(data);
-            });
-          });
-        }
-        if (typeof callback !== "function") {
-          throw new InvalidArgumentError("invalid callback");
-        }
-        if (this[kDestroyed]) {
-          if (this[kOnDestroyed]) {
-            this[kOnDestroyed].push(callback);
-          } else {
-            queueMicrotask(() => callback(null, null));
-          }
-          return;
-        }
-        if (!err) {
-          err = new ClientDestroyedError();
-        }
-        this[kDestroyed] = true;
-        this[kOnDestroyed] = this[kOnDestroyed] || [];
-        this[kOnDestroyed].push(callback);
-        const onDestroyed = () => {
-          const callbacks = this[kOnDestroyed];
-          this[kOnDestroyed] = null;
-          for (let i = 0; i < callbacks.length; i++) {
-            callbacks[i](null, null);
-          }
-        };
-        this[kDestroy](err).then(() => {
-          queueMicrotask(onDestroyed);
-        });
+        this.#handler.onUpgrade?.(statusCode, rawHeaders, socket);
       }
-      [kInterceptedDispatch](opts, handler) {
-        if (!this[kInterceptors] || this[kInterceptors].length === 0) {
-          this[kInterceptedDispatch] = this[kDispatch];
-          return this[kDispatch](opts, handler);
+      onResponseStart(controller, statusCode, headers, statusMessage) {
+        const rawHeaders = [];
+        for (const [key, val] of Object.entries(headers)) {
+          rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
         }
-        let dispatch = this[kDispatch].bind(this);
-        for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
-          dispatch = this[kInterceptors][i](dispatch);
+        if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === false) {
+          controller.pause();
         }
-        this[kInterceptedDispatch] = dispatch;
-        return dispatch(opts, handler);
       }
-      dispatch(opts, handler) {
-        if (!handler || typeof handler !== "object") {
-          throw new InvalidArgumentError("handler must be an object");
+      onResponseData(controller, data) {
+        if (this.#handler.onData?.(data) === false) {
+          controller.pause();
         }
-        try {
-          if (!opts || typeof opts !== "object") {
-            throw new InvalidArgumentError("opts must be an object.");
-          }
-          if (this[kDestroyed] || this[kOnDestroyed]) {
-            throw new ClientDestroyedError();
-          }
-          if (this[kClosed]) {
-            throw new ClientClosedError();
-          }
-          return this[kInterceptedDispatch](opts, handler);
-        } catch (err) {
-          if (typeof handler.onError !== "function") {
-            throw new InvalidArgumentError("invalid onError method");
-          }
-          handler.onError(err);
-          return false;
+      }
+      onResponseEnd(controller, trailers) {
+        const rawTrailers = [];
+        for (const [key, val] of Object.entries(trailers)) {
+          rawTrailers.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
         }
+        this.#handler.onComplete?.(rawTrailers);
       }
-    };
-    module2.exports = DispatcherBase;
-  }
-});
-
-// src/mock-agent/pool.cjs
-var require_pool = __commonJS({
-  "src/mock-agent/pool.cjs"(exports2, module2) {
-    var assert = require("node:assert");
-    module2.exports = class Pool {
-      constructor() {
-        assert.fail("Pool is not implemented in worker");
+      onResponseError(controller, err) {
+        if (!this.#handler.onError) {
+          throw new InvalidArgumentError("invalid onError method");
+        }
+        this.#handler.onError?.(err);
       }
     };
   }
 });
 
-// src/mock-agent/dispatcher.cjs
-var require_dispatcher2 = __commonJS({
-  "src/mock-agent/dispatcher.cjs"(exports2, module2) {
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/dispatcher/dispatcher.js
+var require_dispatcher = __commonJS({
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/dispatcher/dispatcher.js"(exports2, module2) {
     "use strict";
-    var dispatcher;
-    module2.exports = {
-      getDispatcher() {
-        return dispatcher;
-      },
-      setDispatcher(newDispatcher) {
-        dispatcher = newDispatcher;
+    var EventEmitter = require("node:events");
+    var WrapHandler = require_wrap_handler();
+    var wrapInterceptor = (dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler));
+    var Dispatcher = class extends EventEmitter {
+      dispatch() {
+        throw new Error("not implemented");
+      }
+      close() {
+        throw new Error("not implemented");
+      }
+      destroy() {
+        throw new Error("not implemented");
+      }
+      compose(...args) {
+        const interceptors = Array.isArray(args[0]) ? args[0] : args;
+        let dispatch = this.dispatch.bind(this);
+        for (const interceptor of interceptors) {
+          if (interceptor == null) {
+            continue;
+          }
+          if (typeof interceptor !== "function") {
+            throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`);
+          }
+          dispatch = interceptor(dispatch);
+          dispatch = wrapInterceptor(dispatch);
+          if (dispatch == null || typeof dispatch !== "function" || dispatch.length !== 2) {
+            throw new TypeError("invalid interceptor");
+          }
+        }
+        return new Proxy(this, {
+          get: (target, key) => key === "dispatch" ? dispatch : target[key]
+        });
       }
     };
+    module2.exports = Dispatcher;
   }
 });
 
-// src/mock-agent/client.cjs
-var require_client = __commonJS({
-  "src/mock-agent/client.cjs"(exports2, module2) {
-    var assert = require("node:assert");
-    var DispatcherBase = require_dispatcher_base();
-    var { kDispatch, kClose, kDestroy } = require_symbols();
-    var { getDispatcher } = require_dispatcher2();
-    module2.exports = class Client extends DispatcherBase {
-      [kDispatch](opts, handler) {
-        const dispatcher = getDispatcher();
-        if (dispatcher === void 0) {
-          assert.fail("setDispatcher() must be called before Client#[kDispatch]()");
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/util/timers.js
+var require_timers = __commonJS({
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/util/timers.js"(exports2, module2) {
+    "use strict";
+    var fastNow = 0;
+    var RESOLUTION_MS = 1e3;
+    var TICK_MS = (RESOLUTION_MS >> 1) - 1;
+    var fastNowTimeout;
+    var kFastTimer = Symbol("kFastTimer");
+    var fastTimers = [];
+    var NOT_IN_LIST = -2;
+    var TO_BE_CLEARED = -1;
+    var PENDING = 0;
+    var ACTIVE = 1;
+    function onTick() {
+      fastNow += TICK_MS;
+      let idx = 0;
+      let len = fastTimers.length;
+      while (idx < len) {
+        const timer = fastTimers[idx];
+        if (timer._state === PENDING) {
+          timer._idleStart = fastNow - TICK_MS;
+          timer._state = ACTIVE;
+        } else if (timer._state === ACTIVE && fastNow >= timer._idleStart + timer._idleTimeout) {
+          timer._state = TO_BE_CLEARED;
+          timer._idleStart = -1;
+          timer._onTimeout(timer._timerArg);
+        }
+        if (timer._state === TO_BE_CLEARED) {
+          timer._state = NOT_IN_LIST;
+          if (--len !== 0) {
+            fastTimers[idx] = fastTimers[len];
+          }
+        } else {
+          ++idx;
         }
-        dispatcher(opts, handler);
-        return true;
       }
-      async [kClose]() {
+      fastTimers.length = len;
+      if (fastTimers.length !== 0) {
+        refreshTimeout();
       }
-      async [kDestroy](_err) {
+    }
+    function refreshTimeout() {
+      if (fastNowTimeout?.refresh) {
+        fastNowTimeout.refresh();
+      } else {
+        clearTimeout(fastNowTimeout);
+        fastNowTimeout = setTimeout(onTick, TICK_MS);
+        fastNowTimeout?.unref();
+      }
+    }
+    var FastTimer = class {
+      [kFastTimer] = true;
+      /**
+       * The state of the timer, which can be one of the following:
+       * - NOT_IN_LIST (-2)
+       * - TO_BE_CLEARED (-1)
+       * - PENDING (0)
+       * - ACTIVE (1)
+       *
+       * @type {-2|-1|0|1}
+       * @private
+       */
+      _state = NOT_IN_LIST;
+      /**
+       * The number of milliseconds to wait before calling the callback.
+       *
+       * @type {number}
+       * @private
+       */
+      _idleTimeout = -1;
+      /**
+       * The time in milliseconds when the timer was started. This value is used to
+       * calculate when the timer should expire.
+       *
+       * @type {number}
+       * @default -1
+       * @private
+       */
+      _idleStart = -1;
+      /**
+       * The function to be executed when the timer expires.
+       * @type {Function}
+       * @private
+       */
+      _onTimeout;
+      /**
+       * The argument to be passed to the callback when the timer expires.
+       *
+       * @type {*}
+       * @private
+       */
+      _timerArg;
+      /**
+       * @constructor
+       * @param {Function} callback A function to be executed after the timer
+       * expires.
+       * @param {number} delay The time, in milliseconds that the timer should wait
+       * before the specified function or code is executed.
+       * @param {*} arg
+       */
+      constructor(callback, delay, arg) {
+        this._onTimeout = callback;
+        this._idleTimeout = delay;
+        this._timerArg = arg;
+        this.refresh();
+      }
+      /**
+       * Sets the timer's start time to the current time, and reschedules the timer
+       * to call its callback at the previously specified duration adjusted to the
+       * current time.
+       * Using this on a timer that has already called its callback will reactivate
+       * the timer.
+       *
+       * @returns {void}
+       */
+      refresh() {
+        if (this._state === NOT_IN_LIST) {
+          fastTimers.push(this);
+        }
+        if (!fastNowTimeout || fastTimers.length === 1) {
+          refreshTimeout();
+        }
+        this._state = PENDING;
+      }
+      /**
+       * The `clear` method cancels the timer, preventing it from executing.
+       *
+       * @returns {void}
+       * @private
+       */
+      clear() {
+        this._state = TO_BE_CLEARED;
+        this._idleStart = -1;
       }
     };
+    module2.exports = {
+      /**
+       * The setTimeout() method sets a timer which executes a function once the
+       * timer expires.
+       * @param {Function} callback A function to be executed after the timer
+       * expires.
+       * @param {number} delay The time, in milliseconds that the timer should
+       * wait before the specified function or code is executed.
+       * @param {*} [arg] An optional argument to be passed to the callback function
+       * when the timer expires.
+       * @returns {NodeJS.Timeout|FastTimer}
+       */
+      setTimeout(callback, delay, arg) {
+        return delay <= RESOLUTION_MS ? setTimeout(callback, delay, arg) : new FastTimer(callback, delay, arg);
+      },
+      /**
+       * The clearTimeout method cancels an instantiated Timer previously created
+       * by calling setTimeout.
+       *
+       * @param {NodeJS.Timeout|FastTimer} timeout
+       */
+      clearTimeout(timeout) {
+        if (timeout[kFastTimer]) {
+          timeout.clear();
+        } else {
+          clearTimeout(timeout);
+        }
+      },
+      /**
+       * The setFastTimeout() method sets a fastTimer which executes a function once
+       * the timer expires.
+       * @param {Function} callback A function to be executed after the timer
+       * expires.
+       * @param {number} delay The time, in milliseconds that the timer should
+       * wait before the specified function or code is executed.
+       * @param {*} [arg] An optional argument to be passed to the callback function
+       * when the timer expires.
+       * @returns {FastTimer}
+       */
+      setFastTimeout(callback, delay, arg) {
+        return new FastTimer(callback, delay, arg);
+      },
+      /**
+       * The clearTimeout method cancels an instantiated FastTimer previously
+       * created by calling setFastTimeout.
+       *
+       * @param {FastTimer} timeout
+       */
+      clearFastTimeout(timeout) {
+        timeout.clear();
+      },
+      /**
+       * The now method returns the value of the internal fast timer clock.
+       *
+       * @returns {number}
+       */
+      now() {
+        return fastNow;
+      },
+      /**
+       * Trigger the onTick function to process the fastTimers array.
+       * Exported for testing purposes only.
+       * Marking as deprecated to discourage any use outside of testing.
+       * @deprecated
+       * @param {number} [delay=0] The delay in milliseconds to add to the now value.
+       */
+      tick(delay = 0) {
+        fastNow += delay - RESOLUTION_MS + 1;
+        onTick();
+        onTick();
+      },
+      /**
+       * Reset FastTimers.
+       * Exported for testing purposes only.
+       * Marking as deprecated to discourage any use outside of testing.
+       * @deprecated
+       */
+      reset() {
+        fastNow = 0;
+        fastTimers.length = 0;
+        clearTimeout(fastNowTimeout);
+        fastNowTimeout = null;
+      },
+      /**
+       * Exporting for testing purposes only.
+       * Marking as deprecated to discourage any use outside of testing.
+       * @deprecated
+       */
+      kFastTimer
+    };
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/constants.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/constants.js
 var require_constants = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/constants.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/constants.js"(exports2, module2) {
     "use strict";
+    var wellknownHeaderNames = (
+      /** @type {const} */
+      [
+        "Accept",
+        "Accept-Encoding",
+        "Accept-Language",
+        "Accept-Ranges",
+        "Access-Control-Allow-Credentials",
+        "Access-Control-Allow-Headers",
+        "Access-Control-Allow-Methods",
+        "Access-Control-Allow-Origin",
+        "Access-Control-Expose-Headers",
+        "Access-Control-Max-Age",
+        "Access-Control-Request-Headers",
+        "Access-Control-Request-Method",
+        "Age",
+        "Allow",
+        "Alt-Svc",
+        "Alt-Used",
+        "Authorization",
+        "Cache-Control",
+        "Clear-Site-Data",
+        "Connection",
+        "Content-Disposition",
+        "Content-Encoding",
+        "Content-Language",
+        "Content-Length",
+        "Content-Location",
+        "Content-Range",
+        "Content-Security-Policy",
+        "Content-Security-Policy-Report-Only",
+        "Content-Type",
+        "Cookie",
+        "Cross-Origin-Embedder-Policy",
+        "Cross-Origin-Opener-Policy",
+        "Cross-Origin-Resource-Policy",
+        "Date",
+        "Device-Memory",
+        "Downlink",
+        "ECT",
+        "ETag",
+        "Expect",
+        "Expect-CT",
+        "Expires",
+        "Forwarded",
+        "From",
+        "Host",
+        "If-Match",
+        "If-Modified-Since",
+        "If-None-Match",
+        "If-Range",
+        "If-Unmodified-Since",
+        "Keep-Alive",
+        "Last-Modified",
+        "Link",
+        "Location",
+        "Max-Forwards",
+        "Origin",
+        "Permissions-Policy",
+        "Pragma",
+        "Proxy-Authenticate",
+        "Proxy-Authorization",
+        "RTT",
+        "Range",
+        "Referer",
+        "Referrer-Policy",
+        "Refresh",
+        "Retry-After",
+        "Sec-WebSocket-Accept",
+        "Sec-WebSocket-Extensions",
+        "Sec-WebSocket-Key",
+        "Sec-WebSocket-Protocol",
+        "Sec-WebSocket-Version",
+        "Server",
+        "Server-Timing",
+        "Service-Worker-Allowed",
+        "Service-Worker-Navigation-Preload",
+        "Set-Cookie",
+        "SourceMap",
+        "Strict-Transport-Security",
+        "Supports-Loading-Mode",
+        "TE",
+        "Timing-Allow-Origin",
+        "Trailer",
+        "Transfer-Encoding",
+        "Upgrade",
+        "Upgrade-Insecure-Requests",
+        "User-Agent",
+        "Vary",
+        "Via",
+        "WWW-Authenticate",
+        "X-Content-Type-Options",
+        "X-DNS-Prefetch-Control",
+        "X-Frame-Options",
+        "X-Permitted-Cross-Domain-Policies",
+        "X-Powered-By",
+        "X-Requested-With",
+        "X-XSS-Protection"
+      ]
+    );
     var headerNameLowerCasedRecord = {};
-    var wellknownHeaderNames = [
-      "Accept",
-      "Accept-Encoding",
-      "Accept-Language",
-      "Accept-Ranges",
-      "Access-Control-Allow-Credentials",
-      "Access-Control-Allow-Headers",
-      "Access-Control-Allow-Methods",
-      "Access-Control-Allow-Origin",
-      "Access-Control-Expose-Headers",
-      "Access-Control-Max-Age",
-      "Access-Control-Request-Headers",
-      "Access-Control-Request-Method",
-      "Age",
-      "Allow",
-      "Alt-Svc",
-      "Alt-Used",
-      "Authorization",
-      "Cache-Control",
-      "Clear-Site-Data",
-      "Connection",
-      "Content-Disposition",
-      "Content-Encoding",
-      "Content-Language",
-      "Content-Length",
-      "Content-Location",
-      "Content-Range",
-      "Content-Security-Policy",
-      "Content-Security-Policy-Report-Only",
-      "Content-Type",
-      "Cookie",
-      "Cross-Origin-Embedder-Policy",
-      "Cross-Origin-Opener-Policy",
-      "Cross-Origin-Resource-Policy",
-      "Date",
-      "Device-Memory",
-      "Downlink",
-      "ECT",
-      "ETag",
-      "Expect",
-      "Expect-CT",
-      "Expires",
-      "Forwarded",
-      "From",
-      "Host",
-      "If-Match",
-      "If-Modified-Since",
-      "If-None-Match",
-      "If-Range",
-      "If-Unmodified-Since",
-      "Keep-Alive",
-      "Last-Modified",
-      "Link",
-      "Location",
-      "Max-Forwards",
-      "Origin",
-      "Permissions-Policy",
-      "Pragma",
-      "Proxy-Authenticate",
-      "Proxy-Authorization",
-      "RTT",
-      "Range",
-      "Referer",
-      "Referrer-Policy",
-      "Refresh",
-      "Retry-After",
-      "Sec-WebSocket-Accept",
-      "Sec-WebSocket-Extensions",
-      "Sec-WebSocket-Key",
-      "Sec-WebSocket-Protocol",
-      "Sec-WebSocket-Version",
-      "Server",
-      "Server-Timing",
-      "Service-Worker-Allowed",
-      "Service-Worker-Navigation-Preload",
-      "Set-Cookie",
-      "SourceMap",
-      "Strict-Transport-Security",
-      "Supports-Loading-Mode",
-      "TE",
-      "Timing-Allow-Origin",
-      "Trailer",
-      "Transfer-Encoding",
-      "Upgrade",
-      "Upgrade-Insecure-Requests",
-      "User-Agent",
-      "Vary",
-      "Via",
-      "WWW-Authenticate",
-      "X-Content-Type-Options",
-      "X-DNS-Prefetch-Control",
-      "X-Frame-Options",
-      "X-Permitted-Cross-Domain-Policies",
-      "X-Powered-By",
-      "X-Requested-With",
-      "X-XSS-Protection"
-    ];
+    Object.setPrototypeOf(headerNameLowerCasedRecord, null);
+    var wellknownHeaderNameBuffers = {};
+    Object.setPrototypeOf(wellknownHeaderNameBuffers, null);
+    function getHeaderNameAsBuffer(header) {
+      let buffer = wellknownHeaderNameBuffers[header];
+      if (buffer === void 0) {
+        buffer = Buffer.from(header);
+      }
+      return buffer;
+    }
     for (let i = 0; i < wellknownHeaderNames.length; ++i) {
       const key = wellknownHeaderNames[i];
       const lowerCasedKey = key.toLowerCase();
       headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
     }
-    Object.setPrototypeOf(headerNameLowerCasedRecord, null);
     module2.exports = {
+      wellknownHeaderNames,
+      headerNameLowerCasedRecord,
+      getHeaderNameAsBuffer
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/tree.js
+var require_tree = __commonJS({
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/tree.js"(exports2, module2) {
+    "use strict";
+    var {
       wellknownHeaderNames,
       headerNameLowerCasedRecord
+    } = require_constants();
+    var TstNode = class _TstNode {
+      /** @type {any} */
+      value = null;
+      /** @type {null | TstNode} */
+      left = null;
+      /** @type {null | TstNode} */
+      middle = null;
+      /** @type {null | TstNode} */
+      right = null;
+      /** @type {number} */
+      code;
+      /**
+       * @param {string} key
+       * @param {any} value
+       * @param {number} index
+       */
+      constructor(key, value, index) {
+        if (index === void 0 || index >= key.length) {
+          throw new TypeError("Unreachable");
+        }
+        const code = this.code = key.charCodeAt(index);
+        if (code > 127) {
+          throw new TypeError("key must be ascii string");
+        }
+        if (key.length !== ++index) {
+          this.middle = new _TstNode(key, value, index);
+        } else {
+          this.value = value;
+        }
+      }
+      /**
+       * @param {string} key
+       * @param {any} value
+       * @returns {void}
+       */
+      add(key, value) {
+        const length = key.length;
+        if (length === 0) {
+          throw new TypeError("Unreachable");
+        }
+        let index = 0;
+        let node = this;
+        while (true) {
+          const code = key.charCodeAt(index);
+          if (code > 127) {
+            throw new TypeError("key must be ascii string");
+          }
+          if (node.code === code) {
+            if (length === ++index) {
+              node.value = value;
+              break;
+            } else if (node.middle !== null) {
+              node = node.middle;
+            } else {
+              node.middle = new _TstNode(key, value, index);
+              break;
+            }
+          } else if (node.code < code) {
+            if (node.left !== null) {
+              node = node.left;
+            } else {
+              node.left = new _TstNode(key, value, index);
+              break;
+            }
+          } else if (node.right !== null) {
+            node = node.right;
+          } else {
+            node.right = new _TstNode(key, value, index);
+            break;
+          }
+        }
+      }
+      /**
+       * @param {Uint8Array} key
+       * @return {TstNode | null}
+       */
+      search(key) {
+        const keylength = key.length;
+        let index = 0;
+        let node = this;
+        while (node !== null && index < keylength) {
+          let code = key[index];
+          if (code <= 90 && code >= 65) {
+            code |= 32;
+          }
+          while (node !== null) {
+            if (code === node.code) {
+              if (keylength === ++index) {
+                return node;
+              }
+              node = node.middle;
+              break;
+            }
+            node = node.code < code ? node.left : node.right;
+          }
+        }
+        return null;
+      }
+    };
+    var TernarySearchTree = class {
+      /** @type {TstNode | null} */
+      node = null;
+      /**
+       * @param {string} key
+       * @param {any} value
+       * @returns {void}
+       * */
+      insert(key, value) {
+        if (this.node === null) {
+          this.node = new TstNode(key, value, 0);
+        } else {
+          this.node.add(key, value);
+        }
+      }
+      /**
+       * @param {Uint8Array} key
+       * @returns {any}
+       */
+      lookup(key) {
+        return this.node?.search(key)?.value ?? null;
+      }
+    };
+    var tree = new TernarySearchTree();
+    for (let i = 0; i < wellknownHeaderNames.length; ++i) {
+      const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]];
+      tree.insert(key, key);
+    }
+    module2.exports = {
+      TernarySearchTree,
+      tree
     };
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/util.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/util.js
 var require_util = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/util.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/core/util.js"(exports2, module2) {
     "use strict";
-    var assert = require("assert");
-    var { kDestroyed, kBodyUsed } = require_symbols();
-    var { IncomingMessage } = require("http");
-    var stream = require("stream");
-    var net = require("net");
-    var { InvalidArgumentError } = require_errors();
-    var { Blob } = require("buffer");
-    var nodeUtil = require("util");
-    var { stringify } = require("querystring");
+    var assert = require("node:assert");
+    var { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols();
+    var { IncomingMessage } = require("node:http");
+    var stream = require("node:stream");
+    var net = require("node:net");
+    var { Blob } = require("node:buffer");
+    var { stringify } = require("node:querystring");
+    var { EventEmitter: EE } = require("node:events");
+    var timers = require_timers();
+    var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
     var { headerNameLowerCasedRecord } = require_constants();
-    var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v));
-    function nop() {
+    var { tree } = require_tree();
+    var [nodeMajor, nodeMinor] = process.versions.node.split(".", 2).map((v) => Number(v));
+    var BodyAsyncIterable = class {
+      constructor(body) {
+        this[kBody] = body;
+        this[kBodyUsed] = false;
+      }
+      async *[Symbol.asyncIterator]() {
+        assert(!this[kBodyUsed], "disturbed");
+        this[kBodyUsed] = true;
+        yield* this[kBody];
+      }
+    };
+    function noop() {
+    }
+    function wrapRequestBody(body) {
+      if (isStream(body)) {
+        if (bodyLength(body) === 0) {
+          body.on("data", function() {
+            assert(false);
+          });
+        }
+        if (typeof body.readableDidRead !== "boolean") {
+          body[kBodyUsed] = false;
+          EE.prototype.on.call(body, "data", function() {
+            this[kBodyUsed] = true;
+          });
+        }
+        return body;
+      } else if (body && typeof body.pipeTo === "function") {
+        return new BodyAsyncIterable(body);
+      } else if (body && typeof body !== "string" && !ArrayBuffer.isView(body) && isIterable(body)) {
+        return new BodyAsyncIterable(body);
+      } else {
+        return body;
+      }
     }
     function isStream(obj) {
       return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
     }
     function isBlobLike(object) {
-      return Blob && object instanceof Blob || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
+      if (object === null) {
+        return false;
+      } else if (object instanceof Blob) {
+        return true;
+      } else if (typeof object !== "object") {
+        return false;
+      } else {
+        const sTag = object[Symbol.toStringTag];
+        return (sTag === "Blob" || sTag === "File") && ("stream" in object && typeof object.stream === "function" || "arrayBuffer" in object && typeof object.arrayBuffer === "function");
+      }
     }
-    function buildURL(url, queryParams) {
+    function serializePathWithQuery(url, queryParams) {
       if (url.includes("?") || url.includes("#")) {
         throw new Error('Query params cannot be passed when url already contains "?" or "#".');
       }
@@ -671,10 +998,17 @@ var require_util = __commonJS({
       }
       return url;
     }
+    function isValidPort(port) {
+      const value = parseInt(port, 10);
+      return value === Number(port) && value >= 0 && value <= 65535;
+    }
+    function isHttpOrHttpsPrefixed(value) {
+      return value != null && value[0] === "h" && value[1] === "t" && value[2] === "t" && value[3] === "p" && (value[4] === ":" || value[4] === "s" && value[5] === ":");
+    }
     function parseURL(url) {
       if (typeof url === "string") {
         url = new URL(url);
-        if (!/^https?:/.test(url.origin || url.protocol)) {
+        if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
           throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
         }
         return url;
@@ -682,11 +1016,8 @@ var require_util = __commonJS({
       if (!url || typeof url !== "object") {
         throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object.");
       }
-      if (!/^https?:/.test(url.origin || url.protocol)) {
-        throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
-      }
       if (!(url instanceof URL)) {
-        if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) {
+        if (url.port != null && url.port !== "" && isValidPort(url.port) === false) {
           throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer.");
         }
         if (url.path != null && typeof url.path !== "string") {
@@ -701,16 +1032,22 @@ var require_util = __commonJS({
         if (url.origin != null && typeof url.origin !== "string") {
           throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined.");
         }
+        if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
+          throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
+        }
         const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
-        let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`;
+        let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`;
         let path = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
-        if (origin.endsWith("/")) {
-          origin = origin.substring(0, origin.length - 1);
+        if (origin[origin.length - 1] === "/") {
+          origin = origin.slice(0, origin.length - 1);
         }
-        if (path && !path.startsWith("/")) {
+        if (path && path[0] !== "/") {
           path = `/${path}`;
         }
-        url = new URL(origin + path);
+        return new URL(`${origin}${path}`);
+      }
+      if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
+        throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
       }
       return url;
     }
@@ -735,7 +1072,7 @@ var require_util = __commonJS({
       if (!host) {
         return null;
       }
-      assert.strictEqual(typeof host, "string");
+      assert(typeof host === "string");
       const servername = getHostname(host);
       if (net.isIP(servername)) {
         return "";
@@ -764,12 +1101,8 @@ var require_util = __commonJS({
       }
       return null;
     }
-    function isDestroyed(stream2) {
-      return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]);
-    }
-    function isReadableAborted(stream2) {
-      const state = stream2 && stream2._readableState;
-      return isDestroyed(stream2) && state && !state.endEmitted;
+    function isDestroyed(body) {
+      return body && !!(body.destroyed || body[kDestroyed] || stream.isDestroyed?.(body));
     }
     function destroy(stream2, err) {
       if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) {
@@ -781,9 +1114,9 @@ var require_util = __commonJS({
         }
         stream2.destroy(err);
       } else if (err) {
-        process.nextTick((stream3, err2) => {
-          stream3.emit("error", err2);
-        }, stream2, err);
+        queueMicrotask(() => {
+          stream2.emit("error", err);
+        });
       }
       if (stream2.destroyed !== true) {
         stream2[kDestroyed] = true;
@@ -791,29 +1124,33 @@ var require_util = __commonJS({
     }
     var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
     function parseKeepAliveTimeout(val) {
-      const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR);
+      const m = val.match(KEEPALIVE_TIMEOUT_EXPR);
       return m ? parseInt(m[1], 10) * 1e3 : null;
     }
     function headerNameToString(value) {
-      return headerNameLowerCasedRecord[value] || value.toLowerCase();
+      return typeof value === "string" ? headerNameLowerCasedRecord[value] ?? value.toLowerCase() : tree.lookup(value) ?? value.toString("latin1").toLowerCase();
     }
-    function parseHeaders(headers, obj = {}) {
-      if (!Array.isArray(headers)) return headers;
+    function bufferToLowerCasedHeaderName(value) {
+      return tree.lookup(value) ?? value.toString("latin1").toLowerCase();
+    }
+    function parseHeaders(headers, obj) {
+      if (obj === void 0) obj = {};
       for (let i = 0; i < headers.length; i += 2) {
-        const key = headers[i].toString().toLowerCase();
+        const key = headerNameToString(headers[i]);
         let val = obj[key];
-        if (!val) {
-          if (Array.isArray(headers[i + 1])) {
-            obj[key] = headers[i + 1].map((x) => x.toString("utf8"));
-          } else {
-            obj[key] = headers[i + 1].toString("utf8");
-          }
-        } else {
-          if (!Array.isArray(val)) {
+        if (val) {
+          if (typeof val === "string") {
             val = [val];
             obj[key] = val;
           }
           val.push(headers[i + 1].toString("utf8"));
+        } else {
+          const headersValue = headers[i + 1];
+          if (typeof headersValue === "string") {
+            obj[key] = headersValue;
+          } else {
+            obj[key] = Array.isArray(headersValue) ? headersValue.map((x) => x.toString("utf8")) : headersValue.toString("utf8");
+          }
         }
       }
       if ("content-length" in obj && "content-disposition" in obj) {
@@ -822,33 +1159,48 @@ var require_util = __commonJS({
       return obj;
     }
     function parseRawHeaders(headers) {
-      const ret = [];
+      const headersLength = headers.length;
+      const ret = new Array(headersLength);
       let hasContentLength = false;
       let contentDispositionIdx = -1;
-      for (let n = 0; n < headers.length; n += 2) {
-        const key = headers[n + 0].toString();
-        const val = headers[n + 1].toString("utf8");
-        if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) {
-          ret.push(key, val);
+      let key;
+      let val;
+      let kLen = 0;
+      for (let n = 0; n < headersLength; n += 2) {
+        key = headers[n];
+        val = headers[n + 1];
+        typeof key !== "string" && (key = key.toString());
+        typeof val !== "string" && (val = val.toString("utf8"));
+        kLen = key.length;
+        if (kLen === 14 && key[7] === "-" && (key === "content-length" || key.toLowerCase() === "content-length")) {
           hasContentLength = true;
-        } else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
-          contentDispositionIdx = ret.push(key, val) - 1;
-        } else {
-          ret.push(key, val);
+        } else if (kLen === 19 && key[7] === "-" && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
+          contentDispositionIdx = n + 1;
         }
+        ret[n] = key;
+        ret[n + 1] = val;
       }
       if (hasContentLength && contentDispositionIdx !== -1) {
         ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
       }
       return ret;
     }
+    function encodeRawHeaders(headers) {
+      if (!Array.isArray(headers)) {
+        throw new TypeError("expected headers to be an array");
+      }
+      return headers.map((x) => Buffer.from(x));
+    }
     function isBuffer(buffer) {
       return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
     }
-    function validateHandler(handler, method, upgrade) {
+    function assertRequestHandler(handler, method, upgrade) {
       if (!handler || typeof handler !== "object") {
         throw new InvalidArgumentError("handler must be an object");
       }
+      if (typeof handler.onRequestStart === "function") {
+        return;
+      }
       if (typeof handler.onConnect !== "function") {
         throw new InvalidArgumentError("invalid onConnect method");
       }
@@ -875,17 +1227,7 @@ var require_util = __commonJS({
       }
     }
     function isDisturbed(body) {
-      return !!(body && (stream.isDisturbed ? stream.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body)));
-    }
-    function isErrored(body) {
-      return !!(body && (stream.isErrored ? stream.isErrored(body) : /state: 'errored'/.test(
-        nodeUtil.inspect(body)
-      )));
-    }
-    function isReadable(body) {
-      return !!(body && (stream.isReadable ? stream.isReadable(body) : /state: 'readable'/.test(
-        nodeUtil.inspect(body)
-      )));
+      return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]));
     }
     function getSocketInfo(socket) {
       return {
@@ -899,97 +1241,192 @@ var require_util = __commonJS({
         bytesRead: socket.bytesRead
       };
     }
-    async function* convertIterableToBuffer(iterable) {
-      for await (const chunk of iterable) {
-        yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      }
-    }
-    var ReadableStream;
     function ReadableStreamFrom(iterable) {
-      if (!ReadableStream) {
-        ReadableStream = require("stream/web").ReadableStream;
-      }
-      if (ReadableStream.from) {
-        return ReadableStream.from(convertIterableToBuffer(iterable));
-      }
       let iterator;
       return new ReadableStream(
         {
           async start() {
             iterator = iterable[Symbol.asyncIterator]();
           },
-          async pull(controller) {
-            const { done, value } = await iterator.next();
-            if (done) {
-              queueMicrotask(() => {
-                controller.close();
-              });
-            } else {
-              const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
-              controller.enqueue(new Uint8Array(buf));
+          pull(controller) {
+            async function pull() {
+              const { done, value } = await iterator.next();
+              if (done) {
+                queueMicrotask(() => {
+                  controller.close();
+                  controller.byobRequest?.respond(0);
+                });
+              } else {
+                const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
+                if (buf.byteLength) {
+                  controller.enqueue(new Uint8Array(buf));
+                } else {
+                  return await pull();
+                }
+              }
             }
-            return controller.desiredSize > 0;
+            return pull();
           },
-          async cancel(reason) {
+          async cancel() {
             await iterator.return();
-          }
-        },
-        0
+          },
+          type: "bytes"
+        }
       );
     }
     function isFormDataLike(object) {
       return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData";
     }
-    function throwIfAborted(signal) {
-      if (!signal) {
-        return;
-      }
-      if (typeof signal.throwIfAborted === "function") {
-        signal.throwIfAborted();
-      } else {
-        if (signal.aborted) {
-          const err = new Error("The operation was aborted");
-          err.name = "AbortError";
-          throw err;
-        }
-      }
-    }
     function addAbortListener(signal, listener) {
       if ("addEventListener" in signal) {
         signal.addEventListener("abort", listener, { once: true });
         return () => signal.removeEventListener("abort", listener);
       }
-      signal.addListener("abort", listener);
+      signal.once("abort", listener);
       return () => signal.removeListener("abort", listener);
     }
-    var hasToWellFormed = !!String.prototype.toWellFormed;
-    function toUSVString(val) {
-      if (hasToWellFormed) {
-        return `${val}`.toWellFormed();
-      } else if (nodeUtil.toUSVString) {
-        return nodeUtil.toUSVString(val);
+    function isTokenCharCode(c) {
+      switch (c) {
+        case 34:
+        case 40:
+        case 41:
+        case 44:
+        case 47:
+        case 58:
+        case 59:
+        case 60:
+        case 61:
+        case 62:
+        case 63:
+        case 64:
+        case 91:
+        case 92:
+        case 93:
+        case 123:
+        case 125:
+          return false;
+        default:
+          return c >= 33 && c <= 126;
+      }
+    }
+    function isValidHTTPToken(characters) {
+      if (characters.length === 0) {
+        return false;
       }
-      return `${val}`;
+      for (let i = 0; i < characters.length; ++i) {
+        if (!isTokenCharCode(characters.charCodeAt(i))) {
+          return false;
+        }
+      }
+      return true;
     }
+    var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
+    function isValidHeaderValue(characters) {
+      return !headerCharRegex.test(characters);
+    }
+    var rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+)?$/;
     function parseRangeHeader(range) {
       if (range == null || range === "") return { start: 0, end: null, size: null };
-      const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
+      const m = range ? range.match(rangeHeaderRegex) : null;
       return m ? {
         start: parseInt(m[1]),
         end: m[2] ? parseInt(m[2]) : null,
         size: m[3] ? parseInt(m[3]) : null
       } : null;
     }
+    function addListener(obj, name, listener) {
+      const listeners = obj[kListeners] ??= [];
+      listeners.push([name, listener]);
+      obj.on(name, listener);
+      return obj;
+    }
+    function removeAllListeners(obj) {
+      if (obj[kListeners] != null) {
+        for (const [name, listener] of obj[kListeners]) {
+          obj.removeListener(name, listener);
+        }
+        obj[kListeners] = null;
+      }
+      return obj;
+    }
+    function errorRequest(client, request, err) {
+      try {
+        request.onError(err);
+        assert(request.aborted);
+      } catch (err2) {
+        client.emit("error", err2);
+      }
+    }
+    var setupConnectTimeout = process.platform === "win32" ? (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop;
+      }
+      let s1 = null;
+      let s2 = null;
+      const fastTimer = timers.setFastTimeout(() => {
+        s1 = setImmediate(() => {
+          s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts));
+        });
+      }, opts.timeout);
+      return () => {
+        timers.clearFastTimeout(fastTimer);
+        clearImmediate(s1);
+        clearImmediate(s2);
+      };
+    } : (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop;
+      }
+      let s1 = null;
+      const fastTimer = timers.setFastTimeout(() => {
+        s1 = setImmediate(() => {
+          onConnectTimeout(socketWeakRef.deref(), opts);
+        });
+      }, opts.timeout);
+      return () => {
+        timers.clearFastTimeout(fastTimer);
+        clearImmediate(s1);
+      };
+    };
+    function onConnectTimeout(socket, opts) {
+      if (socket == null) {
+        return;
+      }
+      let message = "Connect Timeout Error";
+      if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
+        message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")},`;
+      } else {
+        message += ` (attempted address: ${opts.hostname}:${opts.port},`;
+      }
+      message += ` timeout: ${opts.timeout}ms)`;
+      destroy(socket, new ConnectTimeoutError(message));
+    }
     var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
     kEnumerableProperty.enumerable = true;
+    var normalizedMethodRecordsBase = {
+      delete: "DELETE",
+      DELETE: "DELETE",
+      get: "GET",
+      GET: "GET",
+      head: "HEAD",
+      HEAD: "HEAD",
+      options: "OPTIONS",
+      OPTIONS: "OPTIONS",
+      post: "POST",
+      POST: "POST",
+      put: "PUT",
+      PUT: "PUT"
+    };
+    var normalizedMethodRecords = {
+      ...normalizedMethodRecordsBase,
+      patch: "patch",
+      PATCH: "PATCH"
+    };
+    Object.setPrototypeOf(normalizedMethodRecordsBase, null);
+    Object.setPrototypeOf(normalizedMethodRecords, null);
     module2.exports = {
       kEnumerableProperty,
-      nop,
       isDisturbed,
-      isErrored,
-      isReadable,
-      toUSVString,
-      isReadableAborted,
       isBlobLike,
       parseOrigin,
       parseURL,
@@ -999,7 +1436,12 @@ var require_util = __commonJS({
       isAsyncIterable,
       isDestroyed,
       headerNameToString,
+      bufferToLowerCasedHeaderName,
+      addListener,
+      removeAllListeners,
+      errorRequest,
       parseRawHeaders,
+      encodeRawHeaders,
       parseHeaders,
       parseKeepAliveTimeout,
       destroy,
@@ -1007,309 +1449,359 @@ var require_util = __commonJS({
       deepClone,
       ReadableStreamFrom,
       isBuffer,
-      validateHandler,
+      assertRequestHandler,
       getSocketInfo,
       isFormDataLike,
-      buildURL,
-      throwIfAborted,
+      serializePathWithQuery,
       addAbortListener,
+      isValidHTTPToken,
+      isValidHeaderValue,
+      isTokenCharCode,
       parseRangeHeader,
+      normalizedMethodRecordsBase,
+      normalizedMethodRecords,
+      isValidPort,
+      isHttpOrHttpsPrefixed,
       nodeMajor,
       nodeMinor,
-      nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13,
-      safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"]
+      safeHTTPMethods: Object.freeze(["GET", "HEAD", "OPTIONS", "TRACE"]),
+      wrapRequestBody,
+      setupConnectTimeout
     };
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/handler/RedirectHandler.js
-var require_RedirectHandler = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module2) {
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/handler/unwrap-handler.js
+var require_unwrap_handler = __commonJS({
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/handler/unwrap-handler.js"(exports2, module2) {
     "use strict";
-    var util = require_util();
-    var { kBodyUsed } = require_symbols();
-    var assert = require("assert");
+    var { parseHeaders } = require_util();
     var { InvalidArgumentError } = require_errors();
-    var EE = require("events");
-    var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
-    var kBody = Symbol("body");
-    var BodyAsyncIterable = class {
-      constructor(body) {
-        this[kBody] = body;
-        this[kBodyUsed] = false;
+    var kResume = Symbol("resume");
+    var UnwrapController = class {
+      #paused = false;
+      #reason = null;
+      #aborted = false;
+      #abort;
+      [kResume] = null;
+      constructor(abort) {
+        this.#abort = abort;
       }
-      async *[Symbol.asyncIterator]() {
-        assert(!this[kBodyUsed], "disturbed");
-        this[kBodyUsed] = true;
-        yield* this[kBody];
+      pause() {
+        this.#paused = true;
+      }
+      resume() {
+        if (this.#paused) {
+          this.#paused = false;
+          this[kResume]?.();
+        }
+      }
+      abort(reason) {
+        if (!this.#aborted) {
+          this.#aborted = true;
+          this.#reason = reason;
+          this.#abort(reason);
+        }
+      }
+      get aborted() {
+        return this.#aborted;
+      }
+      get reason() {
+        return this.#reason;
+      }
+      get paused() {
+        return this.#paused;
       }
     };
-    var RedirectHandler = class {
-      constructor(dispatch, maxRedirections, opts, handler) {
-        if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
-          throw new InvalidArgumentError("maxRedirections must be a positive number");
-        }
-        util.validateHandler(handler, opts.method, opts.upgrade);
-        this.dispatch = dispatch;
-        this.location = null;
-        this.abort = null;
-        this.opts = { ...opts, maxRedirections: 0 };
-        this.maxRedirections = maxRedirections;
-        this.handler = handler;
-        this.history = [];
-        if (util.isStream(this.opts.body)) {
-          if (util.bodyLength(this.opts.body) === 0) {
-            this.opts.body.on("data", function() {
-              assert(false);
-            });
-          }
-          if (typeof this.opts.body.readableDidRead !== "boolean") {
-            this.opts.body[kBodyUsed] = false;
-            EE.prototype.on.call(this.opts.body, "data", function() {
-              this[kBodyUsed] = true;
-            });
-          }
-        } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") {
-          this.opts.body = new BodyAsyncIterable(this.opts.body);
-        } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) {
-          this.opts.body = new BodyAsyncIterable(this.opts.body);
+    module2.exports = class UnwrapHandler {
+      #handler;
+      #controller;
+      constructor(handler) {
+        this.#handler = handler;
+      }
+      static unwrap(handler) {
+        return !handler.onRequestStart ? handler : new UnwrapHandler(handler);
+      }
+      onConnect(abort, context) {
+        this.#controller = new UnwrapController(abort);
+        this.#handler.onRequestStart?.(this.#controller, context);
+      }
+      onUpgrade(statusCode, rawHeaders, socket) {
+        this.#handler.onRequestUpgrade?.(this.#controller, statusCode, parseHeaders(rawHeaders), socket);
+      }
+      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+        this.#controller[kResume] = resume;
+        this.#handler.onResponseStart?.(this.#controller, statusCode, parseHeaders(rawHeaders), statusMessage);
+        return !this.#controller.paused;
+      }
+      onData(data) {
+        this.#handler.onResponseData?.(this.#controller, data);
+        return !this.#controller.paused;
+      }
+      onComplete(rawTrailers) {
+        this.#handler.onResponseEnd?.(this.#controller, parseHeaders(rawTrailers));
+      }
+      onError(err) {
+        if (!this.#handler.onResponseError) {
+          throw new InvalidArgumentError("invalid onError method");
         }
+        this.#handler.onResponseError?.(this.#controller, err);
       }
-      onConnect(abort) {
-        this.abort = abort;
-        this.handler.onConnect(abort, { history: this.history });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/dispatcher/dispatcher-base.js
+var require_dispatcher_base = __commonJS({
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/dispatcher/dispatcher-base.js"(exports2, module2) {
+    "use strict";
+    var Dispatcher = require_dispatcher();
+    var UnwrapHandler = require_unwrap_handler();
+    var {
+      ClientDestroyedError,
+      ClientClosedError,
+      InvalidArgumentError
+    } = require_errors();
+    var { kDestroy, kClose, kClosed, kDestroyed, kDispatch } = require_symbols();
+    var kOnDestroyed = Symbol("onDestroyed");
+    var kOnClosed = Symbol("onClosed");
+    var DispatcherBase = class extends Dispatcher {
+      constructor() {
+        super();
+        this[kDestroyed] = false;
+        this[kOnDestroyed] = null;
+        this[kClosed] = false;
+        this[kOnClosed] = [];
       }
-      onUpgrade(statusCode, headers, socket) {
-        this.handler.onUpgrade(statusCode, headers, socket);
+      get destroyed() {
+        return this[kDestroyed];
       }
-      onError(error) {
-        this.handler.onError(error);
+      get closed() {
+        return this[kClosed];
       }
-      onHeaders(statusCode, headers, resume, statusText) {
-        this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
-        if (this.opts.origin) {
-          this.history.push(new URL(this.opts.path, this.opts.origin));
+      close(callback) {
+        if (callback === void 0) {
+          return new Promise((resolve, reject) => {
+            this.close((err, data) => {
+              return err ? reject(err) : resolve(data);
+            });
+          });
+        }
+        if (typeof callback !== "function") {
+          throw new InvalidArgumentError("invalid callback");
+        }
+        if (this[kDestroyed]) {
+          queueMicrotask(() => callback(new ClientDestroyedError(), null));
+          return;
         }
-        if (!this.location) {
-          return this.handler.onHeaders(statusCode, headers, resume, statusText);
+        if (this[kClosed]) {
+          if (this[kOnClosed]) {
+            this[kOnClosed].push(callback);
+          } else {
+            queueMicrotask(() => callback(null, null));
+          }
+          return;
         }
-        const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path = search ? `${pathname}${search}` : pathname;
-        this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
-        this.opts.path = path;
-        this.opts.origin = origin;
-        this.opts.maxRedirections = 0;
-        this.opts.query = null;
-        if (statusCode === 303 && this.opts.method !== "HEAD") {
-          this.opts.method = "GET";
-          this.opts.body = null;
+        this[kClosed] = true;
+        this[kOnClosed].push(callback);
+        const onClosed = () => {
+          const callbacks = this[kOnClosed];
+          this[kOnClosed] = null;
+          for (let i = 0; i < callbacks.length; i++) {
+            callbacks[i](null, null);
+          }
+        };
+        this[kClose]().then(() => this.destroy()).then(() => {
+          queueMicrotask(onClosed);
+        });
+      }
+      destroy(err, callback) {
+        if (typeof err === "function") {
+          callback = err;
+          err = null;
+        }
+        if (callback === void 0) {
+          return new Promise((resolve, reject) => {
+            this.destroy(err, (err2, data) => {
+              return err2 ? (
+                /* istanbul ignore next: should never error */
+                reject(err2)
+              ) : resolve(data);
+            });
+          });
         }
-      }
-      onData(chunk) {
-        if (this.location) {
-        } else {
-          return this.handler.onData(chunk);
+        if (typeof callback !== "function") {
+          throw new InvalidArgumentError("invalid callback");
         }
-      }
-      onComplete(trailers) {
-        if (this.location) {
-          this.location = null;
-          this.abort = null;
-          this.dispatch(this.opts, this);
-        } else {
-          this.handler.onComplete(trailers);
+        if (this[kDestroyed]) {
+          if (this[kOnDestroyed]) {
+            this[kOnDestroyed].push(callback);
+          } else {
+            queueMicrotask(() => callback(null, null));
+          }
+          return;
         }
-      }
-      onBodySent(chunk) {
-        if (this.handler.onBodySent) {
-          this.handler.onBodySent(chunk);
+        if (!err) {
+          err = new ClientDestroyedError();
         }
+        this[kDestroyed] = true;
+        this[kOnDestroyed] = this[kOnDestroyed] || [];
+        this[kOnDestroyed].push(callback);
+        const onDestroyed = () => {
+          const callbacks = this[kOnDestroyed];
+          this[kOnDestroyed] = null;
+          for (let i = 0; i < callbacks.length; i++) {
+            callbacks[i](null, null);
+          }
+        };
+        this[kDestroy](err).then(() => {
+          queueMicrotask(onDestroyed);
+        });
       }
-    };
-    function parseLocation(statusCode, headers) {
-      if (redirectableStatusCodes.indexOf(statusCode) === -1) {
-        return null;
-      }
-      for (let i = 0; i < headers.length; i += 2) {
-        if (headers[i].toString().toLowerCase() === "location") {
-          return headers[i + 1];
+      dispatch(opts, handler) {
+        if (!handler || typeof handler !== "object") {
+          throw new InvalidArgumentError("handler must be an object");
         }
-      }
-    }
-    function shouldRemoveHeader(header, removeContent, unknownOrigin) {
-      if (header.length === 4) {
-        return util.headerNameToString(header) === "host";
-      }
-      if (removeContent && util.headerNameToString(header).startsWith("content-")) {
-        return true;
-      }
-      if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
-        const name = util.headerNameToString(header);
-        return name === "authorization" || name === "cookie" || name === "proxy-authorization";
-      }
-      return false;
-    }
-    function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
-      const ret = [];
-      if (Array.isArray(headers)) {
-        for (let i = 0; i < headers.length; i += 2) {
-          if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
-            ret.push(headers[i], headers[i + 1]);
+        handler = UnwrapHandler.unwrap(handler);
+        try {
+          if (!opts || typeof opts !== "object") {
+            throw new InvalidArgumentError("opts must be an object.");
           }
-        }
-      } else if (headers && typeof headers === "object") {
-        for (const key of Object.keys(headers)) {
-          if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
-            ret.push(key, headers[key]);
+          if (this[kDestroyed] || this[kOnDestroyed]) {
+            throw new ClientDestroyedError();
+          }
+          if (this[kClosed]) {
+            throw new ClientClosedError();
+          }
+          return this[kDispatch](opts, handler);
+        } catch (err) {
+          if (typeof handler.onError !== "function") {
+            throw err;
           }
+          handler.onError(err);
+          return false;
         }
-      } else {
-        assert(headers == null, "headers must be an object or an array");
       }
-      return ret;
-    }
-    module2.exports = RedirectHandler;
+    };
+    module2.exports = DispatcherBase;
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/interceptor/redirectInterceptor.js
-var require_redirectInterceptor = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module2) {
-    "use strict";
-    var RedirectHandler = require_RedirectHandler();
-    function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) {
-      return (dispatch) => {
-        return function Intercept(opts, handler) {
-          const { maxRedirections = defaultMaxRedirections } = opts;
-          if (!maxRedirections) {
-            return dispatch(opts, handler);
-          }
-          const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler);
-          opts = { ...opts, maxRedirections: 0 };
-          return dispatch(opts, redirectHandler);
-        };
-      };
-    }
-    module2.exports = createRedirectInterceptor;
+// src/mock-agent/pool.cjs
+var require_pool = __commonJS({
+  "src/mock-agent/pool.cjs"(exports2, module2) {
+    var assert = require("node:assert");
+    module2.exports = class Pool {
+      constructor() {
+        assert.fail("Pool is not implemented in worker");
+      }
+    };
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/compat/dispatcher-weakref.js
-var require_dispatcher_weakref = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/compat/dispatcher-weakref.js"(exports2, module2) {
+// src/mock-agent/dispatcher.cjs
+var require_dispatcher2 = __commonJS({
+  "src/mock-agent/dispatcher.cjs"(exports2, module2) {
     "use strict";
-    var { kConnected, kSize } = require_symbols();
-    var CompatWeakRef = class {
-      constructor(value) {
-        this.value = value;
-      }
-      deref() {
-        return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
+    var dispatcher;
+    module2.exports = {
+      getDispatcher() {
+        return dispatcher;
+      },
+      setDispatcher(newDispatcher) {
+        dispatcher = newDispatcher;
       }
     };
-    var CompatFinalizer = class {
-      constructor(finalizer) {
-        this.finalizer = finalizer;
-      }
-      register(dispatcher, key) {
-        if (dispatcher.on) {
-          dispatcher.on("disconnect", () => {
-            if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
-              this.finalizer(key);
-            }
-          });
+  }
+});
+
+// src/mock-agent/client.cjs
+var require_client = __commonJS({
+  "src/mock-agent/client.cjs"(exports2, module2) {
+    var assert = require("node:assert");
+    var DispatcherBase = require_dispatcher_base();
+    var { kDispatch, kClose, kDestroy } = require_symbols();
+    var { getDispatcher } = require_dispatcher2();
+    module2.exports = class Client extends DispatcherBase {
+      [kDispatch](opts, handler) {
+        const dispatcher = getDispatcher();
+        if (dispatcher === void 0) {
+          assert.fail("setDispatcher() must be called before Client#[kDispatch]()");
         }
+        dispatcher(opts, handler);
+        return true;
       }
-    };
-    module2.exports = function() {
-      if (process.env.NODE_V8_COVERAGE) {
-        return {
-          WeakRef: CompatWeakRef,
-          FinalizationRegistry: CompatFinalizer
-        };
+      async [kClose]() {
+      }
+      async [kDestroy](_err) {
       }
-      return {
-        WeakRef: global.WeakRef || CompatWeakRef,
-        FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer
-      };
     };
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/agent.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/dispatcher/agent.js
 var require_agent = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/agent.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/dispatcher/agent.js"(exports2, module2) {
     "use strict";
     var { InvalidArgumentError } = require_errors();
-    var { kClients: kClients2, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols();
+    var { kClients: kClients2, kRunning, kClose, kDestroy, kDispatch, kUrl } = require_symbols();
     var DispatcherBase = require_dispatcher_base();
     var Pool = require_pool();
     var Client = require_client();
     var util = require_util();
-    var createRedirectInterceptor = require_redirectInterceptor();
-    var { WeakRef, FinalizationRegistry } = require_dispatcher_weakref()();
     var kOnConnect = Symbol("onConnect");
     var kOnDisconnect = Symbol("onDisconnect");
     var kOnConnectionError = Symbol("onConnectionError");
-    var kMaxRedirections = Symbol("maxRedirections");
     var kOnDrain = Symbol("onDrain");
     var kFactory = Symbol("factory");
-    var kFinalizer = Symbol("finalizer");
     var kOptions = Symbol("options");
     function defaultFactory(origin, opts) {
       return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
     }
     var Agent = class extends DispatcherBase {
-      constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
-        super();
+      constructor({ factory = defaultFactory, connect, ...options } = {}) {
         if (typeof factory !== "function") {
           throw new InvalidArgumentError("factory must be a function.");
         }
         if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
           throw new InvalidArgumentError("connect must be a function or an object");
         }
-        if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
-          throw new InvalidArgumentError("maxRedirections must be a positive number");
-        }
+        super();
         if (connect && typeof connect !== "function") {
           connect = { ...connect };
         }
-        this[kInterceptors] = options.interceptors && options.interceptors.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })];
         this[kOptions] = { ...util.deepClone(options), connect };
-        this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
-        this[kMaxRedirections] = maxRedirections;
         this[kFactory] = factory;
         this[kClients2] = /* @__PURE__ */ new Map();
-        this[kFinalizer] = new FinalizationRegistry(
-          /* istanbul ignore next: gc is undeterministic */
-          (key) => {
-            const ref = this[kClients2].get(key);
-            if (ref !== void 0 && ref.deref() === void 0) {
-              this[kClients2].delete(key);
-            }
-          }
-        );
-        const agent = this;
         this[kOnDrain] = (origin, targets) => {
-          agent.emit("drain", origin, [agent, ...targets]);
+          this.emit("drain", origin, [this, ...targets]);
         };
         this[kOnConnect] = (origin, targets) => {
-          agent.emit("connect", origin, [agent, ...targets]);
+          const result = this[kClients2].get(origin);
+          if (result) {
+            result.count += 1;
+          }
+          this.emit("connect", origin, [this, ...targets]);
         };
         this[kOnDisconnect] = (origin, targets, err) => {
-          agent.emit("disconnect", origin, [agent, ...targets], err);
+          const result = this[kClients2].get(origin);
+          if (result) {
+            result.count -= 1;
+            if (result.count <= 0) {
+              this[kClients2].delete(origin);
+              result.dispatcher.destroy();
+            }
+          }
+          this.emit("disconnect", origin, [this, ...targets], err);
         };
         this[kOnConnectionError] = (origin, targets, err) => {
-          agent.emit("connectionError", origin, [agent, ...targets], err);
+          this.emit("connectionError", origin, [this, ...targets], err);
         };
       }
       get [kRunning]() {
         let ret = 0;
-        for (const ref of this[kClients2].values()) {
-          const client = ref.deref();
-          if (client) {
-            ret += client[kRunning];
-          }
+        for (const { dispatcher } of this[kClients2].values()) {
+          ret += dispatcher[kRunning];
         }
         return ret;
       }
@@ -1320,43 +1812,47 @@ var require_agent = __commonJS({
         } else {
           throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
         }
-        const ref = this[kClients2].get(key);
-        let dispatcher = ref ? ref.deref() : null;
+        const result = this[kClients2].get(key);
+        let dispatcher = result && result.dispatcher;
         if (!dispatcher) {
           dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
-          this[kClients2].set(key, new WeakRef(dispatcher));
-          this[kFinalizer].register(dispatcher, key);
+          this[kClients2].set(key, { count: 0, dispatcher });
         }
         return dispatcher.dispatch(opts, handler);
       }
       async [kClose]() {
         const closePromises = [];
-        for (const ref of this[kClients2].values()) {
-          const client = ref.deref();
-          if (client) {
-            closePromises.push(client.close());
-          }
+        for (const { dispatcher } of this[kClients2].values()) {
+          closePromises.push(dispatcher.close());
         }
+        this[kClients2].clear();
         await Promise.all(closePromises);
       }
       async [kDestroy](err) {
         const destroyPromises = [];
-        for (const ref of this[kClients2].values()) {
-          const client = ref.deref();
-          if (client) {
-            destroyPromises.push(client.destroy(err));
-          }
+        for (const { dispatcher } of this[kClients2].values()) {
+          destroyPromises.push(dispatcher.destroy(err));
         }
+        this[kClients2].clear();
         await Promise.all(destroyPromises);
       }
+      get stats() {
+        const allClientStats = {};
+        for (const { dispatcher } of this[kClients2].values()) {
+          if (dispatcher.stats) {
+            allClientStats[dispatcher[kUrl].origin] = dispatcher.stats;
+          }
+        }
+        return allClientStats;
+      }
     };
     module2.exports = Agent;
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-symbols.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-symbols.js
 var require_mock_symbols = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-symbols.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-symbols.js"(exports2, module2) {
     "use strict";
     module2.exports = {
       kAgent: Symbol("agent"),
@@ -1373,24 +1869,31 @@ var require_mock_symbols = __commonJS({
       kMockDispatch: Symbol("mock dispatch"),
       kClose: Symbol("close"),
       kOriginalClose: Symbol("original agent close"),
+      kOriginalDispatch: Symbol("original dispatch"),
       kOrigin: Symbol("origin"),
       kIsMockActive: Symbol("is mock active"),
       kNetConnect: Symbol("net connect"),
       kGetNetConnect: Symbol("get net connect"),
-      kConnected: Symbol("connected")
+      kConnected: Symbol("connected"),
+      kIgnoreTrailingSlash: Symbol("ignore trailing slash"),
+      kMockAgentMockCallHistoryInstance: Symbol("mock agent mock call history name"),
+      kMockAgentRegisterCallHistory: Symbol("mock agent register mock call history"),
+      kMockAgentAddCallHistoryLog: Symbol("mock agent add call history log"),
+      kMockAgentIsCallHistoryEnabled: Symbol("mock agent is call history enabled"),
+      kMockAgentAcceptsNonStandardSearchParameters: Symbol("mock agent accepts non standard search parameters"),
+      kMockCallHistoryAddLog: Symbol("mock call history add log")
     };
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-errors.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-errors.js
 var require_mock_errors = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-errors.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-errors.js"(exports2, module2) {
     "use strict";
     var { UndiciError } = require_errors();
-    var MockNotMatchedError = class _MockNotMatchedError extends UndiciError {
+    var MockNotMatchedError = class extends UndiciError {
       constructor(message) {
         super(message);
-        Error.captureStackTrace(this, _MockNotMatchedError);
         this.name = "MockNotMatchedError";
         this.message = message || "The request does not match any registered mock dispatches";
         this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED";
@@ -1402,9 +1905,9 @@ var require_mock_errors = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-utils.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-utils.js
 var require_mock_utils = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-utils.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-utils.js"(exports2, module2) {
     "use strict";
     var { MockNotMatchedError } = require_mock_errors();
     var {
@@ -1414,13 +1917,14 @@ var require_mock_utils = __commonJS({
       kOrigin,
       kGetNetConnect
     } = require_mock_symbols();
-    var { buildURL, nop } = require_util();
-    var { STATUS_CODES } = require("http");
+    var { serializePathWithQuery } = require_util();
+    var { STATUS_CODES } = require("node:http");
     var {
       types: {
         isPromise
       }
-    } = require("util");
+    } = require("node:util");
+    var { InvalidArgumentError } = require_errors();
     function matchValue(match, value) {
       if (typeof match === "string") {
         return match === value;
@@ -1483,11 +1987,35 @@ var require_mock_utils = __commonJS({
       }
       return true;
     }
+    function normalizeSearchParams(query) {
+      if (typeof query !== "string") {
+        return query;
+      }
+      const originalQp = new URLSearchParams(query);
+      const normalizedQp = new URLSearchParams();
+      for (let [key, value] of originalQp.entries()) {
+        key = key.replace("[]", "");
+        const valueRepresentsString = /^(['"]).*\1$/.test(value);
+        if (valueRepresentsString) {
+          normalizedQp.append(key, value);
+          continue;
+        }
+        if (value.includes(",")) {
+          const values = value.split(",");
+          for (const v of values) {
+            normalizedQp.append(key, v);
+          }
+          continue;
+        }
+        normalizedQp.append(key, value);
+      }
+      return normalizedQp;
+    }
     function safeUrl(path) {
       if (typeof path !== "string") {
         return path;
       }
-      const pathSegments = path.split("?");
+      const pathSegments = path.split("?", 3);
       if (pathSegments.length !== 2) {
         return path;
       }
@@ -1505,35 +2033,45 @@ var require_mock_utils = __commonJS({
     function getResponseData(data) {
       if (Buffer.isBuffer(data)) {
         return data;
+      } else if (data instanceof Uint8Array) {
+        return data;
+      } else if (data instanceof ArrayBuffer) {
+        return data;
       } else if (typeof data === "object") {
         return JSON.stringify(data);
-      } else {
+      } else if (data) {
         return data.toString();
+      } else {
+        return "";
       }
     }
     function getMockDispatch(mockDispatches, key) {
-      const basePath = key.query ? buildURL(key.path, key.query) : key.path;
+      const basePath = key.query ? serializePathWithQuery(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path }) => matchValue(safeUrl(path), resolvedPath));
+      const resolvedPathWithoutTrailingSlash = removeTrailingSlash(resolvedPath);
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path, ignoreTrailingSlash }) => {
+        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path), resolvedPath);
+      });
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
       }
       matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method));
       if (matchedMockDispatches.length === 0) {
-        throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`);
+        throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}' on path '${resolvedPath}'`);
       }
       matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true);
       if (matchedMockDispatches.length === 0) {
-        throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`);
+        throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}' on path '${resolvedPath}'`);
       }
       matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers));
       if (matchedMockDispatches.length === 0) {
-        throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`);
+        const headers = typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers;
+        throw new MockNotMatchedError(`Mock dispatch not matched for headers '${headers}' on path '${resolvedPath}'`);
       }
       return matchedMockDispatches[0];
     }
-    function addMockDispatch(mockDispatches, key, data) {
-      const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false };
+    function addMockDispatch(mockDispatches, key, data, opts) {
+      const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false, ...opts };
       const replyData = typeof data === "function" ? { callback: data } : { ...data };
       const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } };
       mockDispatches.push(newMockDispatch);
@@ -1550,6 +2088,15 @@ var require_mock_utils = __commonJS({
         mockDispatches.splice(index, 1);
       }
     }
+    function removeTrailingSlash(path) {
+      while (path.endsWith("/")) {
+        path = path.slice(0, -1);
+      }
+      if (path.length === 0) {
+        path = "/";
+      }
+      return path;
+    }
     function buildKey(opts) {
       const { path, method, body, headers, query } = opts;
       return {
@@ -1561,11 +2108,21 @@ var require_mock_utils = __commonJS({
       };
     }
     function generateKeyValues(data) {
-      return Object.entries(data).reduce((keyValuePairs, [key, value]) => [
-        ...keyValuePairs,
-        Buffer.from(`${key}`),
-        Array.isArray(value) ? value.map((x) => Buffer.from(`${x}`)) : Buffer.from(`${value}`)
-      ], []);
+      const keys = Object.keys(data);
+      const result = [];
+      for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        const value = data[key];
+        const name = Buffer.from(`${key}`);
+        if (Array.isArray(value)) {
+          for (let j = 0; j < value.length; ++j) {
+            result.push(name, Buffer.from(`${value[j]}`));
+          }
+        } else {
+          result.push(name, Buffer.from(`${value}`));
+        }
+      }
+      return result;
     }
     function getStatusText(statusCode) {
       return STATUS_CODES[statusCode] || "unknown";
@@ -1610,10 +2167,10 @@ var require_mock_utils = __commonJS({
         const responseData = getResponseData(body);
         const responseHeaders = generateKeyValues(headers);
         const responseTrailers = generateKeyValues(trailers);
-        handler.abort = nop;
-        handler.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode));
-        handler.onData(Buffer.from(responseData));
-        handler.onComplete(responseTrailers);
+        handler.onConnect?.((err) => handler.onError(err), null);
+        handler.onHeaders?.(statusCode, responseHeaders, resume, getStatusText(statusCode));
+        handler.onData?.(Buffer.from(responseData));
+        handler.onComplete?.(responseTrailers);
         deleteMockDispatch(mockDispatches, key);
       }
       function resume() {
@@ -1657,9 +2214,15 @@ var require_mock_utils = __commonJS({
       }
       return false;
     }
-    function buildMockOptions(opts) {
+    function buildAndValidateMockOptions(opts) {
       if (opts) {
         const { agent, ...mockOptions } = opts;
+        if ("enableCallHistory" in mockOptions && typeof mockOptions.enableCallHistory !== "boolean") {
+          throw new InvalidArgumentError("options.enableCallHistory must to be a boolean");
+        }
+        if ("acceptNonStandardSearchParameters" in mockOptions && typeof mockOptions.acceptNonStandardSearchParameters !== "boolean") {
+          throw new InvalidArgumentError("options.acceptNonStandardSearchParameters must to be a boolean");
+        }
         return mockOptions;
       }
     }
@@ -1676,15 +2239,17 @@ var require_mock_utils = __commonJS({
       mockDispatch,
       buildMockDispatch,
       checkNetConnect,
-      buildMockOptions,
-      getHeaderByName
+      buildAndValidateMockOptions,
+      getHeaderByName,
+      buildHeadersFromArray,
+      normalizeSearchParams
     };
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-interceptor.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-interceptor.js
 var require_mock_interceptor = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module2) {
     "use strict";
     var { getResponseData, buildKey, addMockDispatch } = require_mock_utils();
     var {
@@ -1693,10 +2258,11 @@ var require_mock_interceptor = __commonJS({
       kDefaultHeaders,
       kDefaultTrailers,
       kContentLength,
-      kMockDispatch
+      kMockDispatch,
+      kIgnoreTrailingSlash
     } = require_mock_symbols();
     var { InvalidArgumentError } = require_errors();
-    var { buildURL } = require_util();
+    var { serializePathWithQuery } = require_util();
     var MockScope = class {
       constructor(mockDispatch) {
         this[kMockDispatch] = mockDispatch;
@@ -1742,7 +2308,7 @@ var require_mock_interceptor = __commonJS({
         }
         if (typeof opts.path === "string") {
           if (opts.query) {
-            opts.path = buildURL(opts.path, opts.query);
+            opts.path = serializePathWithQuery(opts.path, opts.query);
           } else {
             const parsedURL = new URL(opts.path, "data://");
             opts.path = parsedURL.pathname + parsedURL.search;
@@ -1753,51 +2319,53 @@ var require_mock_interceptor = __commonJS({
         }
         this[kDispatchKey] = buildKey(opts);
         this[kDispatches2] = mockDispatches;
+        this[kIgnoreTrailingSlash] = opts.ignoreTrailingSlash ?? false;
         this[kDefaultHeaders] = {};
         this[kDefaultTrailers] = {};
         this[kContentLength] = false;
       }
-      createMockScopeDispatchData(statusCode, data, responseOptions = {}) {
+      createMockScopeDispatchData({ statusCode, data, responseOptions }) {
         const responseData = getResponseData(data);
         const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {};
         const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers };
         const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers };
         return { statusCode, data, headers, trailers };
       }
-      validateReplyParameters(statusCode, data, responseOptions) {
-        if (typeof statusCode === "undefined") {
+      validateReplyParameters(replyParameters) {
+        if (typeof replyParameters.statusCode === "undefined") {
           throw new InvalidArgumentError("statusCode must be defined");
         }
-        if (typeof data === "undefined") {
-          throw new InvalidArgumentError("data must be defined");
-        }
-        if (typeof responseOptions !== "object") {
+        if (typeof replyParameters.responseOptions !== "object" || replyParameters.responseOptions === null) {
           throw new InvalidArgumentError("responseOptions must be an object");
         }
       }
       /**
        * Mock an undici request with a defined reply.
        */
-      reply(replyData) {
-        if (typeof replyData === "function") {
+      reply(replyOptionsCallbackOrStatusCode) {
+        if (typeof replyOptionsCallbackOrStatusCode === "function") {
           const wrappedDefaultsCallback = (opts) => {
-            const resolvedData = replyData(opts);
-            if (typeof resolvedData !== "object") {
+            const resolvedData = replyOptionsCallbackOrStatusCode(opts);
+            if (typeof resolvedData !== "object" || resolvedData === null) {
               throw new InvalidArgumentError("reply options callback must return an object");
             }
-            const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData;
-            this.validateReplyParameters(statusCode2, data2, responseOptions2);
+            const replyParameters2 = { data: "", responseOptions: {}, ...resolvedData };
+            this.validateReplyParameters(replyParameters2);
             return {
-              ...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2)
+              ...this.createMockScopeDispatchData(replyParameters2)
             };
           };
-          const newMockDispatch2 = addMockDispatch(this[kDispatches2], this[kDispatchKey], wrappedDefaultsCallback);
+          const newMockDispatch2 = addMockDispatch(this[kDispatches2], this[kDispatchKey], wrappedDefaultsCallback, { ignoreTrailingSlash: this[kIgnoreTrailingSlash] });
           return new MockScope(newMockDispatch2);
         }
-        const [statusCode, data = "", responseOptions = {}] = [...arguments];
-        this.validateReplyParameters(statusCode, data, responseOptions);
-        const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions);
-        const newMockDispatch = addMockDispatch(this[kDispatches2], this[kDispatchKey], dispatchData);
+        const replyParameters = {
+          statusCode: replyOptionsCallbackOrStatusCode,
+          data: arguments[1] === void 0 ? "" : arguments[1],
+          responseOptions: arguments[2] === void 0 ? {} : arguments[2]
+        };
+        this.validateReplyParameters(replyParameters);
+        const dispatchData = this.createMockScopeDispatchData(replyParameters);
+        const newMockDispatch = addMockDispatch(this[kDispatches2], this[kDispatchKey], dispatchData, { ignoreTrailingSlash: this[kIgnoreTrailingSlash] });
         return new MockScope(newMockDispatch);
       }
       /**
@@ -1807,7 +2375,7 @@ var require_mock_interceptor = __commonJS({
         if (typeof error === "undefined") {
           throw new InvalidArgumentError("error must be defined");
         }
-        const newMockDispatch = addMockDispatch(this[kDispatches2], this[kDispatchKey], { error });
+        const newMockDispatch = addMockDispatch(this[kDispatches2], this[kDispatchKey], { error }, { ignoreTrailingSlash: this[kIgnoreTrailingSlash] });
         return new MockScope(newMockDispatch);
       }
       /**
@@ -1843,11 +2411,11 @@ var require_mock_interceptor = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-client.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-client.js
 var require_mock_client = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-client.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-client.js"(exports2, module2) {
     "use strict";
-    var { promisify } = require("util");
+    var { promisify } = require("node:util");
     var Client = require_client();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -1857,19 +2425,21 @@ var require_mock_client = __commonJS({
       kOriginalClose,
       kOrigin,
       kOriginalDispatch,
-      kConnected
+      kConnected,
+      kIgnoreTrailingSlash
     } = require_mock_symbols();
     var { MockInterceptor } = require_mock_interceptor();
     var Symbols = require_symbols();
     var { InvalidArgumentError } = require_errors();
     var MockClient = class extends Client {
       constructor(origin, opts) {
-        super(origin, opts);
         if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
           throw new InvalidArgumentError("Argument opts.agent must implement Agent");
         }
+        super(origin, opts);
         this[kMockAgent] = opts.agent;
         this[kOrigin] = origin;
+        this[kIgnoreTrailingSlash] = opts.ignoreTrailingSlash ?? false;
         this[kDispatches2] = [];
         this[kConnected] = 1;
         this[kOriginalDispatch] = this.dispatch;
@@ -1884,7 +2454,13 @@ var require_mock_client = __commonJS({
        * Sets up the base interceptor for mocking replies from undici.
        */
       intercept(opts) {
-        return new MockInterceptor(opts, this[kDispatches2]);
+        return new MockInterceptor(
+          opts && { ignoreTrailingSlash: this[kIgnoreTrailingSlash], ...opts },
+          this[kDispatches2]
+        );
+      }
+      cleanMocks() {
+        this[kDispatches2] = [];
       }
       async [kClose]() {
         await promisify(this[kOriginalClose])();
@@ -1896,11 +2472,11 @@ var require_mock_client = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-pool.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-pool.js
 var require_mock_pool = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) {
     "use strict";
-    var { promisify } = require("util");
+    var { promisify } = require("node:util");
     var Pool = require_pool();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -1910,19 +2486,21 @@ var require_mock_pool = __commonJS({
       kOriginalClose,
       kOrigin,
       kOriginalDispatch,
-      kConnected
+      kConnected,
+      kIgnoreTrailingSlash
     } = require_mock_symbols();
     var { MockInterceptor } = require_mock_interceptor();
     var Symbols = require_symbols();
     var { InvalidArgumentError } = require_errors();
     var MockPool = class extends Pool {
       constructor(origin, opts) {
-        super(origin, opts);
         if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
           throw new InvalidArgumentError("Argument opts.agent must implement Agent");
         }
+        super(origin, opts);
         this[kMockAgent] = opts.agent;
         this[kOrigin] = origin;
+        this[kIgnoreTrailingSlash] = opts.ignoreTrailingSlash ?? false;
         this[kDispatches2] = [];
         this[kConnected] = 1;
         this[kOriginalDispatch] = this.dispatch;
@@ -1937,7 +2515,13 @@ var require_mock_pool = __commonJS({
        * Sets up the base interceptor for mocking replies from undici.
        */
       intercept(opts) {
-        return new MockInterceptor(opts, this[kDispatches2]);
+        return new MockInterceptor(
+          opts && { ignoreTrailingSlash: this[kIgnoreTrailingSlash], ...opts },
+          this[kDispatches2]
+        );
+      }
+      cleanMocks() {
+        this[kDispatches2] = [];
       }
       async [kClose]() {
         await promisify(this[kOriginalClose])();
@@ -1949,37 +2533,6 @@ var require_mock_pool = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/pluralizer.js
-var require_pluralizer = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/pluralizer.js"(exports2, module2) {
-    "use strict";
-    var singulars = {
-      pronoun: "it",
-      is: "is",
-      was: "was",
-      this: "this"
-    };
-    var plurals = {
-      pronoun: "they",
-      is: "are",
-      was: "were",
-      this: "these"
-    };
-    module2.exports = class Pluralizer {
-      constructor(singular, plural) {
-        this.singular = singular;
-        this.plural = plural;
-      }
-      pluralize(count) {
-        const one = count === 1;
-        const keys = one ? singulars : plurals;
-        const noun = one ? this.singular : this.plural;
-        return { ...keys, count, noun };
-      }
-    };
-  }
-});
-
 // src/mock-agent/pending-interceptor-formatter.cjs
 var require_pending_interceptor_formatter = __commonJS({
   "src/mock-agent/pending-interceptor-formatter.cjs"(exports2, module2) {
@@ -2017,9 +2570,209 @@ var require_pending_interceptor_formatter = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-agent.js
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-call-history.js
+var require_mock_call_history = __commonJS({
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-call-history.js"(exports2, module2) {
+    "use strict";
+    var { kMockCallHistoryAddLog } = require_mock_symbols();
+    var { InvalidArgumentError } = require_errors();
+    function handleFilterCallsWithOptions(criteria, options, handler, store) {
+      switch (options.operator) {
+        case "OR":
+          store.push(...handler(criteria));
+          return store;
+        case "AND":
+          return handler.call({ logs: store }, criteria);
+        default:
+          throw new InvalidArgumentError("options.operator must to be a case insensitive string equal to 'OR' or 'AND'");
+      }
+    }
+    function buildAndValidateFilterCallsOptions(options = {}) {
+      const finalOptions = {};
+      if ("operator" in options) {
+        if (typeof options.operator !== "string" || options.operator.toUpperCase() !== "OR" && options.operator.toUpperCase() !== "AND") {
+          throw new InvalidArgumentError("options.operator must to be a case insensitive string equal to 'OR' or 'AND'");
+        }
+        return {
+          ...finalOptions,
+          operator: options.operator.toUpperCase()
+        };
+      }
+      return finalOptions;
+    }
+    function makeFilterCalls(parameterName) {
+      return (parameterValue) => {
+        if (typeof parameterValue === "string" || parameterValue == null) {
+          return this.logs.filter((log) => {
+            return log[parameterName] === parameterValue;
+          });
+        }
+        if (parameterValue instanceof RegExp) {
+          return this.logs.filter((log) => {
+            return parameterValue.test(log[parameterName]);
+          });
+        }
+        throw new InvalidArgumentError(`${parameterName} parameter should be one of string, regexp, undefined or null`);
+      };
+    }
+    function computeUrlWithMaybeSearchParameters(requestInit) {
+      try {
+        const url = new URL(requestInit.path, requestInit.origin);
+        if (url.search.length !== 0) {
+          return url;
+        }
+        url.search = new URLSearchParams(requestInit.query).toString();
+        return url;
+      } catch (error) {
+        throw new InvalidArgumentError("An error occurred when computing MockCallHistoryLog.url", { cause: error });
+      }
+    }
+    var MockCallHistoryLog = class {
+      constructor(requestInit = {}) {
+        this.body = requestInit.body;
+        this.headers = requestInit.headers;
+        this.method = requestInit.method;
+        const url = computeUrlWithMaybeSearchParameters(requestInit);
+        this.fullUrl = url.toString();
+        this.origin = url.origin;
+        this.path = url.pathname;
+        this.searchParams = Object.fromEntries(url.searchParams);
+        this.protocol = url.protocol;
+        this.host = url.host;
+        this.port = url.port;
+        this.hash = url.hash;
+      }
+      toMap() {
+        return /* @__PURE__ */ new Map(
+          [
+            ["protocol", this.protocol],
+            ["host", this.host],
+            ["port", this.port],
+            ["origin", this.origin],
+            ["path", this.path],
+            ["hash", this.hash],
+            ["searchParams", this.searchParams],
+            ["fullUrl", this.fullUrl],
+            ["method", this.method],
+            ["body", this.body],
+            ["headers", this.headers]
+          ]
+        );
+      }
+      toString() {
+        const options = { betweenKeyValueSeparator: "->", betweenPairSeparator: "|" };
+        let result = "";
+        this.toMap().forEach((value, key) => {
+          if (typeof value === "string" || value === void 0 || value === null) {
+            result = `${result}${key}${options.betweenKeyValueSeparator}${value}${options.betweenPairSeparator}`;
+          }
+          if (typeof value === "object" && value !== null || Array.isArray(value)) {
+            result = `${result}${key}${options.betweenKeyValueSeparator}${JSON.stringify(value)}${options.betweenPairSeparator}`;
+          }
+        });
+        return result.slice(0, -1);
+      }
+    };
+    var MockCallHistory = class {
+      logs = [];
+      calls() {
+        return this.logs;
+      }
+      firstCall() {
+        return this.logs.at(0);
+      }
+      lastCall() {
+        return this.logs.at(-1);
+      }
+      nthCall(number) {
+        if (typeof number !== "number") {
+          throw new InvalidArgumentError("nthCall must be called with a number");
+        }
+        if (!Number.isInteger(number)) {
+          throw new InvalidArgumentError("nthCall must be called with an integer");
+        }
+        if (Math.sign(number) !== 1) {
+          throw new InvalidArgumentError("nthCall must be called with a positive value. use firstCall or lastCall instead");
+        }
+        return this.logs.at(number - 1);
+      }
+      filterCalls(criteria, options) {
+        if (this.logs.length === 0) {
+          return this.logs;
+        }
+        if (typeof criteria === "function") {
+          return this.logs.filter(criteria);
+        }
+        if (criteria instanceof RegExp) {
+          return this.logs.filter((log) => {
+            return criteria.test(log.toString());
+          });
+        }
+        if (typeof criteria === "object" && criteria !== null) {
+          if (Object.keys(criteria).length === 0) {
+            return this.logs;
+          }
+          const finalOptions = { operator: "OR", ...buildAndValidateFilterCallsOptions(options) };
+          let maybeDuplicatedLogsFiltered = [];
+          if ("protocol" in criteria) {
+            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.protocol, finalOptions, this.filterCallsByProtocol, maybeDuplicatedLogsFiltered);
+          }
+          if ("host" in criteria) {
+            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.host, finalOptions, this.filterCallsByHost, maybeDuplicatedLogsFiltered);
+          }
+          if ("port" in criteria) {
+            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.port, finalOptions, this.filterCallsByPort, maybeDuplicatedLogsFiltered);
+          }
+          if ("origin" in criteria) {
+            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.origin, finalOptions, this.filterCallsByOrigin, maybeDuplicatedLogsFiltered);
+          }
+          if ("path" in criteria) {
+            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.path, finalOptions, this.filterCallsByPath, maybeDuplicatedLogsFiltered);
+          }
+          if ("hash" in criteria) {
+            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.hash, finalOptions, this.filterCallsByHash, maybeDuplicatedLogsFiltered);
+          }
+          if ("fullUrl" in criteria) {
+            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.fullUrl, finalOptions, this.filterCallsByFullUrl, maybeDuplicatedLogsFiltered);
+          }
+          if ("method" in criteria) {
+            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.method, finalOptions, this.filterCallsByMethod, maybeDuplicatedLogsFiltered);
+          }
+          const uniqLogsFiltered = [...new Set(maybeDuplicatedLogsFiltered)];
+          return uniqLogsFiltered;
+        }
+        throw new InvalidArgumentError("criteria parameter should be one of function, regexp, or object");
+      }
+      filterCallsByProtocol = makeFilterCalls.call(this, "protocol");
+      filterCallsByHost = makeFilterCalls.call(this, "host");
+      filterCallsByPort = makeFilterCalls.call(this, "port");
+      filterCallsByOrigin = makeFilterCalls.call(this, "origin");
+      filterCallsByPath = makeFilterCalls.call(this, "path");
+      filterCallsByHash = makeFilterCalls.call(this, "hash");
+      filterCallsByFullUrl = makeFilterCalls.call(this, "fullUrl");
+      filterCallsByMethod = makeFilterCalls.call(this, "method");
+      clear() {
+        this.logs = [];
+      }
+      [kMockCallHistoryAddLog](requestInit) {
+        const log = new MockCallHistoryLog(requestInit);
+        this.logs.push(log);
+        return log;
+      }
+      *[Symbol.iterator]() {
+        for (const log of this.calls()) {
+          yield log;
+        }
+      }
+    };
+    module2.exports.MockCallHistory = MockCallHistory;
+    module2.exports.MockCallHistoryLog = MockCallHistoryLog;
+  }
+});
+
+// ../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-agent.js
 var require_mock_agent = __commonJS({
-  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/mock/mock-agent.js"(exports2, module2) {
+  "../../node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-agent.js"(exports2, module2) {
     "use strict";
     var { kClients: kClients2 } = require_symbols();
     var Agent = require_agent();
@@ -2032,35 +2785,39 @@ var require_mock_agent = __commonJS({
       kNetConnect,
       kGetNetConnect,
       kOptions,
-      kFactory
+      kFactory,
+      kMockAgentRegisterCallHistory,
+      kMockAgentIsCallHistoryEnabled,
+      kMockAgentAddCallHistoryLog,
+      kMockAgentMockCallHistoryInstance,
+      kMockAgentAcceptsNonStandardSearchParameters,
+      kMockCallHistoryAddLog
     } = require_mock_symbols();
     var MockClient = require_mock_client();
     var MockPool = require_mock_pool();
-    var { matchValue, buildMockOptions } = require_mock_utils();
+    var { matchValue, normalizeSearchParams, buildAndValidateMockOptions } = require_mock_utils();
     var { InvalidArgumentError, UndiciError } = require_errors();
     var Dispatcher = require_dispatcher();
-    var Pluralizer = require_pluralizer();
     var PendingInterceptorsFormatter = require_pending_interceptor_formatter();
-    var FakeWeakRef = class {
-      constructor(value) {
-        this.value = value;
-      }
-      deref() {
-        return this.value;
-      }
-    };
+    var { MockCallHistory } = require_mock_call_history();
     var MockAgent2 = class extends Dispatcher {
       constructor(opts) {
         super(opts);
+        const mockOptions = buildAndValidateMockOptions(opts);
         this[kNetConnect] = true;
         this[kIsMockActive2] = true;
-        if (opts && opts.agent && typeof opts.agent.dispatch !== "function") {
+        this[kMockAgentIsCallHistoryEnabled] = mockOptions?.enableCallHistory ?? false;
+        this[kMockAgentAcceptsNonStandardSearchParameters] = mockOptions?.acceptNonStandardSearchParameters ?? false;
+        if (opts?.agent && typeof opts.agent.dispatch !== "function") {
           throw new InvalidArgumentError("Argument opts.agent must implement Agent");
         }
-        const agent = opts && opts.agent ? opts.agent : new Agent(opts);
+        const agent = opts?.agent ? opts.agent : new Agent(opts);
         this[kAgent] = agent;
         this[kClients2] = agent[kClients2];
-        this[kOptions] = buildMockOptions(opts);
+        this[kOptions] = mockOptions;
+        if (this[kMockAgentIsCallHistoryEnabled]) {
+          this[kMockAgentRegisterCallHistory]();
+        }
       }
       get(origin) {
         let dispatcher = this[kMockAgentGet](origin);
@@ -2072,9 +2829,18 @@ var require_mock_agent = __commonJS({
       }
       dispatch(opts, handler) {
         this.get(opts.origin);
-        return this[kAgent].dispatch(opts, handler);
+        this[kMockAgentAddCallHistoryLog](opts);
+        const acceptNonStandardSearchParameters = this[kMockAgentAcceptsNonStandardSearchParameters];
+        const dispatchOpts = { ...opts };
+        if (acceptNonStandardSearchParameters && dispatchOpts.path) {
+          const [path, searchParams] = dispatchOpts.path.split("?");
+          const normalizedSearchParams = normalizeSearchParams(searchParams, acceptNonStandardSearchParameters);
+          dispatchOpts.path = `${path}?${normalizedSearchParams}`;
+        }
+        return this[kAgent].dispatch(dispatchOpts, handler);
       }
       async close() {
+        this.clearCallHistory();
         await this[kAgent].close();
         this[kClients2].clear();
       }
@@ -2100,34 +2866,60 @@ var require_mock_agent = __commonJS({
       disableNetConnect() {
         this[kNetConnect] = false;
       }
+      enableCallHistory() {
+        this[kMockAgentIsCallHistoryEnabled] = true;
+        return this;
+      }
+      disableCallHistory() {
+        this[kMockAgentIsCallHistoryEnabled] = false;
+        return this;
+      }
+      getCallHistory() {
+        return this[kMockAgentMockCallHistoryInstance];
+      }
+      clearCallHistory() {
+        if (this[kMockAgentMockCallHistoryInstance] !== void 0) {
+          this[kMockAgentMockCallHistoryInstance].clear();
+        }
+      }
       // This is required to bypass issues caused by using global symbols - see:
       // https://github.com/nodejs/undici/issues/1447
       get isMockActive() {
         return this[kIsMockActive2];
       }
+      [kMockAgentRegisterCallHistory]() {
+        if (this[kMockAgentMockCallHistoryInstance] === void 0) {
+          this[kMockAgentMockCallHistoryInstance] = new MockCallHistory();
+        }
+      }
+      [kMockAgentAddCallHistoryLog](opts) {
+        if (this[kMockAgentIsCallHistoryEnabled]) {
+          this[kMockAgentRegisterCallHistory]();
+          this[kMockAgentMockCallHistoryInstance][kMockCallHistoryAddLog](opts);
+        }
+      }
       [kMockAgentSet](origin, dispatcher) {
-        this[kClients2].set(origin, new FakeWeakRef(dispatcher));
+        this[kClients2].set(origin, { count: 0, dispatcher });
       }
       [kFactory](origin) {
         const mockOptions = Object.assign({ agent: this }, this[kOptions]);
         return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions);
       }
       [kMockAgentGet](origin) {
-        const ref = this[kClients2].get(origin);
-        if (ref) {
-          return ref.deref();
+        const result = this[kClients2].get(origin);
+        if (result?.dispatcher) {
+          return result.dispatcher;
         }
         if (typeof origin !== "string") {
           const dispatcher = this[kFactory]("http://localhost:9999");
           this[kMockAgentSet](origin, dispatcher);
           return dispatcher;
         }
-        for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients2])) {
-          const nonExplicitDispatcher = nonExplicitRef.deref();
-          if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) {
+        for (const [keyMatcher, result2] of Array.from(this[kClients2])) {
+          if (result2 && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) {
             const dispatcher = this[kFactory](origin);
             this[kMockAgentSet](origin, dispatcher);
-            dispatcher[kDispatches2] = nonExplicitDispatcher[kDispatches2];
+            dispatcher[kDispatches2] = result2.dispatcher[kDispatches2];
             return dispatcher;
           }
         }
@@ -2137,19 +2929,20 @@ var require_mock_agent = __commonJS({
       }
       pendingInterceptors() {
         const mockAgentClients = this[kClients2];
-        return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches2].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending);
+        return Array.from(mockAgentClients.entries()).flatMap(([origin, result]) => result.dispatcher[kDispatches2].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending);
       }
       assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
         const pending = this.pendingInterceptors();
         if (pending.length === 0) {
           return;
         }
-        const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length);
-        throw new UndiciError(`
-${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:
+        throw new UndiciError(
+          pending.length === 1 ? `1 interceptor is pending:
 
-${pendingInterceptorsFormatter.format(pending)}
-`.trim());
+${pendingInterceptorsFormatter.format(pending)}`.trim() : `${pending.length} interceptors are pending:
+
+${pendingInterceptorsFormatter.format(pending)}`.trim()
+        );
       }
     };
     module2.exports = MockAgent2;
@@ -2170,7 +2963,7 @@ function resetMockAgent(agent) {
   agent.deactivate();
   agent.enableNetConnect();
   for (const mockClient of agent[kClients].values()) {
-    mockClient.deref()?.[kDispatches].splice(0);
+    mockClient.dispatcher?.[kDispatches].splice(0);
   }
   agent.assertNoPendingInterceptors();
 }