@nexusts/resilience 0.7.0

package/README.md

@@ -0,0 +1,41 @@
+# @nexusts/resilience
+
+> **NexusTS** — Bun-native fullstack framework
+
+## Description
+
+Retry + Circuit Breaker + Bulkhead.
+
+Three primitives in a single DI singleton. retry() for backoff. CircuitBreaker for closed → open → half-open state machine. Bulkhead for FIFO concurrency limits. Shared named registry. **Zero external dependencies.**
+
+## Install
+
+This module is part of the NexusTS monorepo. Each module is published as its own npm package under the `@nexusts/` scope.
+
+Most apps start with just the core:
+
+```bash
+bun add @nexusts/core reflect-metadata zod hono
+```
+
+Then add this module only if you need it:
+
+```bash
+bun add @nexusts/resilience
+```
+
+## Peer dependencies
+
+None. This module is fully self-contained.
+
+## Usage
+
+```typescript
+import { /* public API */ } from "@nexusts/resilience";
+```
+
+See the [user guide](../../docs/user-guide/resilience.md) and the [example app](../../examples/) for a working demo.
+
+## License
+
+MIT — see the root [LICENSE](../../LICENSE).

package/dist/index.js

@@ -0,0 +1,570 @@
+// @bun
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/resilience/src/types.ts
+var RESILIENCE_META = Symbol.for("nexus:Resilience:Meta");
+// packages/resilience/src/retry.ts
+var DEFAULTS = {
+  attempts: 3,
+  initialDelay: 100,
+  maxDelay: 30000,
+  backoff: "exponential-jitter",
+  multiplier: 2
+};
+var defaultRetryOn = (err) => {
+  if (err == null)
+    return false;
+  const name = err?.name ?? "";
+  if (name === "AbortError" || name === "CancellationError")
+    return false;
+  return true;
+};
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const id = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(id);
+      reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function computeBackoff(attempt, cfg) {
+  const { initialDelay, maxDelay, backoff, multiplier } = cfg;
+  let raw;
+  switch (backoff) {
+    case "constant":
+      raw = initialDelay;
+      break;
+    case "linear":
+      raw = initialDelay * attempt;
+      break;
+    case "exponential":
+      raw = initialDelay * Math.pow(multiplier, attempt - 1);
+      break;
+    case "exponential-jitter": {
+      const base = initialDelay * Math.pow(multiplier, attempt - 1);
+      raw = Math.random() * base;
+      break;
+    }
+    default:
+      raw = initialDelay;
+  }
+  return Math.min(raw, maxDelay);
+}
+async function retry(fn, cfg = {}) {
+  const attempts = Math.max(1, cfg.attempts ?? DEFAULTS.attempts);
+  const initialDelay = cfg.initialDelay ?? DEFAULTS.initialDelay;
+  const maxDelay = cfg.maxDelay ?? DEFAULTS.maxDelay;
+  const backoff = cfg.backoff ?? DEFAULTS.backoff;
+  const multiplier = cfg.multiplier ?? DEFAULTS.multiplier;
+  const retryOn = cfg.retryOn ?? defaultRetryOn;
+  const onRetry = cfg.onRetry;
+  const overallTimeout = cfg.timeout;
+  const ac = new AbortController;
+  const overallTimer = overallTimeout ? setTimeout(() => ac.abort(new Error("retry: overall timeout exceeded")), overallTimeout) : undefined;
+  const normalized = { initialDelay, maxDelay, backoff, multiplier };
+  let lastErr;
+  for (let attempt = 1;attempt <= attempts; attempt++) {
+    if (ac.signal.aborted)
+      break;
+    try {
+      return await fn(ac.signal);
+    } catch (err) {
+      lastErr = err;
+      if (attempt >= attempts)
+        break;
+      if (!retryOn(err, attempt))
+        break;
+      const delay = computeBackoff(attempt, normalized);
+      if (onRetry) {
+        try {
+          onRetry(err, attempt, delay);
+        } catch {}
+      }
+      try {
+        await sleep(delay, ac.signal);
+      } catch (sleepErr) {
+        lastErr = sleepErr;
+        break;
+      }
+    }
+  }
+  if (overallTimer)
+    clearTimeout(overallTimer);
+  throw lastErr;
+}
+// packages/resilience/src/circuit-breaker.ts
+var DEFAULTS2 = {
+  threshold: 0.5,
+  minCalls: 5,
+  timeout: 30000,
+  halfOpenAfter: 1,
+  window: 60000
+};
+var defaultIsFailure = (_err) => true;
+
+class CircuitOpenError extends Error {
+  name = "CircuitOpenError";
+  circuit;
+  nextRetryAt;
+  constructor(circuit, nextRetryAt) {
+    super(`Circuit "${circuit}" is open; retry after ${nextRetryAt}ms`);
+    this.circuit = circuit;
+    this.nextRetryAt = nextRetryAt;
+  }
+}
+
+class CircuitBreaker {
+  name;
+  config;
+  state = "closed";
+  samples = [];
+  openedAt = 0;
+  halfOpenInFlight = 0;
+  halfOpenAllowed = 0;
+  constructor(name, config = {}) {
+    this.name = name;
+    this.config = {
+      threshold: config.threshold ?? DEFAULTS2.threshold,
+      minCalls: config.minCalls ?? DEFAULTS2.minCalls,
+      timeout: config.timeout ?? DEFAULTS2.timeout,
+      halfOpenAfter: config.halfOpenAfter ?? DEFAULTS2.halfOpenAfter,
+      window: config.window ?? DEFAULTS2.window,
+      isFailure: config.isFailure ?? defaultIsFailure
+    };
+  }
+  get currentState() {
+    if (this.state === "open" && Date.now() - this.openedAt >= this.config.timeout) {
+      this.transition("half-open");
+      this.halfOpenAllowed = this.config.halfOpenAfter;
+      this.halfOpenInFlight = 0;
+    }
+    return this.state;
+  }
+  async execute(fn) {
+    const state = this.currentState;
+    if (state === "open") {
+      throw new CircuitOpenError(this.name, this.openedAt + this.config.timeout);
+    }
+    if (state === "half-open") {
+      if (this.halfOpenInFlight >= this.halfOpenAllowed) {
+        throw new CircuitOpenError(this.name, this.openedAt + this.config.timeout);
+      }
+      this.halfOpenInFlight += 1;
+    }
+    const start = Date.now();
+    let ok = false;
+    try {
+      const result = await fn();
+      ok = true;
+      return result;
+    } finally {
+      const latency = Date.now() - start;
+      this.record(ok, latency, state);
+    }
+  }
+  record(ok, latency, stateAtCall) {
+    this.config;
+    const now = Date.now();
+    this.samples.push({ ts: now, ok });
+    const cutoff = now - this.config.window;
+    while (this.samples.length > 0 && this.samples[0].ts < cutoff) {
+      this.samples.shift();
+    }
+    const failed = ok ? 0 : 1;
+    if (stateAtCall === "half-open") {
+      this.halfOpenInFlight = Math.max(0, this.halfOpenInFlight - 1);
+      if (!ok) {
+        this.openedAt = now;
+        this.transition("open");
+      } else if (this.halfOpenInFlight === 0) {
+        this.transition("closed");
+        this.samples = [];
+      }
+      return;
+    }
+    if (!ok) {
+      const total = this.samples.length;
+      if (total >= this.config.minCalls) {
+        const failures = this.samples.filter((s) => !s.ok).length;
+        const ratio = failures / total;
+        if (ratio >= this.config.threshold) {
+          this.openedAt = now;
+          this.transition("open");
+        }
+      }
+    } else {
+      if (this.samples.length > this.config.minCalls * 4) {
+        this.samples = this.samples.slice(-this.config.minCalls);
+      }
+    }
+    try {
+      this.config;
+    } catch {}
+  }
+  transition(to) {
+    const from = this.state;
+    if (from === to)
+      return;
+    this.state = to;
+    this.fireHook(from, to);
+  }
+  _onStateChange;
+  _onCall;
+  fireHook(from, to) {
+    try {
+      this._onStateChange?.(from, to, this.name);
+    } catch {}
+  }
+}
+// packages/resilience/src/bulkhead.ts
+var DEFAULTS3 = {
+  maxConcurrent: 10,
+  maxQueued: 100,
+  rejectOnFull: false
+};
+
+class BulkheadFullError extends Error {
+  name_;
+  name = "BulkheadFullError";
+  constructor(name_) {
+    super(`Bulkhead "${name_}" is at capacity`);
+    this.name_ = name_;
+  }
+}
+
+class Bulkhead {
+  name;
+  config;
+  inFlight = 0;
+  queue = [];
+  constructor(config = {}) {
+    this.name = config.name ?? "bulkhead";
+    this.config = {
+      maxConcurrent: config.maxConcurrent ?? DEFAULTS3.maxConcurrent,
+      maxQueued: config.maxQueued ?? DEFAULTS3.maxQueued,
+      rejectOnFull: config.rejectOnFull ?? DEFAULTS3.rejectOnFull
+    };
+  }
+  get stats() {
+    return { inFlight: this.inFlight, queued: this.queue.length };
+  }
+  async execute(fn) {
+    if (this.inFlight < this.config.maxConcurrent) {
+      this.inFlight += 1;
+      try {
+        return await fn();
+      } finally {
+        this.inFlight -= 1;
+        this.drain();
+      }
+    }
+    if (this.queue.length >= this.config.maxQueued) {
+      throw new BulkheadFullError(this.name);
+    }
+    const token = this.enqueue();
+    try {
+      await token.acquire();
+    } catch (err) {
+      throw err;
+    }
+    this.inFlight += 1;
+    try {
+      return await fn();
+    } finally {
+      this.inFlight -= 1;
+      this.drain();
+    }
+  }
+  enqueue() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const token = {
+      acquired: false,
+      cancelled: false,
+      resolve,
+      reject
+    };
+    this.queue.push(token);
+    return Object.assign(promise, {
+      acquire: () => promise,
+      cancel: () => {
+        if (token.acquired)
+          return;
+        token.cancelled = true;
+        token.reject(new DOMException("Cancelled", "AbortError"));
+      }
+    });
+  }
+  drain() {
+    while (this.inFlight < this.config.maxConcurrent && this.queue.length > 0) {
+      const next = this.queue.shift();
+      if (next.cancelled)
+        continue;
+      next.acquired = true;
+      next.resolve();
+      return;
+    }
+  }
+}
+// packages/resilience/src/resilience.service.ts
+import"reflect-metadata";
+import { Inject, Injectable } from "@nexusts/core/decorators/index.js";
+class ResilienceService {
+  static TOKEN = Symbol.for("nexus:ResilienceService");
+  defaults;
+  circuits = new Map;
+  bulkheads = new Map;
+  constructor(config = {}) {
+    this.defaults = {
+      retry: {
+        attempts: 3,
+        initialDelay: 100,
+        maxDelay: 30000,
+        backoff: "exponential-jitter",
+        multiplier: 2,
+        ...config.retry
+      },
+      circuit: {
+        threshold: 0.5,
+        minCalls: 5,
+        timeout: 30000,
+        halfOpenAfter: 1,
+        window: 60000,
+        ...config.circuit
+      },
+      bulkhead: {
+        maxConcurrent: 10,
+        maxQueued: 100,
+        rejectOnFull: false,
+        ...config.bulkhead
+      }
+    };
+  }
+  getOrCreateCircuit(name, config = {}) {
+    let cb = this.circuits.get(name);
+    if (!cb) {
+      cb = new CircuitBreaker(name, { ...this.defaults.circuit, ...config });
+      this.circuits.set(name, cb);
+    }
+    return cb;
+  }
+  getOrCreateBulkhead(name, config = {}) {
+    let bh = this.bulkheads.get(name);
+    if (!bh) {
+      const { name: _ignored, ...defaultRest } = this.defaults.bulkhead;
+      bh = new Bulkhead({ ...defaultRest, ...config, name });
+      this.bulkheads.set(name, bh);
+    }
+    return bh;
+  }
+  getCircuit(name) {
+    return this.circuits.get(name);
+  }
+  getBulkhead(name) {
+    return this.bulkheads.get(name);
+  }
+  retry(fn, cfg) {
+    return retry(fn, { ...this.defaults.retry, ...cfg });
+  }
+  computeBackoff(attempt, overrides) {
+    const cfg = { ...this.defaults.retry, ...overrides };
+    const { initialDelay, maxDelay, multiplier } = cfg;
+    const backoff = cfg.backoff;
+    let raw;
+    switch (backoff) {
+      case "constant":
+        raw = initialDelay;
+        break;
+      case "linear":
+        raw = initialDelay * attempt;
+        break;
+      case "exponential":
+        raw = initialDelay * Math.pow(multiplier, attempt - 1);
+        break;
+      case "exponential-jitter":
+        raw = Math.random() * initialDelay * Math.pow(multiplier, attempt - 1);
+        break;
+    }
+    return Math.min(raw, maxDelay);
+  }
+}
+ResilienceService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("RESILIENCE_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof ResilienceConfig === "undefined" ? Object : ResilienceConfig
+  ])
+], ResilienceService);
+// packages/resilience/src/resilience.module.ts
+import { Module } from "@nexusts/core/decorators/module.js";
+
+// packages/resilience/src/decorators/index.ts
+import"reflect-metadata";
+var KEY_RETRY = Symbol.for("nexus:Resilience:Retry");
+var KEY_CIRCUIT = Symbol.for("nexus:Resilience:Circuit");
+var KEY_BULKHEAD = Symbol.for("nexus:Resilience:Bulkhead");
+var KEY_RESILIENT = Symbol.for("nexus:Resilience:Resilient");
+function getMethodRetry(target, propertyKey) {
+  return Reflect.getMetadata(KEY_RETRY, target, propertyKey);
+}
+function getMethodCircuit(target, propertyKey) {
+  return Reflect.getMetadata(KEY_CIRCUIT, target, propertyKey);
+}
+function getMethodBulkhead(target, propertyKey) {
+  return Reflect.getMetadata(KEY_BULKHEAD, target, propertyKey);
+}
+function getMethodResilient(target, propertyKey) {
+  return Reflect.getMetadata(KEY_RESILIENT, target, propertyKey);
+}
+function makeMethodDecorator(key, extract) {
+  return (config) => {
+    return (_target, propertyKey, _descriptor) => {
+      Reflect.defineMetadata(key, extract(config), _target, propertyKey);
+    };
+  };
+}
+var _resilienceService = null;
+function setResilienceService(svc) {
+  _resilienceService = svc;
+}
+function getResilienceService() {
+  return _resilienceService;
+}
+var Retry = makeMethodDecorator(KEY_RETRY, (c) => c);
+var CircuitBreaker2 = makeMethodDecorator(KEY_CIRCUIT, (c) => c);
+var Bulkhead2 = makeMethodDecorator(KEY_BULKHEAD, (c) => c);
+var Resilient = makeMethodDecorator(KEY_RESILIENT, (c) => c);
+function applyResilience(target, propertyKey, descriptor, svc) {
+  if (!descriptor.value || typeof descriptor.value !== "function") {
+    return descriptor;
+  }
+  const original = descriptor.value;
+  const resilient = getMethodResilient(target, propertyKey);
+  const retry2 = resilient?.retry ?? getMethodRetry(target, propertyKey);
+  const circuit = resilient?.circuit ?? getMethodCircuit(target, propertyKey);
+  const bulkhead = resilient?.bulkhead ?? getMethodBulkhead(target, propertyKey);
+  if (!retry2 && !circuit && !bulkhead) {
+    return descriptor;
+  }
+  const wrapped = async function(...args) {
+    const name = String(propertyKey);
+    const fn = () => original.apply(this, args);
+    const runOnce = async () => {
+      if (bulkhead) {
+        const bh = svc.getOrCreateBulkhead(name, bulkhead);
+        return bh.execute(fn);
+      }
+      return fn();
+    };
+    const runWithCircuit = async () => {
+      if (circuit) {
+        const cb = svc.getOrCreateCircuit(name, circuit);
+        return cb.execute(runOnce);
+      }
+      return runOnce();
+    };
+    const runWithRetry = async () => {
+      if (retry2) {
+        return svc.retry(runWithCircuit, retry2);
+      }
+      return runWithCircuit();
+    };
+    return runWithRetry();
+  };
+  return {
+    ...descriptor,
+    value: wrapped
+  };
+}
+
+// packages/resilience/src/resilience.module.ts
+class ResilienceModule {
+  static forRoot(config = {}) {
+    class ConfiguredResilienceModule {
+    }
+    ConfiguredResilienceModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          {
+            provide: ResilienceService.TOKEN,
+            useFactory: () => {
+              const svc = new ResilienceService(config);
+              setResilienceService(svc);
+              return svc;
+            }
+          },
+          {
+            provide: "RESILIENCE_CONFIG",
+            useValue: config
+          }
+        ],
+        exports: [ResilienceService.TOKEN, "RESILIENCE_CONFIG"]
+      })
+    ], ConfiguredResilienceModule);
+    Object.defineProperty(ConfiguredResilienceModule, "name", {
+      value: "ConfiguredResilienceModule"
+    });
+    return ConfiguredResilienceModule;
+  }
+}
+ResilienceModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      ResilienceService,
+      { provide: ResilienceService.TOKEN, useExisting: ResilienceService }
+    ],
+    exports: [ResilienceService, ResilienceService.TOKEN]
+  })
+], ResilienceModule);
+export {
+  setResilienceService,
+  retry,
+  getResilienceService,
+  getMethodRetry,
+  getMethodResilient,
+  getMethodCircuit,
+  getMethodBulkhead,
+  computeBackoff,
+  applyResilience,
+  Retry,
+  Resilient,
+  ResilienceService,
+  ResilienceModule,
+  RESILIENCE_META,
+  CircuitOpenError,
+  CircuitBreaker2 as CircuitBreakerDecorator,
+  CircuitBreaker,
+  BulkheadFullError,
+  Bulkhead2 as BulkheadDecorator,
+  Bulkhead
+};
+
+//# debugId=2E949C7E6C6632FA64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,16 @@
+{
+  "version": 3,
+  "sources": ["../src/types.ts", "../src/retry.ts", "../src/circuit-breaker.ts", "../src/bulkhead.ts", "../src/resilience.service.ts", "../src/resilience.module.ts", "../src/decorators/index.ts"],
+  "sourcesContent": [
+    "/**\n * `nexusjs/resilience` — public types and config.\n *\n * The resilience module groups three classic distributed-systems\n * primitives — retry with backoff, circuit breaker, and bulkhead\n * (concurrency limiter) — under a single, decorator-friendly API.\n * Each primitive can be used as a class, a method decorator, or a\n * standalone function.\n */\n\n// ============================================================================\n// Retry\n// ============================================================================\n\n/** Backoff strategy between retry attempts. */\nexport type BackoffStrategy =\n\t| \"constant\"\n\t| \"linear\"\n\t| \"exponential\"\n\t| \"exponential-jitter\";\n\n/**\n * Predicate: should we retry this error? Default: retry on any\n * non-abort error. Set to a function to filter (e.g. only retry\n * on network errors, not on 4xx HTTP responses).\n */\nexport type RetryOnPredicate = (err: unknown, attempt: number) => boolean;\n\n/** Configuration for `@Retry()` and `retry()`. */\nexport interface RetryConfig {\n\t/** Maximum number of attempts (including the first call). Default: 3. */\n\tattempts?: number;\n\t/** Initial backoff in ms. Default: 100. */\n\tinitialDelay?: number;\n\t/** Max backoff in ms (caps the exponential growth). Default: 30_000. */\n\tmaxDelay?: number;\n\t/** Backoff strategy. Default: \"exponential-jitter\". */\n\tbackoff?: BackoffStrategy;\n\t/** Multiplier for \"linear\" and \"exponential*\". Default: 2. */\n\tmultiplier?: number;\n\t/** Optional: only retry if this predicate returns true. */\n\tretryOn?: RetryOnPredicate;\n\t/**\n\t * Optional: hook called before each retry. Useful for logging\n\t * and metrics.\n\t */\n\tonRetry?: (err: unknown, attempt: number, delayMs: number) => void;\n\t/**\n\t * Optional: hard timeout for the entire retried operation, in ms.\n\t * If the operation takes longer, it is aborted.\n\t */\n\ttimeout?: number;\n}\n\n// ============================================================================\n// Circuit Breaker\n// ============================================================================\n\n/** A circuit breaker's lifecycle state. */\nexport type CircuitState = \"closed\" | \"open\" | \"half-open\";\n\n/** Configuration for `@CircuitBreaker()` and `CircuitBreaker`. */\nexport interface CircuitBreakerConfig {\n\t/**\n\t * Failure ratio (0..1) that opens the circuit. Default: 0.5.\n\t * Open when `failures / (failures + successes) >= threshold` over\n\t * the rolling window.\n\t */\n\tthreshold?: number;\n\t/** Minimum number of calls before the threshold matters. Default: 5. */\n\tminCalls?: number;\n\t/** How long the circuit stays open before going half-open. Default: 30s. */\n\ttimeout?: number;\n\t/** Calls allowed in half-open. Default: 1. */\n\thalfOpenAfter?: number;\n\t/** Predicate: should this error count as a failure? */\n\tisFailure?: (err: unknown) => boolean;\n\t/** Hook on state change. */\n\tonStateChange?: (from: CircuitState, to: CircuitState, name: string) => void;\n\t/** Hook on every call (good for metrics). */\n\tonCall?: (name: string, success: boolean, latencyMs: number) => void;\n\t/**\n\t * Rolling window length for failure ratio, in ms. Default: 60_000.\n\t */\n\twindow?: number;\n}\n\n// ============================================================================\n// Bulkhead\n// ============================================================================\n\n/** Configuration for `Bulkhead`. */\nexport interface BulkheadConfig {\n\t/** Max concurrent executions. Default: 10. */\n\tmaxConcurrent?: number;\n\t/** Max queued callers waiting for a slot. Default: 100. */\n\tmaxQueued?: number;\n\t/** Reject immediately if queue is full (vs. wait for a slot). */\n\trejectOnFull?: boolean;\n\t/** Optional name for logging / metrics. */\n\tname?: string;\n}\n\n/** Result of a bulkhead call. */\nexport type BulkheadOutcome<T> = {\n\tok: boolean;\n\tvalue?: T;\n\terror?: unknown;\n\tqueueMs?: number;\n\texecutionMs?: number;\n};\n\n// ============================================================================\n// Combined decorator: `@Resilient`\n// ============================================================================\n\n/**\n * All three primitives in one decorator. Each section is optional;\n * pass only what you need.\n *\n *   @Resilient({\n *     retry: { attempts: 3, backoff: \"exponential\" },\n *     circuit: { threshold: 0.5, timeout: 30_000 },\n *     bulkhead: { maxConcurrent: 5 },\n *   })\n *   async callExternal() { ... }\n */\nexport interface ResilientConfig {\n\tretry?: RetryConfig;\n\tcircuit?: CircuitBreakerConfig;\n\tbulkhead?: BulkheadConfig;\n}\n\n// ============================================================================\n// Module\n// ============================================================================\n\n/** Top-level config for `ResilienceModule.forRoot()`. */\nexport interface ResilienceConfig {\n\t/**\n\t * Default retry config — used when `@Retry()` is applied without\n\t * explicit options.\n\t */\n\tretry?: RetryConfig;\n\t/**\n\t * Default circuit breaker config — used when `@CircuitBreaker()`\n\t * is applied without explicit options, and as the template for\n\t * circuit breakers created via `getOrCreate()`.\n\t */\n\tcircuit?: CircuitBreakerConfig;\n\t/**\n\t * Default bulkhead config — same as above.\n\t */\n\tbulkhead?: BulkheadConfig;\n}\n\n// ============================================================================\n// Helpers\n// ============================================================================\n\n/** Internal — used by decorators to attach metadata. */\nexport const RESILIENCE_META = Symbol.for(\"nexus:Resilience:Meta\");\n",
+    "/**\n * `retry()` — pure function. The same code that powers `@Retry()`\n * — useful when you can't (or don't want to) decorate a method.\n *\n *   import { retry } from \"@nexusts/resilience\";\n *\n *   const user = await retry(\n *     () => fetch(\"https://api.example.com/users/42\").then(r => r.json()),\n *     { attempts: 3, backoff: \"exponential-jitter\" },\n *   );\n *\n * Error handling:\n *   - If the function throws and `retryOn(err)` returns true, the\n *     call is retried up to `attempts` times.\n *   - The final error is re-thrown to the caller.\n *   - AbortError / CancellationError short-circuit immediately.\n */\nimport type { RetryConfig, RetryOnPredicate } from \"./types.js\";\n\nconst DEFAULTS = {\n\tattempts: 3,\n\tinitialDelay: 100,\n\tmaxDelay: 30_000,\n\tbackoff: \"exponential-jitter\" as const,\n\tmultiplier: 2,\n};\n\nconst defaultRetryOn: RetryOnPredicate = (err: unknown) => {\n\tif (err == null) return false;\n\t// Honour explicit aborts.\n\tconst name = (err as { name?: string })?.name ?? \"\";\n\tif (name === \"AbortError\" || name === \"CancellationError\") return false;\n\treturn true;\n};\n\n/** Sleep helper that respects AbortSignal. */\nfunction sleep(ms: number, signal?: AbortSignal): Promise<void> {\n\treturn new Promise((resolve, reject) => {\n\t\tif (signal?.aborted) {\n\t\t\treject(signal.reason ?? new DOMException(\"Aborted\", \"AbortError\"));\n\t\t\treturn;\n\t\t}\n\t\tconst id = setTimeout(() => {\n\t\t\tsignal?.removeEventListener(\"abort\", onAbort);\n\t\t\tresolve();\n\t\t}, ms);\n\t\tconst onAbort = () => {\n\t\t\tclearTimeout(id);\n\t\t\treject(signal?.reason ?? new DOMException(\"Aborted\", \"AbortError\"));\n\t\t};\n\t\tsignal?.addEventListener(\"abort\", onAbort, { once: true });\n\t});\n}\n\n/**\n * Compute the next backoff delay. Returns ms.\n *\n *   constant:         initialDelay\n *   linear:           initialDelay * attempt * multiplier\n *   exponential:      initialDelay * multiplier^(attempt-1)\n *   exponential-jitter: above * (0.5..1.5) random factor\n */\nexport function computeBackoff(\n\tattempt: number,\n\tcfg: Required<Pick<RetryConfig, \"initialDelay\" | \"maxDelay\" | \"backoff\" | \"multiplier\">>,\n): number {\n\tconst { initialDelay, maxDelay, backoff, multiplier } = cfg;\n\tlet raw: number;\n\tswitch (backoff) {\n\t\tcase \"constant\":\n\t\t\traw = initialDelay;\n\t\t\tbreak;\n\t\tcase \"linear\":\n\t\t\traw = initialDelay * attempt;\n\t\t\tbreak;\n\t\tcase \"exponential\":\n\t\t\traw = initialDelay * Math.pow(multiplier, attempt - 1);\n\t\t\tbreak;\n\t\tcase \"exponential-jitter\": {\n\t\t\tconst base = initialDelay * Math.pow(multiplier, attempt - 1);\n\t\t\t// ±50% jitter — full jitter (AWS-style).\n\t\t\traw = Math.random() * base;\n\t\t\tbreak;\n\t\t}\n\t\tdefault:\n\t\t\traw = initialDelay;\n\t}\n\treturn Math.min(raw, maxDelay);\n}\n\n/**\n * Retry `fn` according to `cfg`. Returns the eventual value or\n * re-throws the last error.\n */\nexport async function retry<T>(\n\tfn: (signal: AbortSignal) => Promise<T> | T,\n\tcfg: RetryConfig = {},\n): Promise<T> {\n\tconst attempts = Math.max(1, cfg.attempts ?? DEFAULTS.attempts);\n\tconst initialDelay = cfg.initialDelay ?? DEFAULTS.initialDelay;\n\tconst maxDelay = cfg.maxDelay ?? DEFAULTS.maxDelay;\n\tconst backoff = cfg.backoff ?? DEFAULTS.backoff;\n\tconst multiplier = cfg.multiplier ?? DEFAULTS.multiplier;\n\tconst retryOn = cfg.retryOn ?? defaultRetryOn;\n\tconst onRetry = cfg.onRetry;\n\tconst overallTimeout = cfg.timeout;\n\n\tconst ac = new AbortController();\n\tconst overallTimer = overallTimeout\n\t\t? setTimeout(() => ac.abort(new Error(\"retry: overall timeout exceeded\")), overallTimeout)\n\t\t: undefined;\n\n\tconst normalized = { initialDelay, maxDelay, backoff, multiplier };\n\tlet lastErr: unknown;\n\tfor (let attempt = 1; attempt <= attempts; attempt++) {\n\t\tif (ac.signal.aborted) break;\n\t\ttry {\n\t\t\treturn await fn(ac.signal);\n\t\t} catch (err) {\n\t\t\tlastErr = err;\n\t\t\tif (attempt >= attempts) break;\n\t\t\tif (!retryOn(err, attempt)) break;\n\t\t\tconst delay = computeBackoff(attempt, normalized);\n\t\t\tif (onRetry) {\n\t\t\t\ttry {\n\t\t\t\t\tonRetry(err, attempt, delay);\n\t\t\t\t} catch {\n\t\t\t\t\t/* hook errors must not break the retry */\n\t\t\t\t}\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tawait sleep(delay, ac.signal);\n\t\t\t} catch (sleepErr) {\n\t\t\t\tlastErr = sleepErr;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (overallTimer) clearTimeout(overallTimer);\n\tthrow lastErr;\n}\n",
+    "/**\n * `CircuitBreaker` — a single named circuit. Constructed on demand\n * via `ResilienceService.getOrCreate()` (so multiple parts of your\n * app share one circuit per external dependency), or directly:\n *\n *   import { CircuitBreaker } from \"@nexusts/resilience\";\n *\n *   const stripe = new CircuitBreaker(\"stripe\", {\n *     threshold: 0.5,\n *     timeout: 30_000,\n *   });\n *\n *   const result = await stripe.execute(() => stripeApi.charge(...));\n *\n * State machine:\n *\n *     closed  ──failures ≥ threshold──▶  open\n *        ▲                                │\n *        │                                │ after `timeout` ms\n *        │                                ▼\n *     closed ◀──success── half-open\n *                    │\n *                    └─ failure ──▶ open (reset)\n *\n *   - `closed`: all calls go through. Track success/failure in a\n *     rolling window.\n *   - `open`: calls fail-fast with `CircuitOpenError`. After\n *     `timeout` ms, transition to `half-open`.\n *   - `half-open`: at most `halfOpenAfter` calls are allowed. If any\n *     of them fails → back to `open`. If all succeed → back to\n *     `closed`.\n */\nimport type { CircuitBreakerConfig, CircuitState } from \"./types.js\";\n\nconst DEFAULTS = {\n\tthreshold: 0.5,\n\tminCalls: 5,\n\ttimeout: 30_000,\n\thalfOpenAfter: 1,\n\twindow: 60_000,\n};\n\nconst defaultIsFailure = (_err: unknown): boolean => true;\n\n/** Thrown when the circuit is open. Callers should treat as \"fail-fast\". */\nexport class CircuitOpenError extends Error {\n\treadonly name = \"CircuitOpenError\";\n\treadonly circuit: string;\n\treadonly nextRetryAt: number;\n\tconstructor(circuit: string, nextRetryAt: number) {\n\t\tsuper(`Circuit \"${circuit}\" is open; retry after ${nextRetryAt}ms`);\n\t\tthis.circuit = circuit;\n\t\tthis.nextRetryAt = nextRetryAt;\n\t}\n}\n\ninterface Sample {\n\tts: number;\n\tok: boolean;\n}\n\nexport class CircuitBreaker {\n\treadonly name: string;\n\treadonly config: Required<Omit<CircuitBreakerConfig, \"onStateChange\" | \"onCall\" | \"isFailure\">> & {\n\t\tisFailure: NonNullable<CircuitBreakerConfig[\"isFailure\"]>;\n\t};\n\tprivate state: CircuitState = \"closed\";\n\tprivate samples: Sample[] = [];\n\tprivate openedAt = 0;\n\tprivate halfOpenInFlight = 0;\n\tprivate halfOpenAllowed = 0;\n\n\tconstructor(name: string, config: CircuitBreakerConfig = {}) {\n\t\tthis.name = name;\n\t\tthis.config = {\n\t\t\tthreshold: config.threshold ?? DEFAULTS.threshold,\n\t\t\tminCalls: config.minCalls ?? DEFAULTS.minCalls,\n\t\t\ttimeout: config.timeout ?? DEFAULTS.timeout,\n\t\t\thalfOpenAfter: config.halfOpenAfter ?? DEFAULTS.halfOpenAfter,\n\t\t\twindow: config.window ?? DEFAULTS.window,\n\t\t\tisFailure: config.isFailure ?? defaultIsFailure,\n\t\t};\n\t}\n\n\tget currentState(): CircuitState {\n\t\t// Lazy transition: if the open timer has elapsed, flip to half-open\n\t\t// before the next call, so the consumer sees the right state.\n\t\tif (\n\t\t\tthis.state === \"open\" &&\n\t\t\tDate.now() - this.openedAt >= this.config.timeout\n\t\t) {\n\t\t\tthis.transition(\"half-open\");\n\t\t\tthis.halfOpenAllowed = this.config.halfOpenAfter;\n\t\t\tthis.halfOpenInFlight = 0;\n\t\t}\n\t\treturn this.state;\n\t}\n\n\t/** Run `fn` through the circuit. Throws `CircuitOpenError` when open. */\n\tasync execute<T>(fn: () => Promise<T> | T): Promise<T> {\n\t\tconst state = this.currentState;\n\n\t\tif (state === \"open\") {\n\t\t\tthrow new CircuitOpenError(this.name, this.openedAt + this.config.timeout);\n\t\t}\n\n\t\t// Concurrency control for half-open.\n\t\tif (state === \"half-open\") {\n\t\t\tif (this.halfOpenInFlight >= this.halfOpenAllowed) {\n\t\t\t\tthrow new CircuitOpenError(this.name, this.openedAt + this.config.timeout);\n\t\t\t}\n\t\t\tthis.halfOpenInFlight += 1;\n\t\t}\n\n\t\tconst start = Date.now();\n\t\tlet ok = false;\n\t\ttry {\n\t\t\tconst result = await fn();\n\t\t\tok = true;\n\t\t\treturn result;\n\t\t} finally {\n\t\t\tconst latency = Date.now() - start;\n\t\t\tthis.record(ok, latency, state);\n\t\t}\n\t}\n\n\tprivate record(ok: boolean, latency: number, stateAtCall: CircuitState): void {\n\t\tthis.config; // touch — keep the type narrow\n\t\t// Track in the rolling window.\n\t\tconst now = Date.now();\n\t\tthis.samples.push({ ts: now, ok });\n\t\tconst cutoff = now - this.config.window;\n\t\twhile (this.samples.length > 0 && this.samples[0].ts < cutoff) {\n\t\t\tthis.samples.shift();\n\t\t}\n\n\t\tconst failed = ok ? 0 : 1;\n\t\tvoid failed;\n\n\t\t// State transitions.\n\t\tif (stateAtCall === \"half-open\") {\n\t\t\tthis.halfOpenInFlight = Math.max(0, this.halfOpenInFlight - 1);\n\t\t\tif (!ok) {\n\t\t\t\tthis.openedAt = now;\n\t\t\t\tthis.transition(\"open\");\n\t\t\t} else if (this.halfOpenInFlight === 0) {\n\t\t\t\tthis.transition(\"closed\");\n\t\t\t\tthis.samples = [];\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\t// closed → possibly open\n\t\tif (!ok) {\n\t\t\tconst total = this.samples.length;\n\t\t\tif (total >= this.config.minCalls) {\n\t\t\t\tconst failures = this.samples.filter((s) => !s.ok).length;\n\t\t\t\tconst ratio = failures / total;\n\t\t\t\tif (ratio >= this.config.threshold) {\n\t\t\t\t\tthis.openedAt = now;\n\t\t\t\t\tthis.transition(\"open\");\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\t// Reset the window on full-success periods so a long-stable\n\t\t\t// upstream doesn't carry stale failures forever.\n\t\t\tif (this.samples.length > this.config.minCalls * 4) {\n\t\t\t\tthis.samples = this.samples.slice(-this.config.minCalls);\n\t\t\t}\n\t\t}\n\n\t\t// Hooks — best-effort, swallow errors.\n\t\ttry {\n\t\t\tthis.config; // (placeholder for future hooks read)\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t}\n\n\tprivate transition(to: CircuitState): void {\n\t\tconst from = this.state;\n\t\tif (from === to) return;\n\t\tthis.state = to;\n\t\t// Hooks are passed in `config`; we only know about them via\n\t\t// the outer constructor so we keep them on a parallel field.\n\t\t// (The hook API is set in the ResilienceService which owns\n\t\t// the onStateChange list.)\n\t\tthis.fireHook(from, to);\n\t}\n\n\t/** Set by ResilienceService — fires on each transition. */\n\t_onStateChange?: (from: CircuitState, to: CircuitState, name: string) => void;\n\t_onCall?: (name: string, success: boolean, latencyMs: number) => void;\n\tprivate fireHook(from: CircuitState, to: CircuitState): void {\n\t\ttry {\n\t\t\tthis._onStateChange?.(from, to, this.name);\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t}\n}\n",
+    "/**\n * `Bulkhead` — concurrency limiter with optional queue.\n *\n *   import { Bulkhead } from \"@nexusts/resilience\";\n *\n *   const api = new Bulkhead({ maxConcurrent: 5, maxQueued: 100 });\n *\n *   const result = await api.execute(() => fetch(\"...\"));\n *\n * Behavior:\n *   - `maxConcurrent`: how many `execute()` calls may be in-flight at once.\n *   - `maxQueued`: how many additional callers may wait in the queue\n *     for a free slot.\n *   - `rejectOnFull` (default false): when the queue is full, reject\n *     immediately with `BulkheadFullError` instead of waiting.\n *\n * The bulkhead is fair: callers are released in FIFO order. Each\n * waiter carries its own resolver; when a slot frees up we wake the\n * next waiter in the queue, who then re-enters and runs its function.\n */\nimport type { BulkheadConfig } from \"./types.js\";\n\nconst DEFAULTS = {\n\tmaxConcurrent: 10,\n\tmaxQueued: 100,\n\trejectOnFull: false,\n};\n\n/** Thrown when `rejectOnFull` is set and the queue is at capacity. */\nexport class BulkheadFullError extends Error {\n\treadonly name = \"BulkheadFullError\";\n\tconstructor(public readonly name_: string) {\n\t\tsuper(`Bulkhead \"${name_}\" is at capacity`);\n\t}\n}\n\n/** A queued caller. Resolves when this caller gets a slot. */\ninterface SlotToken {\n\t/** Acquired by the drain loop when a slot opens. */\n\tacquired: boolean;\n\t/** Cancelled before we got a slot. */\n\tcancelled: boolean;\n\tresolve: () => void;\n\treject: (e: unknown) => void;\n}\n\nexport class Bulkhead {\n\treadonly name: string;\n\treadonly config: Required<Omit<BulkheadConfig, \"name\">>;\n\n\tprivate inFlight = 0;\n\tprivate queue: SlotToken[] = [];\n\n\tconstructor(config: BulkheadConfig = {}) {\n\t\tthis.name = config.name ?? \"bulkhead\";\n\t\tthis.config = {\n\t\t\tmaxConcurrent: config.maxConcurrent ?? DEFAULTS.maxConcurrent,\n\t\t\tmaxQueued: config.maxQueued ?? DEFAULTS.maxQueued,\n\t\t\trejectOnFull: config.rejectOnFull ?? DEFAULTS.rejectOnFull,\n\t\t};\n\t}\n\n\tget stats(): { inFlight: number; queued: number } {\n\t\treturn { inFlight: this.inFlight, queued: this.queue.length };\n\t}\n\n\t/** Run `fn` through the bulkhead. */\n\tasync execute<T>(fn: () => Promise<T> | T): Promise<T> {\n\t\t// Fast path: a slot is free.\n\t\tif (this.inFlight < this.config.maxConcurrent) {\n\t\t\tthis.inFlight += 1;\n\t\t\ttry {\n\t\t\t\treturn await fn();\n\t\t\t} finally {\n\t\t\t\tthis.inFlight -= 1;\n\t\t\t\tthis.drain();\n\t\t\t}\n\t\t}\n\n\t\t// No slot — wait for one.\n\t\tif (this.queue.length >= this.config.maxQueued) {\n\t\t\tthrow new BulkheadFullError(this.name);\n\t\t}\n\n\t\tconst token = this.enqueue();\n\t\ttry {\n\t\t\tawait token.acquire();\n\t\t} catch (err) {\n\t\t\t// Cancelled or aborted — drop the token and re-throw.\n\t\t\tthrow err;\n\t\t}\n\t\t// Slot acquired. Run and release on completion.\n\t\tthis.inFlight += 1;\n\t\ttry {\n\t\t\treturn await fn();\n\t\t} finally {\n\t\t\tthis.inFlight -= 1;\n\t\t\tthis.drain();\n\t\t}\n\t}\n\n\t/** Allocate a slot token, joining the FIFO queue. */\n\tprivate enqueue(): SlotToken & { acquire(): Promise<void> } {\n\t\tlet resolve!: () => void;\n\t\tlet reject!: (e: unknown) => void;\n\t\tconst promise = new Promise<void>((res, rej) => {\n\t\t\tresolve = res;\n\t\t\treject = rej;\n\t\t});\n\t\tconst token: SlotToken = {\n\t\t\tacquired: false,\n\t\t\tcancelled: false,\n\t\t\tresolve,\n\t\t\treject,\n\t\t};\n\t\tthis.queue.push(token);\n\t\treturn Object.assign(promise as never, {\n\t\t\tacquire: () => promise,\n\t\t\tcancel: () => {\n\t\t\t\tif (token.acquired) return;\n\t\t\t\ttoken.cancelled = true;\n\t\t\t\ttoken.reject(new DOMException(\"Cancelled\", \"AbortError\"));\n\t\t\t},\n\t\t});\n\t}\n\n\t/** Release a slot by waking the next waiter. Idempotent. */\n\tprivate drain(): void {\n\t\twhile (\n\t\t\tthis.inFlight < this.config.maxConcurrent &&\n\t\t\tthis.queue.length > 0\n\t\t) {\n\t\t\tconst next = this.queue.shift()!;\n\t\t\tif (next.cancelled) continue;\n\t\t\tnext.acquired = true;\n\t\t\tnext.resolve();\n\t\t\treturn; // Only one slot opens per drain call.\n\t\t}\n\t}\n}\n",
+    "/**\n * `ResilienceService` — owns the named circuit-breaker and bulkhead\n * registry. Exposed via DI so multiple parts of an app can share\n * the same circuit for an external dependency.\n *\n *   constructor(@Inject(ResilienceService.TOKEN) private r: ResilienceService) {}\n *\n *   const cb = this.r.getOrCreateCircuit(\"stripe\", { threshold: 0.5 });\n *   const result = await cb.execute(() => stripeApi.charge(...));\n *\n * The service also holds the *default* config (RetryConfig,\n * CircuitBreakerConfig, BulkheadConfig) used by the decorators\n * when no per-call options are given.\n */\nimport \"reflect-metadata\";\nimport { Inject, Injectable } from \"@nexusts/core/decorators/index.js\";\nimport { CircuitBreaker } from \"./circuit-breaker.js\";\nimport { Bulkhead } from \"./bulkhead.js\";\nimport { retry } from \"./retry.js\";\nimport type {\n\tBackoffStrategy,\n\tBulkheadConfig,\n\tCircuitBreakerConfig,\n\tResilienceConfig,\n\tRetryConfig,\n} from \"./types.js\";\n\n@Injectable()\nexport class ResilienceService {\n\t/** DI token — `@Inject(ResilienceService.TOKEN)`. */\n\tstatic readonly TOKEN = Symbol.for(\"nexus:ResilienceService\");\n\n\treadonly defaults: {\n\t\tretry: Required<RetryConfig>;\n\t\tcircuit: Required<CircuitBreakerConfig>;\n\t\tbulkhead: Required<BulkheadConfig>;\n\t};\n\n\tprivate circuits = new Map<string, CircuitBreaker>();\n\tprivate bulkheads = new Map<string, Bulkhead>();\n\n\tconstructor(@Inject(\"RESILIENCE_CONFIG\") config: ResilienceConfig = {}) {\n\t\tthis.defaults = {\n\t\t\tretry: {\n\t\t\t\tattempts: 3,\n\t\t\t\tinitialDelay: 100,\n\t\t\t\tmaxDelay: 30_000,\n\t\t\t\tbackoff: \"exponential-jitter\",\n\t\t\t\tmultiplier: 2,\n\t\t\t\t...config.retry,\n\t\t\t} as Required<RetryConfig>,\n\t\t\tcircuit: {\n\t\t\t\tthreshold: 0.5,\n\t\t\t\tminCalls: 5,\n\t\t\t\ttimeout: 30_000,\n\t\t\t\thalfOpenAfter: 1,\n\t\t\t\twindow: 60_000,\n\t\t\t\t...config.circuit,\n\t\t\t} as Required<CircuitBreakerConfig>,\n\t\t\tbulkhead: {\n\t\t\t\tmaxConcurrent: 10,\n\t\t\t\tmaxQueued: 100,\n\t\t\t\trejectOnFull: false,\n\t\t\t\t...config.bulkhead,\n\t\t\t} as Required<BulkheadConfig>,\n\t\t};\n\t}\n\n\t/** Get or create a named circuit breaker. Shared across the app. */\n\tgetOrCreateCircuit(name: string, config: CircuitBreakerConfig = {}): CircuitBreaker {\n\t\tlet cb = this.circuits.get(name);\n\t\tif (!cb) {\n\t\t\tcb = new CircuitBreaker(name, { ...this.defaults.circuit, ...config });\n\t\t\tthis.circuits.set(name, cb);\n\t\t}\n\t\treturn cb;\n\t}\n\n\t/** Get or create a named bulkhead. */\n\tgetOrCreateBulkhead(name: string, config: BulkheadConfig = {}): Bulkhead {\n\t\tlet bh = this.bulkheads.get(name);\n\t\tif (!bh) {\n\t\t\t// Merge: explicit config overrides defaults, except for\n\t\t\t// `name` (always use the caller's name). Strip `name` from\n\t\t\t// the defaults before spreading to avoid a duplicate.\n\t\t\tconst { name: _ignored, ...defaultRest } = this.defaults.bulkhead as BulkheadConfig;\n\t\t\tvoid _ignored;\n\t\t\tbh = new Bulkhead({ ...defaultRest, ...config, name });\n\t\t\tthis.bulkheads.set(name, bh);\n\t\t}\n\t\treturn bh;\n\t}\n\n\t/** Look up an existing circuit (no creation). */\n\tgetCircuit(name: string): CircuitBreaker | undefined {\n\t\treturn this.circuits.get(name);\n\t}\n\n\t/** Look up an existing bulkhead. */\n\tgetBulkhead(name: string): Bulkhead | undefined {\n\t\treturn this.bulkheads.get(name);\n\t}\n\n\t/** Retry with default config. */\n\tretry<T>(fn: (signal: AbortSignal) => Promise<T> | T, cfg?: RetryConfig): Promise<T> {\n\t\treturn retry(fn, { ...this.defaults.retry, ...cfg });\n\t}\n\n\t/** Compute the backoff for a given attempt. Exposed for tests. */\n\tcomputeBackoff(attempt: number, overrides?: Partial<RetryConfig>): number {\n\t\tconst cfg = { ...this.defaults.retry, ...overrides };\n\t\t// Local copy of the same algorithm — kept here to avoid\n\t\t// importing from retry.ts just for the math.\n\t\tconst { initialDelay, maxDelay, multiplier } = cfg;\n\t\tconst backoff: BackoffStrategy = cfg.backoff;\n\t\tlet raw: number;\n\t\tswitch (backoff) {\n\t\t\tcase \"constant\":\n\t\t\t\traw = initialDelay;\n\t\t\t\tbreak;\n\t\t\tcase \"linear\":\n\t\t\t\traw = initialDelay * attempt;\n\t\t\t\tbreak;\n\t\t\tcase \"exponential\":\n\t\t\t\traw = initialDelay * Math.pow(multiplier, attempt - 1);\n\t\t\t\tbreak;\n\t\t\tcase \"exponential-jitter\":\n\t\t\t\traw = Math.random() * initialDelay * Math.pow(multiplier, attempt - 1);\n\t\t\t\tbreak;\n\t\t}\n\t\treturn Math.min(raw, maxDelay);\n\t}\n}\n",
+    "/**\n * `ResilienceModule` — drop-in DI for the resilience primitives.\n *\n *   @Module({\n *     imports: [\n *       ResilienceModule.forRoot({\n *         retry: { attempts: 3, backoff: \"exponential-jitter\" },\n *         circuit: { threshold: 0.5, timeout: 30_000 },\n *       }),\n *     ],\n *   })\n *   class AppModule {}\n *\n * After boot, the service is available as `@Inject(ResilienceService.TOKEN)`\n * — controllers can call `svc.getOrCreateCircuit(\"stripe\")` to share\n * a circuit breaker with the rest of the app.\n *\n * The decorators (`@Retry`, `@CircuitBreaker`, `@Bulkhead`,\n * `@Resilient`) work without the module — they pick up the\n * service from the DI container at controller-mount time.\n */\nimport { Module } from \"@nexusts/core/decorators/module.js\";\nimport { ResilienceService } from \"./resilience.service.js\";\nimport { setResilienceService } from \"./decorators/index.js\";\nimport type { ResilienceConfig } from \"./types.js\";\n\n@Module({\n\tproviders: [\n\t\tResilienceService,\n\t\t{ provide: ResilienceService.TOKEN, useExisting: ResilienceService },\n\t],\n\texports: [ResilienceService, ResilienceService.TOKEN],\n})\nexport class ResilienceModule {\n\tstatic forRoot(config: ResilienceConfig = {}) {\n\t\t@Module({\n\t\t\tproviders: [\n\t\t\t\t{\n\t\t\t\t\tprovide: ResilienceService.TOKEN,\n\t\t\t\t\tuseFactory: () => {\n\t\t\t\t\t\tconst svc = new ResilienceService(config);\n\t\t\t\t\t\t// Register globally so the eager-decorator path\n\t\t\t\t\t\t// (in `decorators/index.ts`) can find us without\n\t\t\t\t\t\t// needing each controller method to carry an\n\t\t\t\t\t\t// `@Inject(ResilienceService.TOKEN)` argument.\n\t\t\t\t\t\tsetResilienceService(svc);\n\t\t\t\t\t\treturn svc;\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tprovide: \"RESILIENCE_CONFIG\",\n\t\t\t\t\tuseValue: config,\n\t\t\t\t},\n\t\t\t],\n\t\t\texports: [ResilienceService.TOKEN, \"RESILIENCE_CONFIG\"],\n\t\t})\n\t\tclass ConfiguredResilienceModule {}\n\t\tObject.defineProperty(ConfiguredResilienceModule, \"name\", {\n\t\t\tvalue: \"ConfiguredResilienceModule\",\n\t\t});\n\t\treturn ConfiguredResilienceModule;\n\t}\n}\n",
+    "/**\n * Decorator barrel for `nexusjs/resilience`.\n *\n * The three method decorators (`@Retry`, `@CircuitBreaker`,\n * `@Bulkhead`) plus the combined `@Resilient` decorator are\n * implemented as **metadata-only** decorators — they write options\n * to the method's `reflect-metadata` store, and an\n * `ResilienceInterceptor` (or a runtime hook) reads and applies\n * them at call time.\n *\n *   @Retry({ attempts: 3, backoff: \"exponential\" })\n *   async fetchUser(id: string) { ... }\n *\n *   @CircuitBreaker({ threshold: 0.5, timeout: 30_000 })\n *   async callStripe() { ... }\n *\n *   @Bulkhead({ maxConcurrent: 5 })\n *   async callExpensive() { ... }\n *\n *   @Resilient({ retry: {...}, circuit: {...}, bulkhead: {...} })\n *   async criticalCall() { ... }\n */\nimport \"reflect-metadata\";\nimport type {\n\tBulkheadConfig,\n\tCircuitBreakerConfig,\n\tResilientConfig,\n\tRetryConfig,\n} from \"../types.js\";\nimport { RESILIENCE_META } from \"../types.js\";\n\n// Use `import type` for the service to avoid a circular import:\n// `resilience.service.ts` → `decorators/index.ts` → `resilience.service.ts`.\n// At runtime, the dependency is set via `setResilienceService()` so\n// only the *type* needs to be visible at type-check time.\nimport type { ResilienceService } from \"../resilience.service.js\";\n\n// Per-method metadata kinds. Each decorator stores its own\n// payload under a separate key so a method can have e.g. `@Retry`\n// and `@CircuitBreaker` simultaneously.\nconst KEY_RETRY = Symbol.for(\"nexus:Resilience:Retry\");\nconst KEY_CIRCUIT = Symbol.for(\"nexus:Resilience:Circuit\");\nconst KEY_BULKHEAD = Symbol.for(\"nexus:Resilience:Bulkhead\");\nconst KEY_RESILIENT = Symbol.for(\"nexus:Resilience:Resilient\");\n\nexport interface RetryMeta {\n\tconfig: RetryConfig;\n\t/** Captured bound `this` at call time. */\n}\nexport interface CircuitMeta {\n\tconfig: CircuitBreakerConfig;\n}\nexport interface BulkheadMeta {\n\tconfig: BulkheadConfig;\n}\nexport interface ResilientMeta {\n\tconfig: ResilientConfig;\n}\n\n/** Read the metadata for a given method. */\nexport function getMethodRetry(\n\ttarget: object,\n\tpropertyKey: string | symbol,\n): RetryConfig | undefined {\n\treturn Reflect.getMetadata(KEY_RETRY, target, propertyKey) as RetryConfig | undefined;\n}\n\nexport function getMethodCircuit(\n\ttarget: object,\n\tpropertyKey: string | symbol,\n): CircuitBreakerConfig | undefined {\n\treturn Reflect.getMetadata(KEY_CIRCUIT, target, propertyKey) as\n\t\t| CircuitBreakerConfig\n\t\t| undefined;\n}\n\nexport function getMethodBulkhead(\n\ttarget: object,\n\tpropertyKey: string | symbol,\n): BulkheadConfig | undefined {\n\treturn Reflect.getMetadata(KEY_BULKHEAD, target, propertyKey) as\n\t\t| BulkheadConfig\n\t\t| undefined;\n}\n\nexport function getMethodResilient(\n\ttarget: object,\n\tpropertyKey: string | symbol,\n): ResilientConfig | undefined {\n\treturn Reflect.getMetadata(KEY_RESILIENT, target, propertyKey) as\n\t\t| ResilientConfig\n\t\t| undefined;\n}\n\n// ============================================================================\n// Decorator factories\n// ============================================================================\n\nfunction makeMethodDecorator<TConfig>(\n\tkey: symbol,\n\textract: (config: TConfig) => unknown,\n): (config: TConfig) => MethodDecorator {\n\treturn (config: TConfig): MethodDecorator => {\n\t\treturn (\n\t\t\t_target: object,\n\t\t\tpropertyKey: string | symbol,\n\t\t\t_descriptor: TypedPropertyDescriptor<any>,\n\t\t): void => {\n\t\t\t// Metadata-only — we don't touch `descriptor.value`\n\t\t\t// here because Bun 1.3's stage-3 decorator mode (the\n\t\t\t// default) doesn't pass it. Instead, the framework\n\t\t\t// reads the metadata at controller-mount time and\n\t\t\t// calls `applyResilience()` to wrap the method.\n\t\t\tReflect.defineMetadata(key, extract(config), _target, propertyKey);\n\t\t};\n\t};\n}\n\n// Used by `applyResilience()` below (exported for users who want\n// to wire it into their own framework hook). Not invoked from the\n// decorator factories themselves — that would require reading\n// `descriptor.value` in the decorator body, which Bun's stage-3\n// decorator mode (the default in Bun 1.3+) doesn't supply.\nexport function getResilientMetadata(target: object, propertyKey: string | symbol) {\n\tconst resilient = getMethodResilient(target, propertyKey);\n\tconst retry = resilient?.retry ?? getMethodRetry(target, propertyKey);\n\tconst circuit = resilient?.circuit ?? getMethodCircuit(target, propertyKey);\n\tconst bulkhead = resilient?.bulkhead ?? getMethodBulkhead(target, propertyKey);\n\treturn { retry, circuit, bulkhead };\n}\n\n// Used by `applyResilience()` below; same rationale as above.\nexport function makeResilientWrapper(\n\toriginal: Function,\n\tresolveMeta: () => {\n\t\tretry?: RetryConfig;\n\t\tcircuit?: CircuitBreakerConfig;\n\t\tbulkhead?: BulkheadConfig;\n\t},\n): Function {\n\treturn function (this: unknown, ...args: any[]) {\n\t\tconst meta = resolveMeta();\n\t\tif (!meta.retry && !meta.circuit && !meta.bulkhead) {\n\t\t\treturn original.apply(this, args);\n\t\t}\n\t\tconst svc = getResilienceService();\n\t\tif (!svc) {\n\t\t\treturn original.apply(this, args);\n\t\t}\n\t\tconst name = original.name || \"anonymous\";\n\n\t\tconst fn = () => original.apply(this, args);\n\t\tconst runOnce = () =>\n\t\t\tmeta.bulkhead\n\t\t\t\t? svc.getOrCreateBulkhead(name, meta.bulkhead).execute(fn)\n\t\t\t\t: fn();\n\t\tconst runWithCircuit = () =>\n\t\t\tmeta.circuit\n\t\t\t\t? svc.getOrCreateCircuit(name, meta.circuit).execute(runOnce)\n\t\t\t\t: runOnce();\n\t\tconst runWithRetry = () =>\n\t\t\tmeta.retry ? svc.retry(runWithCircuit, meta.retry) : runWithCircuit();\n\n\t\treturn runWithRetry();\n\t};\n}\n\n/**\n * Module-level handle to the `ResilienceService`. Set by\n * `ResilienceModule.forRoot()` so the eager-decorator path can\n * access the registry without each method carrying the DI token.\n */\nlet _resilienceService: ResilienceService | null = null;\n\n/** Public — used by `ResilienceModule` to register the service. */\nexport function setResilienceService(svc: ResilienceService | null): void {\n\t_resilienceService = svc;\n}\n\n/** Public — used by the eager decorator path. */\nexport function getResilienceService(): ResilienceService | null {\n\treturn _resilienceService;\n}\n\n/** `@Retry(config)` — retry the method with backoff. */\nexport const Retry = makeMethodDecorator<RetryConfig>(KEY_RETRY, (c) => c);\n\n/** `@CircuitBreaker(config)` — wrap the method in a named circuit. */\nexport const CircuitBreaker = makeMethodDecorator<CircuitBreakerConfig>(\n\tKEY_CIRCUIT,\n\t(c) => c,\n);\n\n/** `@Bulkhead(config)` — limit concurrency for the method. */\nexport const Bulkhead = makeMethodDecorator<BulkheadConfig>(KEY_BULKHEAD, (c) => c);\n\n/** `@Resilient(config)` — combine retry + circuit + bulkhead. */\nexport const Resilient = makeMethodDecorator<ResilientConfig>(\n\tKEY_RESILIENT,\n\t(c) => c,\n);\n\n// ============================================================================\n// `applyResilience()` — runtime hook\n// ============================================================================\n\n/**\n * Read all `@Resilient` / `@Retry` / `@CircuitBreaker` / `@Bulkhead`\n * metadata on `target` and apply the corresponding wrappers around\n * `descriptor.value`. The framework wires this up via\n * `ResilienceService` when controllers are mounted.\n */\nexport function applyResilience(\n\ttarget: object,\n\tpropertyKey: string | symbol,\n\tdescriptor: TypedPropertyDescriptor<any>,\n\tsvc: import(\"../resilience.service.js\").ResilienceService,\n): TypedPropertyDescriptor<any> {\n\tif (!descriptor.value || typeof descriptor.value !== \"function\") {\n\t\treturn descriptor;\n\t}\n\tconst original = descriptor.value;\n\n\tconst resilient = getMethodResilient(target, propertyKey);\n\tconst retry = resilient?.retry ?? getMethodRetry(target, propertyKey);\n\tconst circuit = resilient?.circuit ?? getMethodCircuit(target, propertyKey);\n\tconst bulkhead = resilient?.bulkhead ?? getMethodBulkhead(target, propertyKey);\n\n\tif (!retry && !circuit && !bulkhead) {\n\t\treturn descriptor; // No resilience — leave the method alone.\n\t}\n\n\tconst wrapped = async function (this: unknown, ...args: any[]) {\n\t\tconst name = String(propertyKey);\n\t\tconst fn = () => original.apply(this, args);\n\n\t\tconst runOnce = async () => {\n\t\t\tif (bulkhead) {\n\t\t\t\tconst bh = svc.getOrCreateBulkhead(name, bulkhead);\n\t\t\t\treturn bh.execute(fn);\n\t\t\t}\n\t\t\treturn fn();\n\t\t};\n\n\t\tconst runWithCircuit = async () => {\n\t\t\tif (circuit) {\n\t\t\t\tconst cb = svc.getOrCreateCircuit(name, circuit);\n\t\t\t\treturn cb.execute(runOnce);\n\t\t\t}\n\t\t\treturn runOnce();\n\t\t};\n\n\t\tconst runWithRetry = async () => {\n\t\t\tif (retry) {\n\t\t\t\treturn svc.retry(runWithCircuit, retry);\n\t\t\t}\n\t\t\treturn runWithCircuit();\n\t\t};\n\n\t\treturn runWithRetry();\n\t};\n\n\treturn {\n\t\t...descriptor,\n\t\tvalue: wrapped,\n\t};\n}\n\n// Re-export the meta key for tests.\nexport { RESILIENCE_META };\n"
+  ],
+  "mappings": "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",
+  "debugId": "2E949C7E6C6632FA64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@nexusts/resilience",
+  "version": "0.7.0",
+  "description": "Retry + Circuit Breaker + Bulkhead",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run ../../build.ts"
+  },
+  "keywords": [
+    "nexusts",
+    "framework",
+    "bun"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@nexusts/core": "^0.7.0"
+  }
+}