@fetchkit/ffetch 4.3.0 → 5.0.1

package/README.md

@@ -15,18 +15,22 @@
 
 ffetch can wrap any fetch-compatible implementation (native fetch, node-fetch, undici, or framework-provided fetch), making it flexible for SSR, edge, and custom environments.
 
+ffetch uses a plugin architecture for optional features, so you only include what you need.
+
 **Key Features:**
 
 - **Timeouts** – per-request or global
 - **Retries** – exponential backoff + jitter
-- **Circuit breaker** – automatic failure protection
-- **Deduplication** – automatic deduping of in-flight identical requests
+- **Abort-aware retries** – aborting during backoff cancels immediately
+- **Plugin architecture** – extensible lifecycle-based plugins for optional behavior
 - **Hooks** – logging, auth, metrics, request/response transformation
 - **Pending requests** – real-time monitoring of active requests
 - **Per-request overrides** – customize behavior on a per-request basis
 - **Universal** – Node.js, Browser, Cloudflare Workers, React Native
 - **Zero runtime deps** – ships as dual ESM/CJS
 - **Configurable error handling** – custom error types and `throwOnHttpError` flag to throw on HTTP errors
+- **Circuit breaker plugin (optional, prebuilt)** – automatic failure protection
+- **Deduplication plugin (optional, prebuilt)** – automatic deduping of in-flight identical requests
 
 ## Quick Start
 
@@ -39,13 +43,14 @@ npm install @fetchkit/ffetch
 ### Basic Usage
 
 ```typescript
-import createClient from '@fetchkit/ffetch'
+import { createClient } from '@fetchkit/ffetch'
+import { dedupePlugin } from '@fetchkit/ffetch/plugins/dedupe'
 
-// Create a client with timeout, retries, and deduplication
+// Create a client with timeout, retries, and deduplication plugin
 const api = createClient({
   timeout: 5000,
   retries: 3,
-  dedupe: true, // Enable deduplication globally
+  plugins: [dedupePlugin()],
   retryDelay: ({ attempt }) => 2 ** attempt * 100 + Math.random() * 100,
 })
 
@@ -64,7 +69,7 @@ const [r1, r2] = await Promise.all([p1, p2])
 
 ```typescript
 // Example: SvelteKit, Next.js, Nuxt, or node-fetch
-import createClient from '@fetchkit/ffetch'
+import { createClient } from '@fetchkit/ffetch'
 
 // Pass your framework's fetch implementation
 const api = createClient({
@@ -84,19 +89,31 @@ const response = await api('/api/data')
 
 ```typescript
 // Production-ready client with error handling and monitoring
+import { createClient } from '@fetchkit/ffetch'
+import { dedupePlugin } from '@fetchkit/ffetch/plugins/dedupe'
+import { circuitPlugin } from '@fetchkit/ffetch/plugins/circuit'
+
 const client = createClient({
   timeout: 10000,
   retries: 2,
-  dedupe: true,
-  dedupeHashFn: (params) => `${params.method}|${params.url}|${params.body}`,
-  circuit: { threshold: 5, reset: 30000 },
   fetchHandler: fetch, // Use custom fetch if needed
+  plugins: [
+    dedupePlugin({
+      hashFn: (params) => `${params.method}|${params.url}|${params.body}`,
+      ttl: 30_000,
+      sweepInterval: 5_000,
+    }),
+    circuitPlugin({
+      threshold: 5,
+      reset: 30_000,
+      onCircuitOpen: (req) => console.warn('Circuit opened due to:', req.url),
+      onCircuitClose: (req) => console.info('Circuit closed after:', req.url),
+    }),
+  ],
   hooks: {
     before: async (req) => console.log('→', req.url),
     after: async (req, res) => console.log('←', res.status),
     onError: async (req, err) => console.error('Error:', err.message),
-    onCircuitOpen: (req) => console.warn('Circuit opened due to:', req.url),
-    onCircuitClose: (req) => console.info('Circuit closed after:', req.url),
   },
 })
 
@@ -130,6 +147,7 @@ Native `fetch`'s controversial behavior of not throwing errors for HTTP error st
 | --------------------------------------------- | ------------------------------------------------------------------------- |
 | **[Complete Documentation](./docs/index.md)** | **Start here** - Documentation index and overview                         |
 | **[API Reference](./docs/api.md)**            | Complete API documentation and configuration options                      |
+| **[Plugin Architecture](./docs/plugins.md)**  | Plugin lifecycle, custom plugin authoring, and integration patterns       |
 | **[Deduplication](./docs/deduplication.md)**  | How deduplication works, hash config, optional TTL cleanup, limitations   |
 | **[Error Handling](./docs/errorhandling.md)** | Strategies for managing errors, including `throwOnHttpError`              |
 | **[Advanced Features](./docs/advanced.md)**   | Per-request overrides, pending requests, circuit breakers, custom errors  |
@@ -139,12 +157,12 @@ Native `fetch`'s controversial behavior of not throwing errors for HTTP error st
 
 ## Environment Requirements
 
-`ffetch` requires modern AbortSignal APIs:
+`ffetch` works best with native `AbortSignal.any` support:
 
-- **Node.js 20.6+** (for AbortSignal.any)
-- **Modern browsers** (Chrome 117+, Firefox 117+, Safari 17+, Edge 117+)
+- **Node.js 20.6+** (native `AbortSignal.any`)
+- **Modern browsers with `AbortSignal.any`** (for example: Chrome 117+, Firefox 117+, Safari 17+, Edge 117+)
 
-If your environment does not support `AbortSignal.any` (Node.js < 20.6, older browsers), you **must install a polyfill** before using ffetch. See the [compatibility guide](./docs/compatibility.md) for instructions.
+If your environment does not support `AbortSignal.any` (Node.js < 20.6, older browsers), you can still use ffetch by installing an `AbortSignal.any` polyfill. `AbortSignal.timeout` is optional because ffetch includes an internal timeout fallback. See the [compatibility guide](./docs/compatibility.md) for instructions.
 
 **Custom fetch support:**
 You can pass any fetch-compatible implementation (native fetch, node-fetch, undici, SvelteKit, Next.js, Nuxt, or a polyfill) via the `fetchHandler` option. This makes ffetch fully compatible with SSR, edge, metaframework environments, custom backends, and test runners.
@@ -161,7 +179,7 @@ npm install abort-controller-x
 
 ```html
 <script type="module">
-  import createClient from 'https://unpkg.com/@fetchkit/ffetch/dist/index.min.js'
+  import { createClient } from 'https://unpkg.com/@fetchkit/ffetch/dist/index.min.js'
 
   const api = createClient({ timeout: 5000 })
   const data = await api('/api/data').then((r) => r.json())
@@ -170,9 +188,9 @@ npm install abort-controller-x
 
 ## Deduplication Limitations
 
-- Deduplication is **off** by default. Enable it via the `dedupe` option.
+- Deduplication is **off** by default. Enable it via `plugins: [dedupePlugin()]`.
 - The default hash function is `dedupeRequestHash`, which handles common body types and skips deduplication for streams and FormData.
-- Optional stale-entry cleanup: `dedupeTTL` enables map-entry eviction, and `dedupeSweepInterval` controls how often eviction runs. TTL eviction only removes dedupe keys; it does not reject already in-flight promises.
+- Optional stale-entry cleanup: `dedupePlugin({ ttl, sweepInterval })` enables map-entry eviction. TTL eviction only removes dedupe keys; it does not reject already in-flight promises.
 - **Stream bodies** (`ReadableStream`, `FormData`): Deduplication is skipped for requests with these body types, as they cannot be reliably hashed or replayed.
 - **Non-idempotent requests**: Use deduplication with caution for non-idempotent methods (e.g., POST), as it may suppress multiple intended requests.
 - **Custom hash function**: Ensure your hash function uniquely identifies requests to avoid accidental deduplication.
@@ -185,6 +203,7 @@ See [deduplication.md](./docs/deduplication.md) for full details.
 | -------------------- | ------------------------- | -------------------- | -------------------------------------------------------------------------------------- |
 | Timeouts             | ❌ Manual AbortController | ✅ Built-in          | ✅ Built-in with fallbacks                                                             |
 | Retries              | ❌ Manual implementation  | ❌ Manual or plugins | ✅ Smart exponential backoff                                                           |
+| Plugin Architecture  | ❌ Not available          | ⚠️ Interceptors only | ✅ First-class plugin pipeline (optional built-in + custom plugins)                    |
 | Circuit Breaker      | ❌ Not available          | ❌ Manual or plugins | ✅ Automatic failure protection                                                        |
 | Deduplication        | ❌ Not available          | ❌ Not available     | ✅ Automatic deduplication of in-flight identical requests                             |
 | Request Monitoring   | ❌ Manual tracking        | ❌ Manual tracking   | ✅ Built-in pending requests                                                           |

package/dist/index.cjs

@@ -82,43 +82,10 @@ __export(index_exports, {
   NetworkError: () => NetworkError,
   RetryLimitError: () => RetryLimitError,
   TimeoutError: () => TimeoutError,
-  createClient: () => createClient,
-  default: () => index_default
+  createClient: () => createClient
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/dedupeRequestHash.ts
-function dedupeRequestHash(params) {
-  const { method, url, body } = params;
-  let bodyString = "";
-  if (body instanceof FormData) {
-    return void 0;
-  }
-  if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
-    return void 0;
-  }
-  if (typeof body === "string") {
-    bodyString = body;
-  } else if (body instanceof URLSearchParams) {
-    bodyString = body.toString();
-  } else if (body instanceof ArrayBuffer) {
-    bodyString = Buffer.from(body).toString("base64");
-  } else if (body instanceof Uint8Array) {
-    bodyString = Buffer.from(body).toString("base64");
-  } else if (body instanceof Blob) {
-    bodyString = `[blob:${body.type}:${body.size}]`;
-  } else if (body == null) {
-    bodyString = "";
-  } else {
-    try {
-      bodyString = JSON.stringify(body);
-    } catch {
-      bodyString = "[unserializable-body]";
-    }
-  }
-  return `${method.toUpperCase()}|${url}|${bodyString}`;
-}
-
 // src/retry.ts
 var defaultDelay = (ctx) => {
   const retryAfter = ctx.response?.headers.get("Retry-After");
@@ -130,7 +97,29 @@ var defaultDelay = (ctx) => {
   }
   return 2 ** ctx.attempt * 200 + Math.random() * 100;
 };
-async function retry(fn, retries, delay, shouldRetry2 = () => true, request) {
+function waitForRetryDelay(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    if (!signal) {
+      setTimeout(resolve, ms);
+      return;
+    }
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function retry(fn, retries, delay, shouldRetry2 = () => true, request, signal) {
   let lastErr;
   let lastRes;
   for (let i = 0; i <= retries; i++) {
@@ -146,7 +135,7 @@ async function retry(fn, retries, delay, shouldRetry2 = () => true, request) {
       ctx.error = void 0;
       if (i < retries && shouldRetry2(ctx)) {
         const wait = typeof delay === "function" ? delay(ctx) : delay;
-        await new Promise((r) => setTimeout(r, wait));
+        await waitForRetryDelay(wait, signal);
         continue;
       }
       return lastRes;
@@ -155,7 +144,7 @@ async function retry(fn, retries, delay, shouldRetry2 = () => true, request) {
       ctx.error = err;
       if (i === retries || !shouldRetry2(ctx)) throw err;
       const wait = typeof delay === "function" ? delay(ctx) : delay;
-      await new Promise((r) => setTimeout(r, wait));
+      await waitForRetryDelay(wait, signal);
     }
   }
   throw lastErr;
@@ -171,128 +160,49 @@ function shouldRetry(ctx) {
   return response.status >= 500 || response.status === 429;
 }
 
-// src/circuit.ts
-init_error();
-var CircuitBreaker = class {
-  constructor(threshold, resetTimeout) {
-    this.threshold = threshold;
-    this.resetTimeout = resetTimeout;
-    this.failures = 0;
-    this.nextAttempt = 0;
-    this.isOpen = false;
-  }
-  // Returns true if the circuit breaker is currently open (blocking requests).
-  get open() {
-    return this.isOpen;
-  }
-  // Call this after each request to record the result and update circuit state.
-  // Returns true if the result was counted as a failure.
-  recordResult(response, error, req) {
-    if (error && !(error instanceof RetryLimitError)) {
-      this.setLastOpenRequest(req);
-      this.onFailure();
-      return true;
-    }
-    if (response && (response.status >= 500 || response.status === 429)) {
-      this.setLastOpenRequest(req);
-      this.onFailure();
-      return true;
-    }
-    if (req) this.setLastSuccessRequest(req);
-    this.onSuccess();
-    return false;
-  }
-  setHooks(hooks) {
-    this.hooks = hooks;
-  }
-  setLastOpenRequest(req) {
-    this.lastOpenRequest = req;
-  }
-  setLastSuccessRequest(req) {
-    this.lastSuccessRequest = req;
-  }
-  async invoke(fn) {
-    if (Date.now() < this.nextAttempt)
-      throw new CircuitOpenError("Circuit is open");
-    try {
-      const res = await fn();
-      this.onSuccess();
-      return res;
-    } catch (err) {
-      this.onFailure();
-      throw err;
-    }
-  }
-  onSuccess() {
-    const wasOpen = this.isOpen;
-    this.failures = 0;
-    if (wasOpen) {
-      this.isOpen = false;
-      if (this.hooks?.onCircuitClose && this.lastSuccessRequest) {
-        this.hooks.onCircuitClose(this.lastSuccessRequest);
-      }
-    }
-    this.lastSuccessRequest = void 0;
-  }
-  onFailure() {
-    this.failures++;
-    if (this.failures >= this.threshold) {
-      this.nextAttempt = Date.now() + this.resetTimeout;
-      this.isOpen = true;
-      if (this.hooks?.onCircuitOpen && this.lastOpenRequest) {
-        this.hooks.onCircuitOpen(this.lastOpenRequest);
-      }
-    }
-  }
-};
-
 // src/client.ts
 init_error();
 function createClient(opts = {}) {
-  let dedupeSweeper;
-  function startDedupeSweeper() {
-    if (dedupeSweeper || !dedupeTTL) return;
-    dedupeSweeper = setInterval(() => {
-      const now = Date.now();
-      for (const [key, entry] of dedupeMap.entries()) {
-        if (now - entry.createdAt > dedupeTTL) {
-          dedupeMap.delete(key);
-        }
-      }
-      if (dedupeMap.size === 0 && dedupeSweeper) {
-        clearInterval(dedupeSweeper);
-        dedupeSweeper = void 0;
-      }
-    }, dedupeSweepInterval);
-  }
-  function stopDedupeSweeperIfIdle() {
-    if (dedupeMap.size === 0 && dedupeSweeper) {
-      clearInterval(dedupeSweeper);
-      dedupeSweeper = void 0;
-    }
-  }
-  const dedupeMap = /* @__PURE__ */ new Map();
   const {
     timeout: clientDefaultTimeout = 5e3,
     retries: clientDefaultRetries = 0,
     retryDelay: clientDefaultRetryDelay = defaultDelay,
     shouldRetry: clientDefaultShouldRetry = shouldRetry,
     hooks: clientDefaultHooks = {},
-    circuit: clientDefaultCircuit,
     fetchHandler,
-    dedupe = false,
-    dedupeHashFn = dedupeRequestHash,
-    dedupeTTL,
-    dedupeSweepInterval = 5e3
+    plugins: inputPlugins = []
   } = opts;
-  const breaker = clientDefaultCircuit ? new CircuitBreaker(
-    clientDefaultCircuit.threshold,
-    clientDefaultCircuit.reset
-  ) : null;
-  if (breaker && (clientDefaultHooks.onCircuitClose || clientDefaultHooks.onCircuitOpen)) {
-    breaker.setHooks({
-      onCircuitClose: clientDefaultHooks.onCircuitClose,
-      onCircuitOpen: clientDefaultHooks.onCircuitOpen
+  const extensionDescriptors = /* @__PURE__ */ Object.create(null);
+  const plugins = inputPlugins.map((plugin, index) => ({ plugin, index })).sort((a, b) => {
+    const aOrder = a.plugin.order ?? 0;
+    const bOrder = b.plugin.order ?? 0;
+    if (aOrder !== bOrder) return aOrder - bOrder;
+    return a.index - b.index;
+  }).map((entry) => entry.plugin);
+  for (const plugin of plugins) {
+    plugin.setup?.({
+      defineExtension: (key, descriptor) => {
+        const propertyKey = key;
+        if (propertyKey in extensionDescriptors) {
+          throw new Error(
+            `Plugin extension collision for property "${String(propertyKey)}"`
+          );
+        }
+        if ("get" in descriptor) {
+          extensionDescriptors[propertyKey] = {
+            get: descriptor.get,
+            enumerable: descriptor.enumerable ?? true,
+            configurable: false
+          };
+          return;
+        }
+        extensionDescriptors[propertyKey] = {
+          value: descriptor.value,
+          writable: false,
+          enumerable: descriptor.enumerable ?? true,
+          configurable: false
+        };
+      }
     });
   }
   const pendingRequests = [];
@@ -302,55 +212,39 @@ function createClient(opts = {}) {
     }
   }
   const client = async (input, init = {}) => {
-    const effectiveDedupe = typeof init.dedupe !== "undefined" ? init.dedupe : dedupe;
-    const effectiveDedupeHashFn = init.dedupeHashFn || dedupeHashFn;
-    let dedupeKey;
     let request = new Request(input, init);
-    if (effectiveDedupe) {
-      dedupeKey = effectiveDedupeHashFn({
-        method: request.method,
-        url: request.url,
-        body: init.body ?? null,
-        headers: request.headers,
-        signal: init.signal === void 0 || init.signal === null ? void 0 : init.signal,
-        requestInit: init,
-        request
-      });
-      if (dedupeKey) {
-        if (dedupeMap.has(dedupeKey)) {
-          return dedupeMap.get(dedupeKey).promise;
-        }
-        let settled = false;
-        let resolveFn;
-        let rejectFn;
-        const inFlightPromise = new Promise((resolve, reject) => {
-          resolveFn = (value) => {
-            if (!settled) {
-              settled = true;
-              resolve(value);
-            }
-          };
-          rejectFn = (reason) => {
-            if (!settled) {
-              settled = true;
-              reject(reason);
-            }
-          };
-        });
-        dedupeMap.set(dedupeKey, {
-          promise: inFlightPromise,
-          resolve: resolveFn,
-          reject: rejectFn,
-          createdAt: Date.now()
-        });
-        if (dedupeTTL) startDedupeSweeper();
-      }
-    }
     const effectiveHooks = { ...clientDefaultHooks, ...init.hooks || {} };
     if (effectiveHooks.transformRequest) {
       request = await effectiveHooks.transformRequest(request);
     }
     await effectiveHooks.before?.(request);
+    const effectiveRetries = init.retries ?? clientDefaultRetries;
+    const effectiveRetryDelay = typeof init.retryDelay !== "undefined" ? init.retryDelay : clientDefaultRetryDelay;
+    const effectiveShouldRetry = init.shouldRetry ?? clientDefaultShouldRetry;
+    const effectiveTimeout = init.timeout ?? clientDefaultTimeout;
+    const userSignal = init.signal;
+    const transformedSignal = request.signal;
+    const pluginContext = {
+      request,
+      init,
+      state: /* @__PURE__ */ Object.create(null),
+      metadata: {
+        startedAt: Date.now(),
+        timeoutMs: effectiveTimeout,
+        signals: {
+          user: userSignal === void 0 || userSignal === null ? void 0 : userSignal,
+          transformed: transformedSignal
+        },
+        retry: {
+          configuredRetries: effectiveRetries,
+          configuredDelay: effectiveRetryDelay,
+          attempt: 0
+        }
+      }
+    };
+    for (const plugin of plugins) {
+      await plugin.preRequest?.(pluginContext);
+    }
     const effectiveThrowOnHttpError = typeof init.throwOnHttpError !== "undefined" ? init.throwOnHttpError : opts.throwOnHttpError ?? false;
     function createTimeoutSignal(timeout) {
       if (typeof AbortSignal?.timeout === "function") {
@@ -365,14 +259,12 @@ function createClient(opts = {}) {
       );
       return controller2.signal;
     }
-    const effectiveTimeout = init.timeout ?? clientDefaultTimeout;
-    const userSignal = init.signal;
-    const transformedSignal = request.signal;
     let timeoutSignal = void 0;
     let combinedSignal = void 0;
     let controller = void 0;
     if (effectiveTimeout > 0) {
       timeoutSignal = createTimeoutSignal(effectiveTimeout);
+      pluginContext.metadata.signals.timeout = timeoutSignal;
     }
     const signals = [];
     if (userSignal) signals.push(userSignal);
@@ -392,14 +284,16 @@ function createClient(opts = {}) {
       combinedSignal = AbortSignal.any(signals);
       controller = new AbortController();
     }
+    pluginContext.metadata.signals.combined = combinedSignal;
     const retryWithHooks = async () => {
-      const effectiveRetries = init.retries ?? clientDefaultRetries;
-      const effectiveRetryDelay = typeof init.retryDelay !== "undefined" ? init.retryDelay : clientDefaultRetryDelay;
-      const effectiveShouldRetry = init.shouldRetry ?? clientDefaultShouldRetry;
       let attempt = 0;
       const shouldRetryWithHook = (ctx) => {
         attempt = ctx.attempt;
+        pluginContext.metadata.retry.attempt = attempt;
+        pluginContext.metadata.retry.lastError = ctx.error;
+        pluginContext.metadata.retry.lastResponse = ctx.response;
         const retrying = effectiveShouldRetry(ctx);
+        pluginContext.metadata.retry.shouldRetryResult = retrying;
         if (retrying && attempt <= effectiveRetries) {
           effectiveHooks.onRetry?.(
             request,
@@ -445,12 +339,10 @@ function createClient(opts = {}) {
               const handler = init.fetchHandler ?? fetchHandler ?? fetch;
               const response = await handler(reqWithSignal);
               lastResponse = response;
-              if (breaker && (response.status >= 500 || response.status === 429)) {
-                breaker.recordResult(response, void 0, request);
-              }
+              pluginContext.metadata.retry.lastResponse = response;
               return response;
             } catch (err) {
-              if (breaker) breaker.recordResult(void 0, err, request);
+              pluginContext.metadata.retry.lastError = err;
               if (err instanceof DOMException && err.name === "AbortError") {
                 if (timeoutSignal?.aborted && (!userSignal || !userSignal.aborted)) {
                   effectiveHooks.onTimeout?.(request);
@@ -475,7 +367,8 @@ function createClient(opts = {}) {
           effectiveRetries,
           effectiveRetryDelay,
           shouldRetryWithHook,
-          request
+          request,
+          combinedSignal
         );
         if (effectiveHooks.transformResponse) {
           res = await effectiveHooks.transformResponse(res, request);
@@ -491,6 +384,7 @@ function createClient(opts = {}) {
         }
         return res;
       } catch (err) {
+        pluginContext.metadata.retry.lastError = err;
         if (lastResponse) {
           const resp = lastResponse;
           if (effectiveThrowOnHttpError && (resp.status >= 400 && resp.status < 500 && resp.status !== 429 || resp.status >= 500 || resp.status === 429)) {
@@ -528,47 +422,39 @@ function createClient(opts = {}) {
         throw retryErr;
       }
     };
-    const actualPromise = breaker ? breaker.invoke(retryWithHooks).catch(async (err) => {
-      if (err instanceof CircuitOpenError) {
-        await effectiveHooks.onCircuitOpen?.(request);
-        await effectiveHooks.onError?.(request, err);
-        await effectiveHooks.onComplete?.(request, void 0, err);
-      } else {
-        await effectiveHooks.onError?.(request, err);
-        await effectiveHooks.onComplete?.(request, void 0, err);
-      }
-      throw err;
-    }) : retryWithHooks();
-    if (effectiveDedupe && dedupeKey && dedupeMap.has(dedupeKey)) {
-      const entry = dedupeMap.get(dedupeKey);
-      if (entry) {
-        actualPromise.then(
-          (result) => entry.resolve(result),
-          (error) => entry.reject(error)
-        );
-        dedupeMap.set(dedupeKey, {
-          promise: actualPromise,
-          resolve: entry.resolve,
-          reject: entry.reject,
-          createdAt: entry.createdAt
-        });
+    const baseDispatch = async () => retryWithHooks();
+    let dispatch = baseDispatch;
+    for (let i = plugins.length - 1; i >= 0; i--) {
+      const plugin = plugins[i];
+      if (plugin.wrapDispatch) {
+        dispatch = plugin.wrapDispatch(dispatch);
       }
     }
+    const actualPromise = dispatch(pluginContext).then(async (response) => {
+      for (const plugin of plugins) {
+        await plugin.onSuccess?.(pluginContext, response);
+      }
+      return response;
+    }).catch(async (err) => {
+      for (const plugin of plugins) {
+        await plugin.onError?.(pluginContext, err);
+      }
+      throw err;
+    });
     const pendingEntry = {
       promise: actualPromise,
       request,
       controller
     };
     pendingRequests.push(pendingEntry);
-    return actualPromise.finally(() => {
+    return actualPromise.finally(async () => {
+      for (const plugin of plugins) {
+        await plugin.onFinally?.(pluginContext);
+      }
       const index = pendingRequests.indexOf(pendingEntry);
       if (index > -1) {
         pendingRequests.splice(index, 1);
       }
-      if (effectiveDedupe && dedupeKey && dedupeMap.get(dedupeKey)?.promise === actualPromise) {
-        dedupeMap.delete(dedupeKey);
-        stopDedupeSweeperIfIdle();
-      }
     });
   };
   Object.defineProperty(client, "pendingRequests", {
@@ -584,18 +470,12 @@ function createClient(opts = {}) {
     enumerable: false,
     configurable: false
   });
-  Object.defineProperty(client, "circuitOpen", {
-    get() {
-      return breaker ? breaker.open : false;
-    },
-    enumerable: true
-  });
+  Object.defineProperties(client, extensionDescriptors);
   return client;
 }
 
 // src/index.ts
 init_error();
-var index_default = createClient;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbortError,