@gkoos/caracal 0.1.0

package/dist/index.js

@@ -0,0 +1,1065 @@
+import { admissionSignal, emitRuntimeEvent, nextAttempt, withAdmissionSignal, withSignal } from './chunk-5CXDW7W6.js';
+export { operation } from './chunk-5CXDW7W6.js';
+import { randomUUID } from 'crypto';
+
+var BulkheadRejectedError = class extends Error {
+  constructor(coordination, policyName, scope, reason) {
+    super(`Bulkhead ${policyName} rejected: ${reason}`);
+    this.coordination = coordination;
+    this.policyName = policyName;
+    this.scope = scope;
+    this.reason = reason;
+    this.name = "BulkheadRejectedError";
+  }
+  coordination;
+  policyName;
+  scope;
+  reason;
+};
+function validate(name, limit) {
+  if (!name.trim() || !Number.isSafeInteger(limit) || limit < 1)
+    throw new RangeError("Bulkhead needs a name and positive integer limit");
+}
+function event(context, coordination, policyName, scope, type, occupancy, reason) {
+  emitRuntimeEvent(context, {
+    type: `bulkhead.${type}`,
+    coordination,
+    policyName,
+    scope,
+    ...occupancy === void 0 ? {} : { occupancy },
+    ...reason === void 0 ? {} : { reason }
+  });
+}
+function local(options) {
+  const { name, limit } = options;
+  const queue = options.queue && { ...options.queue };
+  validate(name, limit);
+  if (queue && (!Number.isSafeInteger(queue.limit) || queue.limit < 1 || !Number.isSafeInteger(queue.timeoutMs) || queue.timeoutMs < 1 || queue.timeoutMs > 2147483647))
+    throw new RangeError("Invalid bounded queue");
+  let occupancy = 0;
+  const waiting = [];
+  return Object.freeze({
+    name,
+    phase: "attempt",
+    coordination: "local",
+    snapshot: () => ({
+      coordination: "local",
+      occupancy,
+      waiting: waiting.length
+    }),
+    async execute(context, next) {
+      const signal = admissionSignal(context);
+      signal?.throwIfAborted();
+      const reject = (reason) => {
+        event(context, "local", name, "process", "rejected", occupancy, reason);
+        return new BulkheadRejectedError("local", name, "process", reason);
+      };
+      if (occupancy >= limit) {
+        if (!queue || waiting.length >= queue.limit) throw reject("capacity");
+        event(context, "local", name, "process", "waited", occupancy);
+        await new Promise((resolve, fail) => {
+          const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            const i = waiting.indexOf(grant);
+            if (i >= 0) waiting.splice(i, 1);
+          };
+          const grant = () => {
+            cleanup();
+            occupancy++;
+            resolve();
+          };
+          const abort = () => {
+            cleanup();
+            event(
+              context,
+              "local",
+              name,
+              "process",
+              "rejected",
+              occupancy,
+              "cancelled"
+            );
+            fail(signal?.reason);
+          };
+          const timer = setTimeout(() => {
+            cleanup();
+            fail(reject("wait-timeout"));
+          }, queue.timeoutMs);
+          waiting.push(grant);
+          signal?.addEventListener("abort", abort, { once: true });
+          if (signal?.aborted) abort();
+        });
+      } else occupancy++;
+      event(context, "local", name, "process", "admitted", occupancy);
+      try {
+        signal?.throwIfAborted();
+        return await next(context);
+      } finally {
+        occupancy--;
+        waiting[0]?.();
+        event(context, "local", name, "process", "released", occupancy);
+      }
+    }
+  });
+}
+function distributed(options) {
+  const {
+    name,
+    limit,
+    coordinator,
+    scope: resolveScope,
+    leaseMs = 3e4
+  } = options;
+  validate(name, limit);
+  if (!Number.isSafeInteger(leaseMs) || leaseMs < 100 || leaseMs > 864e5)
+    throw new RangeError("leaseMs must be 100..86400000");
+  return Object.freeze({
+    name,
+    phase: "attempt",
+    coordination: "distributed",
+    async execute(context, next) {
+      admissionSignal(context)?.throwIfAborted();
+      const scope = resolveScope(context);
+      if (typeof scope !== "string" || !scope.trim())
+        throw new TypeError("Invalid bulkhead scope");
+      const identity = { name, operation: context.operationName, scope };
+      const token = randomUUID();
+      const command = (action) => coordinator.command(identity, action, token, leaseMs, limit);
+      let admitted;
+      const started = performance.now();
+      try {
+        admitted = await command("acquire");
+      } catch (error) {
+        event(
+          context,
+          "distributed",
+          name,
+          scope,
+          "degraded",
+          void 0,
+          "admission-unknown"
+        );
+        event(
+          context,
+          "distributed",
+          name,
+          scope,
+          "rejected",
+          void 0,
+          "coordinator-unavailable"
+        );
+        throw error;
+      }
+      if (!admitted.allowed) {
+        event(
+          context,
+          "distributed",
+          name,
+          scope,
+          "rejected",
+          admitted.occupancy,
+          "capacity"
+        );
+        throw new BulkheadRejectedError("distributed", name, scope, "capacity");
+      }
+      let stopped = false;
+      let lost = false;
+      let timer;
+      let deadlineTimer;
+      let deadline = started + leaseMs;
+      const controller = new AbortController();
+      const lose = () => {
+        if (lost || stopped) return;
+        lost = true;
+        clearTimeout(timer);
+        event(context, "distributed", name, scope, "lease-lost");
+        event(
+          context,
+          "distributed",
+          name,
+          scope,
+          "degraded",
+          void 0,
+          "lease-uncertain"
+        );
+        controller.abort(
+          new BulkheadRejectedError("distributed", name, scope, "lease-lost")
+        );
+      };
+      const watch = () => {
+        clearTimeout(deadlineTimer);
+        deadlineTimer = setTimeout(
+          lose,
+          Math.max(0, deadline - performance.now())
+        );
+      };
+      const renew = async () => {
+        const sent = performance.now();
+        try {
+          if (!(await command("renew")).allowed || performance.now() >= deadline) {
+            lose();
+            return;
+          }
+          deadline = sent + leaseMs;
+        } catch {
+          lose();
+          return;
+        }
+        if (!stopped && !lost) {
+          watch();
+          timer = setTimeout(() => void renew(), leaseMs / 3);
+        }
+      };
+      try {
+        if (performance.now() >= deadline)
+          throw new BulkheadRejectedError(
+            "distributed",
+            name,
+            scope,
+            "admission-expired"
+          );
+        admissionSignal(context)?.throwIfAborted();
+        event(
+          context,
+          "distributed",
+          name,
+          scope,
+          "admitted",
+          admitted.occupancy
+        );
+        watch();
+        timer = setTimeout(() => void renew(), leaseMs / 3);
+        return await next(
+          withAdmissionSignal(
+            context.capabilities.abort === "supported" ? withSignal(
+              context,
+              context.signal ? AbortSignal.any([context.signal, controller.signal]) : controller.signal
+            ) : context,
+            controller.signal
+          )
+        );
+      } finally {
+        stopped = true;
+        clearTimeout(timer);
+        clearTimeout(deadlineTimer);
+        try {
+          const result = await command("release");
+          event(
+            context,
+            "distributed",
+            name,
+            scope,
+            "released",
+            result.occupancy,
+            result.allowed ? void 0 : "already-expired-or-released"
+          );
+        } catch {
+          event(
+            context,
+            "distributed",
+            name,
+            scope,
+            "degraded",
+            void 0,
+            "release-unknown"
+          );
+        }
+      }
+    }
+  });
+}
+var bulkhead = Object.freeze({ local, distributed });
+
+// src/core/scope-state-cache.ts
+function createScopeStateCache() {
+  const retained = /* @__PURE__ */ new Map();
+  const keyFor = (operation2, scope) => JSON.stringify([operation2, scope]);
+  return {
+    remember(operation2, scope, state) {
+      retained.set(keyFor(operation2, scope), state);
+    },
+    forget(operation2, scope) {
+      retained.delete(keyFor(operation2, scope));
+    },
+    read(operation2, scope) {
+      return retained.get(keyFor(operation2, scope));
+    },
+    size() {
+      return retained.size;
+    }
+  };
+}
+
+// src/core/circuit-breaker.ts
+function classifyOutcome(context, classifier, outcome) {
+  if (classifier !== void 0) {
+    return classifier(
+      outcome.status === "failure" ? outcome.error : void 0,
+      outcome.status === "success"
+    );
+  }
+  const classification2 = context.classify(outcome);
+  return classification2 === "retryable" ? "failure" : classification2;
+}
+var CircuitOpenError = class extends Error {
+  constructor(policyName, coordination, scope) {
+    super(`Circuit ${policyName} is open for scope "${scope}"`);
+    this.policyName = policyName;
+    this.coordination = coordination;
+    this.scope = scope;
+    this.name = "CircuitOpenError";
+  }
+  policyName;
+  coordination;
+  scope;
+};
+var DEFAULT_MINIMUM_THROUGHPUT = 5;
+var DEFAULT_FAILURE_THRESHOLD = 0.5;
+var DEFAULT_OPEN_MS = 1e4;
+var DEFAULT_HALF_OPEN_SUCCESSES = 1;
+var DEFAULT_HALF_OPEN_PROBES = 1;
+var DEFAULT_WINDOW_SIZE = 100;
+function validate2(opts) {
+  if (!opts.name.trim())
+    throw new RangeError("Circuit breaker name must not be empty");
+  const { minimumThroughput = DEFAULT_MINIMUM_THROUGHPUT } = opts;
+  if (!Number.isInteger(minimumThroughput) || minimumThroughput < 1)
+    throw new RangeError("minimumThroughput must be a positive integer");
+  const { failureThreshold = DEFAULT_FAILURE_THRESHOLD } = opts;
+  if (!Number.isFinite(failureThreshold) || failureThreshold <= 0 || failureThreshold >= 1)
+    throw new RangeError("failureThreshold must be a number in (0, 1)");
+  const { openMs = DEFAULT_OPEN_MS } = opts;
+  if (!Number.isInteger(openMs) || openMs < 1)
+    throw new RangeError("openMs must be a positive integer");
+  const { halfOpenSuccesses = DEFAULT_HALF_OPEN_SUCCESSES } = opts;
+  if (!Number.isInteger(halfOpenSuccesses) || halfOpenSuccesses < 1)
+    throw new RangeError("halfOpenSuccesses must be a positive integer");
+  const { halfOpenProbes = DEFAULT_HALF_OPEN_PROBES } = opts;
+  if (!Number.isInteger(halfOpenProbes) || halfOpenProbes < 1)
+    throw new RangeError("halfOpenProbes must be a positive integer");
+  const { windowSize = DEFAULT_WINDOW_SIZE } = opts;
+  if (!Number.isInteger(windowSize) || windowSize < 1)
+    throw new RangeError("windowSize must be a positive integer");
+}
+var SlidingWindow = class {
+  #size;
+  #buf;
+  #head = 0;
+  #count = 0;
+  #failures = 0;
+  constructor(size) {
+    this.#size = size;
+    this.#buf = new Array(size).fill(false);
+  }
+  record(failure) {
+    const evicted = this.#buf[this.#head] === true;
+    if (this.#count === this.#size) {
+      if (evicted) this.#failures--;
+    } else {
+      this.#count++;
+    }
+    this.#buf[this.#head] = failure;
+    if (failure) this.#failures++;
+    this.#head = (this.#head + 1) % this.#size;
+  }
+  get count() {
+    return this.#count;
+  }
+  get failures() {
+    return this.#failures;
+  }
+  get successes() {
+    return this.#count - this.#failures;
+  }
+  reset() {
+    this.#buf.fill(false);
+    this.#head = 0;
+    this.#count = 0;
+    this.#failures = 0;
+  }
+};
+function local2(options) {
+  validate2(options);
+  const name = options.name;
+  const minimumThroughput = options.minimumThroughput ?? DEFAULT_MINIMUM_THROUGHPUT;
+  const failureThreshold = options.failureThreshold ?? DEFAULT_FAILURE_THRESHOLD;
+  const openMs = options.openMs ?? DEFAULT_OPEN_MS;
+  const halfOpenSuccessTarget = options.halfOpenSuccesses ?? DEFAULT_HALF_OPEN_SUCCESSES;
+  const halfOpenProbeLimit = options.halfOpenProbes ?? DEFAULT_HALF_OPEN_PROBES;
+  const windowSize = options.windowSize ?? DEFAULT_WINDOW_SIZE;
+  const classifier = options.classify;
+  let state = "closed";
+  let generation = 0;
+  let openedAt = 0;
+  let halfOpenSuccessCount = 0;
+  let halfOpenProbesInFlight = 0;
+  const window = new SlidingWindow(windowSize);
+  function transitionToOpen(context, previousState) {
+    state = "open";
+    generation++;
+    openedAt = Date.now();
+    halfOpenSuccessCount = 0;
+    halfOpenProbesInFlight = 0;
+    window.reset();
+    emitRuntimeEvent(context, {
+      type: "breaker.state-changed",
+      coordination: "local",
+      policyName: name,
+      scope: "process",
+      state: "open",
+      previousState
+    });
+  }
+  function transitionToHalfOpen(context) {
+    state = "half-open";
+    generation++;
+    halfOpenSuccessCount = 0;
+    halfOpenProbesInFlight = 0;
+    window.reset();
+    emitRuntimeEvent(context, {
+      type: "breaker.state-changed",
+      coordination: "local",
+      policyName: name,
+      scope: "process",
+      state: "half-open",
+      previousState: "open"
+    });
+  }
+  function transitionToClosed(context) {
+    state = "closed";
+    generation++;
+    halfOpenSuccessCount = 0;
+    halfOpenProbesInFlight = 0;
+    window.reset();
+    emitRuntimeEvent(context, {
+      type: "breaker.state-changed",
+      coordination: "local",
+      policyName: name,
+      scope: "process",
+      state: "closed",
+      previousState: "half-open"
+    });
+  }
+  function admit(context) {
+    if (state === "closed") return "closed";
+    if (state === "open") {
+      if (Date.now() - openedAt >= openMs) {
+        transitionToHalfOpen(context);
+      } else {
+        emitRuntimeEvent(context, {
+          type: "breaker.rejected",
+          coordination: "local",
+          policyName: name,
+          scope: "process",
+          state: "open"
+        });
+        return "rejected";
+      }
+    }
+    if (halfOpenProbesInFlight >= halfOpenProbeLimit) {
+      emitRuntimeEvent(context, {
+        type: "breaker.rejected",
+        coordination: "local",
+        policyName: name,
+        scope: "process",
+        state: "half-open"
+      });
+      return "rejected";
+    }
+    halfOpenProbesInFlight++;
+    emitRuntimeEvent(context, {
+      type: "breaker.probe-started",
+      coordination: "local",
+      policyName: name,
+      scope: "process"
+    });
+    return "half-open";
+  }
+  function observe(context, admitted, admittedGeneration, settled) {
+    if (admittedGeneration !== generation || admitted !== state) return;
+    const outcome = classifyOutcome(context, classifier, settled);
+    if (outcome === "ignored") {
+      if (admitted === "half-open") {
+        halfOpenProbesInFlight = Math.max(0, halfOpenProbesInFlight - 1);
+      }
+      return;
+    }
+    const failure = outcome === "failure";
+    emitRuntimeEvent(context, {
+      type: "breaker.observation",
+      coordination: "local",
+      policyName: name,
+      scope: "process",
+      outcome
+    });
+    if (admitted === "half-open") {
+      halfOpenProbesInFlight = Math.max(0, halfOpenProbesInFlight - 1);
+      if (failure) {
+        transitionToOpen(context, "half-open");
+        return;
+      }
+      halfOpenSuccessCount++;
+      if (halfOpenSuccessCount >= halfOpenSuccessTarget) {
+        transitionToClosed(context);
+      }
+      return;
+    }
+    window.record(failure);
+    if (window.count >= minimumThroughput && window.failures / window.count >= failureThreshold) {
+      transitionToOpen(context, "closed");
+    }
+  }
+  return Object.freeze({
+    name,
+    coordination: "local",
+    snapshot() {
+      return {
+        coordination: "local",
+        state,
+        failures: window.failures,
+        successes: window.successes,
+        observations: window.count,
+        probesInFlight: halfOpenProbesInFlight,
+        halfOpenSuccesses: halfOpenSuccessCount
+      };
+    },
+    async execute(context, next) {
+      const admitted = admit(context);
+      const admittedGeneration = generation;
+      if (admitted === "rejected") {
+        throw new CircuitOpenError(name, "local", "process");
+      }
+      let isSuccess = false;
+      let value;
+      let error;
+      try {
+        value = await next(context);
+        isSuccess = true;
+        return value;
+      } catch (err) {
+        error = err;
+        throw err;
+      } finally {
+        observe(
+          context,
+          admitted,
+          admittedGeneration,
+          isSuccess ? { status: "success", value } : { status: "failure", error }
+        );
+      }
+    }
+  });
+}
+var DEFAULT_DIST_MINIMUM_THROUGHPUT = 20;
+var DEFAULT_DIST_FAILURE_THRESHOLD = 0.5;
+var DEFAULT_DIST_WINDOW_SIZE = 100;
+var DEFAULT_DIST_OPEN_MS = 3e4;
+var DEFAULT_DIST_HALF_OPEN_PROBES = 3;
+var DEFAULT_DIST_HALF_OPEN_SUCCESSES = 2;
+var DEFAULT_DIST_ON_COORDINATOR_ERROR = "fail-open";
+function validateDistributed(opts) {
+  if (typeof opts.name !== "string" || !opts.name.trim())
+    throw new RangeError("Distributed circuit breaker name must not be empty");
+  if (!opts.coordinator || typeof opts.coordinator !== "object")
+    throw new TypeError("coordinator is required");
+  if (typeof opts.scope !== "function")
+    throw new TypeError("scope must be a function");
+  const { minimumThroughput = DEFAULT_DIST_MINIMUM_THROUGHPUT } = opts;
+  if (!Number.isInteger(minimumThroughput) || minimumThroughput < 1)
+    throw new RangeError("minimumThroughput must be a positive integer");
+  const { failureThreshold = DEFAULT_DIST_FAILURE_THRESHOLD } = opts;
+  if (!Number.isFinite(failureThreshold) || failureThreshold <= 0 || failureThreshold >= 1)
+    throw new RangeError("failureThreshold must be a number in (0, 1)");
+  const { openMs = DEFAULT_DIST_OPEN_MS } = opts;
+  if (!Number.isInteger(openMs) || openMs < 1)
+    throw new RangeError("openMs must be a positive integer");
+  const { halfOpenSuccesses = DEFAULT_DIST_HALF_OPEN_SUCCESSES } = opts;
+  if (!Number.isInteger(halfOpenSuccesses) || halfOpenSuccesses < 1)
+    throw new RangeError("halfOpenSuccesses must be a positive integer");
+  const { halfOpenProbes = DEFAULT_DIST_HALF_OPEN_PROBES } = opts;
+  if (!Number.isInteger(halfOpenProbes) || halfOpenProbes < 1)
+    throw new RangeError("halfOpenProbes must be a positive integer");
+  const { windowSize = DEFAULT_DIST_WINDOW_SIZE } = opts;
+  if (!Number.isInteger(windowSize) || windowSize < 1)
+    throw new RangeError("windowSize must be a positive integer");
+  if (opts.windowTtlMs !== void 0) {
+    if (!Number.isInteger(opts.windowTtlMs) || opts.windowTtlMs < 1)
+      throw new RangeError("windowTtlMs must be a positive integer");
+  }
+  if (opts.probeLeaseTtlMs !== void 0) {
+    if (!Number.isInteger(opts.probeLeaseTtlMs) || opts.probeLeaseTtlMs < 1)
+      throw new RangeError("probeLeaseTtlMs must be a positive integer");
+  }
+  if (opts.onCoordinatorError !== void 0 && opts.onCoordinatorError !== "fail-open" && opts.onCoordinatorError !== "fail-closed")
+    throw new TypeError(
+      'onCoordinatorError must be "fail-open" or "fail-closed"'
+    );
+}
+function distributed2(options) {
+  validateDistributed(options);
+  const name = options.name;
+  const coordinator = options.coordinator;
+  const resolveScope = options.scope;
+  const minimumThroughput = options.minimumThroughput ?? DEFAULT_DIST_MINIMUM_THROUGHPUT;
+  const failureThreshold = options.failureThreshold ?? DEFAULT_DIST_FAILURE_THRESHOLD;
+  const failureThresholdNumerator = Math.round(failureThreshold * 1e3);
+  const windowSize = options.windowSize ?? DEFAULT_DIST_WINDOW_SIZE;
+  const openMs = options.openMs ?? DEFAULT_DIST_OPEN_MS;
+  const windowTtlMs = options.windowTtlMs ?? Math.max(openMs * 3, 6e4);
+  const halfOpenProbes = options.halfOpenProbes ?? DEFAULT_DIST_HALF_OPEN_PROBES;
+  const halfOpenSuccesses = options.halfOpenSuccesses ?? DEFAULT_DIST_HALF_OPEN_SUCCESSES;
+  const probeLeaseTtlMs = options.probeLeaseTtlMs ?? openMs * 2;
+  const onCoordinatorError = options.onCoordinatorError ?? DEFAULT_DIST_ON_COORDINATOR_ERROR;
+  const classifier = options.classify;
+  const lastKnownState = createScopeStateCache();
+  return Object.freeze({
+    name,
+    coordination: "distributed",
+    async execute(context, next) {
+      const scope = resolveScope(context);
+      if (typeof scope !== "string" || !scope.trim())
+        throw new TypeError(
+          "circuitBreaker.distributed scope must be a non-empty string"
+        );
+      const identity = {
+        name,
+        operation: context.operationName,
+        scope
+      };
+      let stateData = null;
+      try {
+        stateData = await coordinator.readState(identity);
+        const observed = stateData?.state;
+        if (observed === "open" || observed === "half-open") {
+          lastKnownState.remember(identity.operation, scope, observed);
+        } else {
+          lastKnownState.forget(identity.operation, scope);
+        }
+      } catch (readError) {
+        emitRuntimeEvent(context, {
+          type: "breaker.coordinator-error",
+          coordination: "distributed",
+          policyName: name,
+          scope,
+          operation: "admit",
+          error: readError
+        });
+        const cached = lastKnownState.read(identity.operation, scope);
+        const effectiveBehavior = cached === "open" || cached === "half-open" ? "fail-closed" : onCoordinatorError;
+        emitRuntimeEvent(context, {
+          type: "breaker.degraded",
+          coordination: "distributed",
+          policyName: name,
+          scope,
+          reason: "coordinator-unavailable",
+          behavior: effectiveBehavior
+        });
+        if (effectiveBehavior === "fail-closed") {
+          emitRuntimeEvent(context, {
+            type: "breaker.rejected",
+            coordination: "distributed",
+            policyName: name,
+            scope,
+            state: "open"
+          });
+          throw new CircuitOpenError(name, "distributed", scope);
+        }
+        stateData = { state: "closed", generation: 0 };
+      }
+      const reportedState = stateData?.state ?? "closed";
+      const reportedGeneration = stateData?.generation ?? 0;
+      let admission;
+      if (reportedState === "closed") {
+        admission = { kind: "closed", generation: reportedGeneration };
+      } else {
+        const probeToken = randomUUID();
+        let probeResult;
+        try {
+          probeResult = await coordinator.admitProbe(identity, {
+            probeToken,
+            openMs,
+            halfOpenProbes,
+            probeLeaseTtlMs
+          });
+        } catch (admitError) {
+          emitRuntimeEvent(context, {
+            type: "breaker.coordinator-error",
+            coordination: "distributed",
+            policyName: name,
+            scope,
+            operation: "admit",
+            error: admitError
+          });
+          emitRuntimeEvent(context, {
+            type: "breaker.degraded",
+            coordination: "distributed",
+            policyName: name,
+            scope,
+            reason: "coordinator-unavailable",
+            behavior: "fail-closed"
+          });
+          emitRuntimeEvent(context, {
+            type: "breaker.rejected",
+            coordination: "distributed",
+            policyName: name,
+            scope,
+            state: reportedState === "open" ? "open" : "half-open"
+          });
+          throw new CircuitOpenError(name, "distributed", scope);
+        }
+        if (probeResult.type === "rejected") {
+          if (probeResult.reason === "closed") {
+            lastKnownState.forget(identity.operation, scope);
+            admission = { kind: "closed", generation: probeResult.generation };
+          } else {
+            const rejState = probeResult.reason === "open" ? "open" : "half-open";
+            emitRuntimeEvent(context, {
+              type: "breaker.rejected",
+              coordination: "distributed",
+              policyName: name,
+              scope,
+              state: rejState,
+              generation: probeResult.generation
+            });
+            throw new CircuitOpenError(name, "distributed", scope);
+          }
+        } else {
+          if (probeResult.stateChanged) {
+            lastKnownState.remember(identity.operation, scope, "half-open");
+            emitRuntimeEvent(context, {
+              type: "breaker.state-changed",
+              coordination: "distributed",
+              policyName: name,
+              scope,
+              state: "half-open",
+              previousState: "open",
+              generation: probeResult.generation
+            });
+          }
+          emitRuntimeEvent(context, {
+            type: "breaker.probe-started",
+            coordination: "distributed",
+            policyName: name,
+            scope,
+            generation: probeResult.generation
+          });
+          admission = {
+            kind: "probe",
+            probeToken,
+            generation: probeResult.generation
+          };
+        }
+      }
+      let isSuccess = false;
+      let value;
+      let thrownError;
+      try {
+        value = await next(context);
+        isSuccess = true;
+        return value;
+      } catch (err) {
+        thrownError = err;
+        throw err;
+      } finally {
+        const breakerOutcome = classifyOutcome(
+          context,
+          classifier,
+          isSuccess ? { status: "success", value } : { status: "failure", error: thrownError }
+        );
+        if (breakerOutcome !== "ignored") {
+          const outcomeStr = breakerOutcome === "success" ? "success" : "failure";
+          if (admission.kind === "closed") {
+            try {
+              const result = await coordinator.observe(identity, {
+                generation: admission.generation,
+                outcome: outcomeStr,
+                uuid: randomUUID(),
+                windowTtlMs,
+                minimumThroughput,
+                failureThresholdNumerator,
+                windowSize,
+                openMs
+              });
+              if (result.type === "stale") {
+                emitRuntimeEvent(context, {
+                  type: "breaker.observation-stale",
+                  coordination: "distributed",
+                  policyName: name,
+                  scope,
+                  attemptGeneration: admission.generation,
+                  currentGeneration: result.currentGeneration
+                });
+              } else {
+                emitRuntimeEvent(context, {
+                  type: "breaker.observation",
+                  coordination: "distributed",
+                  policyName: name,
+                  scope,
+                  outcome: outcomeStr,
+                  generation: admission.generation
+                });
+                if (result.type === "opened") {
+                  lastKnownState.remember(identity.operation, scope, "open");
+                  emitRuntimeEvent(context, {
+                    type: "breaker.state-changed",
+                    coordination: "distributed",
+                    policyName: name,
+                    scope,
+                    state: "open",
+                    previousState: "closed",
+                    generation: result.newGeneration
+                  });
+                }
+              }
+            } catch (observeError) {
+              emitRuntimeEvent(context, {
+                type: "breaker.coordinator-error",
+                coordination: "distributed",
+                policyName: name,
+                scope,
+                operation: "observe",
+                error: observeError
+              });
+            }
+          } else {
+            try {
+              const result = await coordinator.settleProbe(identity, {
+                probeToken: admission.probeToken,
+                outcome: outcomeStr,
+                generation: admission.generation,
+                halfOpenSuccesses,
+                openMs,
+                windowTtlMs
+              });
+              if (result.type === "stale") {
+                emitRuntimeEvent(context, {
+                  type: "breaker.observation-stale",
+                  coordination: "distributed",
+                  policyName: name,
+                  scope,
+                  attemptGeneration: admission.generation,
+                  currentGeneration: result.generation
+                });
+              } else {
+                emitRuntimeEvent(context, {
+                  type: "breaker.observation",
+                  coordination: "distributed",
+                  policyName: name,
+                  scope,
+                  outcome: outcomeStr,
+                  generation: admission.generation
+                });
+                if (result.type === "transitioned") {
+                  if (result.newState === "closed") {
+                    lastKnownState.forget(identity.operation, scope);
+                  } else {
+                    lastKnownState.remember(
+                      identity.operation,
+                      scope,
+                      result.newState
+                    );
+                  }
+                  emitRuntimeEvent(context, {
+                    type: "breaker.state-changed",
+                    coordination: "distributed",
+                    policyName: name,
+                    scope,
+                    state: result.newState,
+                    previousState: "half-open",
+                    generation: result.newGeneration
+                  });
+                }
+              }
+            } catch (settleError) {
+              emitRuntimeEvent(context, {
+                type: "breaker.coordinator-error",
+                coordination: "distributed",
+                policyName: name,
+                scope,
+                operation: "settle-probe",
+                error: settleError
+              });
+            }
+          }
+        }
+      }
+    }
+  });
+}
+var circuitBreaker = Object.freeze({ local: local2, distributed: distributed2 });
+
+// src/core/retry.ts
+function throwIfAborted(signal) {
+  if (!signal?.aborted) {
+    return;
+  }
+  throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+function retryContext(context, outcome) {
+  return {
+    outcome,
+    result: outcome.status === "success" ? outcome.value : void 0,
+    error: outcome.status === "failure" ? outcome.error : void 0,
+    capabilities: context.capabilities,
+    metadata: context.metadata
+  };
+}
+function delayFor(options, context, attempt, outcome) {
+  const configured = options.delay;
+  const delay = typeof configured === "function" ? configured(attempt, retryContext(context, outcome)) : configured ?? 0;
+  if (!Number.isFinite(delay) || delay < 0) {
+    throw new RangeError("retry delay must be a finite non-negative number");
+  }
+  return delay;
+}
+function wait(delayMs, signal) {
+  if (delayMs === 0) {
+    throwIfAborted(signal);
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(done, delayMs);
+    function done() {
+      signal?.removeEventListener("abort", aborted);
+      resolve();
+    }
+    function aborted() {
+      clearTimeout(timer);
+      reject(
+        signal?.reason ?? new DOMException("The operation was aborted", "AbortError")
+      );
+    }
+    if (signal?.aborted) {
+      aborted();
+      return;
+    }
+    signal?.addEventListener("abort", aborted, { once: true });
+  });
+}
+function summarized(outcome) {
+  return outcome.status === "success" ? { status: "success", value: void 0 } : { status: "failure", error: outcome.error };
+}
+function classification(context, outcome) {
+  return context.classify(outcome);
+}
+function retry(options) {
+  if (!Number.isInteger(options.maxAttempts) || options.maxAttempts < 1) {
+    throw new RangeError("maxAttempts must be a positive integer");
+  }
+  return Object.freeze({
+    name: "retry",
+    async execute(initialContext, next) {
+      let context = initialContext;
+      for (; ; ) {
+        throwIfAborted(admissionSignal(context));
+        try {
+          const value = await next(context);
+          const outcome = { status: "success", value };
+          const outcomeClassification = classification(context, outcome);
+          if (outcomeClassification !== "retryable" || context.capabilities.replay !== "safe") {
+            return value;
+          }
+          if (context.attempt >= options.maxAttempts) {
+            emitRuntimeEvent(context, {
+              type: "retry.exhausted",
+              outcome: summarized(outcome),
+              classification: outcomeClassification
+            });
+            return value;
+          }
+          const delayMs = delayFor(options, context, context.attempt, outcome);
+          emitRuntimeEvent(context, {
+            type: "retry.scheduled",
+            nextAttempt: context.attempt + 1,
+            delayMs,
+            outcome: summarized(outcome),
+            classification: outcomeClassification
+          });
+          await wait(delayMs, admissionSignal(context));
+          context = nextAttempt(context);
+        } catch (error) {
+          const outcome = { status: "failure", error };
+          const outcomeClassification = classification(context, outcome);
+          if (admissionSignal(context)?.aborted || context.capabilities.replay !== "safe" || outcomeClassification !== "retryable") {
+            throw error;
+          }
+          if (context.attempt >= options.maxAttempts) {
+            emitRuntimeEvent(context, {
+              type: "retry.exhausted",
+              outcome: summarized(outcome),
+              classification: outcomeClassification
+            });
+            throw error;
+          }
+          const delayMs = delayFor(options, context, context.attempt, outcome);
+          emitRuntimeEvent(context, {
+            type: "retry.scheduled",
+            nextAttempt: context.attempt + 1,
+            delayMs,
+            outcome: summarized(outcome),
+            classification: outcomeClassification
+          });
+          await wait(delayMs, admissionSignal(context));
+          context = nextAttempt(context);
+        }
+      }
+    }
+  });
+}
+
+// src/core/timeout.ts
+var TimeoutError = class extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`Operation timed out after ${timeoutMs}ms`);
+    this.name = "TimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+function combineSignals(external, timeoutController) {
+  if (external === void 0) {
+    return timeoutController.signal;
+  }
+  return AbortSignal.any([external, timeoutController.signal]);
+}
+function timeout(options) {
+  if (!Number.isFinite(options.ms) || options.ms <= 0) {
+    throw new RangeError("timeout ms must be a finite positive number");
+  }
+  return Object.freeze({
+    name: "timeout",
+    async execute(context, next) {
+      const timeoutError = new TimeoutError(options.ms);
+      const supportsAbort = context.capabilities.abort === "supported";
+      const controller = new AbortController();
+      const attemptContext = withAdmissionSignal(
+        supportsAbort ? withSignal(context, combineSignals(context.signal, controller)) : context,
+        controller.signal
+      );
+      let timer;
+      const timeoutPromise = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+          controller.abort(timeoutError);
+          emitRuntimeEvent(context, {
+            type: "timeout.triggered",
+            timeoutMs: options.ms,
+            abortRequested: supportsAbort
+          });
+          reject(timeoutError);
+        }, options.ms);
+      });
+      try {
+        return await Promise.race([next(attemptContext), timeoutPromise]);
+      } finally {
+        if (timer !== void 0) {
+          clearTimeout(timer);
+        }
+      }
+    }
+  });
+}
+
+export { BulkheadRejectedError, CircuitOpenError, TimeoutError, bulkhead, circuitBreaker, retry, timeout };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map