steady-circuit-breaker 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# Steady Circuit Breaker
+
+A tiny, deterministic circuit breaker for Node.js ≥ 18. It wraps any async/promise-based operation and prevents cascading failures by opening after sustained errors, probing for recovery, and closing again when healthy.
+
+## What is a circuit breaker?
+A circuit breaker watches the success/failure ratio of a dependency. When errors exceed a threshold, the breaker **opens** and short-circuits further calls, letting the dependency recover. After a cooldown it allows a limited number of **half-open** probes. If they succeed, the breaker **closes** and traffic resumes; if they fail, it re-opens.
+
+```
+CLOSED --(failure rate > threshold)--> OPEN
+  ^                               |
+  |                               |
+  |                               v
+  +----(all probes succeed)<--HALF_OPEN
+        (any probe fails)---->
+```
+
+## Quick start
+```ts
+import { CircuitBreaker, CircuitBreakerOpenError } from "steady-circuit-breaker";
+
+const breaker = new CircuitBreaker({
+  failureThreshold: 0.6,
+  minRequests: 10,
+  openTimeoutMs: 5_000,
+  halfOpenMaxRequests: 3
+});
+
+async function safeCall() {
+  return breaker.execute(async () => {
+    const res = await riskyOperation();
+    return res.data;
+  });
+}
+
+try {
+  const data = await safeCall();
+  console.log(data);
+} catch (error) {
+  if (error instanceof CircuitBreakerOpenError) {
+    // fast-fail: dependency is unhealthy; consider fallback
+    return useCache();
+  }
+  throw error;
+}
+```
+
+## Configuration
+| option | type | description |
+| --- | --- | --- |
+| `failureThreshold` | `number (0-1)` | Failure rate that trips the breaker once `minRequests` have run. `0.5` means >50% failures trigger OPEN. |
+| `minRequests` | `integer ≥ 1` | Minimum number of recorded calls before the failure rate is evaluated. Prevents noise. |
+| `openTimeoutMs` | `number > 0` | Time to stay OPEN before allowing HALF_OPEN probe calls. |
+| `halfOpenMaxRequests` | `integer ≥ 1` | Maximum concurrent probe executions allowed while HALF_OPEN. All must succeed to close; one failure re-opens immediately. |
+
+## Event hooks
+Subscribe to lifecycle hooks without decorators or global state:
+
+```ts
+const unsubscribe = breaker.on("stateChange", ({ previous, current }) => {
+  telemetry.trackState(previous, current);
+});
+
+breaker.on("success", ({ durationMs }) => metrics.recordLatency(durationMs));
+breaker.on("failure", ({ error }) => metrics.increment("cb.fail", error));
+breaker.on("reject", () => alerts.warn("breaker open"));
+
+// stop listening when finished
+unsubscribe();
+```
+
+Hooks are synchronous fire-and-forget to avoid backpressure.
+
+## Events
+- `stateChange`: Fired on every state transition with `{ previous, current }`.
+- `success`: Fired after an execution succeeds with `{ state, durationMs }`.
+- `failure`: Fired when an execution throws/rejects with `{ state, error }`.
+- `reject`: Fired when a call is short-circuited with `{ state, error }`.
+
+## Testing & build
+```
+npm test   # runs Vitest
+npm run build   # emits dist/index.js, dist/index.cjs, dist/index.d.ts
+```
+
+## Non-goals
+This library intentionally avoids the following (by design for V1):
+- HTTP/middleware integrations
+- Retries, rate limiting, bulkheads, backoff
+- Distributed/shared state or Redis
+- Metrics exporters or dashboards
+- Decorators, reflection, or framework bindings
+- Sliding time windows or adaptive configuration
+
+## Project status
+- Zero runtime dependencies
+- Dual ESM/CJS with type declarations
+- Tree-shakable (`"sideEffects": false`)
+- Targets strict TypeScript + Node.js ≥ 18

package/dist/index.cjs

@@ -0,0 +1,241 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CircuitBreaker: () => CircuitBreaker,
+  CircuitBreakerOpenError: () => CircuitBreakerOpenError,
+  CircuitBreakerState: () => CircuitBreakerState
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var CircuitBreakerOpenError = class extends Error {
+  constructor(message = "Circuit breaker is open") {
+    super(message);
+    this.name = "CircuitBreakerOpenError";
+  }
+};
+
+// src/events.ts
+var EventDispatcher = class {
+  constructor() {
+    this.listeners = {};
+  }
+  on(event, listener) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = /* @__PURE__ */ new Set();
+    }
+    this.listeners[event].add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners[event]?.delete(listener);
+  }
+  emit(event, payload) {
+    const handlers = this.listeners[event];
+    if (!handlers || handlers.size === 0) {
+      return;
+    }
+    for (const handler of handlers) {
+      handler(payload);
+    }
+  }
+};
+
+// src/metrics.ts
+var Metrics = class {
+  constructor() {
+    this.successCount = 0;
+    this.failureCount = 0;
+  }
+  recordSuccess() {
+    this.successCount += 1;
+  }
+  recordFailure() {
+    this.failureCount += 1;
+  }
+  get totalCount() {
+    return this.successCount + this.failureCount;
+  }
+  get failureRate() {
+    const total = this.totalCount;
+    if (total === 0) {
+      return 0;
+    }
+    return this.failureCount / total;
+  }
+  reset() {
+    this.successCount = 0;
+    this.failureCount = 0;
+  }
+};
+
+// src/state.ts
+var CircuitBreakerState = /* @__PURE__ */ ((CircuitBreakerState2) => {
+  CircuitBreakerState2["CLOSED"] = "CLOSED";
+  CircuitBreakerState2["OPEN"] = "OPEN";
+  CircuitBreakerState2["HALF_OPEN"] = "HALF_OPEN";
+  return CircuitBreakerState2;
+})(CircuitBreakerState || {});
+
+// src/CircuitBreaker.ts
+var CircuitBreaker = class {
+  constructor(options) {
+    this.metrics = new Metrics();
+    this.emitter = new EventDispatcher();
+    this.state = "CLOSED" /* CLOSED */;
+    this.lastOpenedAt = null;
+    this.halfOpenInFlight = 0;
+    this.halfOpenSuccessCount = 0;
+    this.options = this.validateOptions(options);
+  }
+  getState() {
+    return this.state;
+  }
+  on(event, listener) {
+    return this.emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+  }
+  async execute(action) {
+    this.maybeTransitionFromOpen();
+    if (this.state === "OPEN" /* OPEN */) {
+      this.rejectExecution();
+    }
+    let countedProbe = false;
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      if (this.halfOpenInFlight >= this.options.halfOpenMaxRequests) {
+        this.rejectExecution();
+      }
+      this.halfOpenInFlight += 1;
+      countedProbe = true;
+    }
+    const start = Date.now();
+    try {
+      const result = await action();
+      this.handleSuccess();
+      this.emitter.emit("success", {
+        state: this.state,
+        durationMs: Date.now() - start
+      });
+      return result;
+    } catch (error) {
+      this.handleFailure();
+      this.emitter.emit("failure", {
+        state: this.state,
+        error
+      });
+      throw error;
+    } finally {
+      if (countedProbe) {
+        this.halfOpenInFlight = Math.max(0, this.halfOpenInFlight - 1);
+      }
+    }
+  }
+  handleSuccess() {
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.halfOpenSuccessCount += 1;
+      if (this.halfOpenSuccessCount >= this.options.halfOpenMaxRequests) {
+        this.transitionTo("CLOSED" /* CLOSED */);
+      }
+      return;
+    }
+    if (this.state === "CLOSED" /* CLOSED */) {
+      this.metrics.recordSuccess();
+    }
+  }
+  handleFailure() {
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.transitionTo("OPEN" /* OPEN */);
+      return;
+    }
+    if (this.state !== "CLOSED" /* CLOSED */) {
+      return;
+    }
+    this.metrics.recordFailure();
+    if (this.metrics.totalCount < this.options.minRequests) {
+      return;
+    }
+    if (this.metrics.failureRate > this.options.failureThreshold) {
+      this.transitionTo("OPEN" /* OPEN */);
+    }
+  }
+  maybeTransitionFromOpen() {
+    if (this.state !== "OPEN" /* OPEN */ || this.lastOpenedAt === null) {
+      return;
+    }
+    const elapsed = Date.now() - this.lastOpenedAt;
+    if (elapsed >= this.options.openTimeoutMs) {
+      this.transitionTo("HALF_OPEN" /* HALF_OPEN */);
+    }
+  }
+  transitionTo(next) {
+    if (this.state === next) {
+      return;
+    }
+    const previous = this.state;
+    this.state = next;
+    if (next === "OPEN" /* OPEN */) {
+      this.lastOpenedAt = Date.now();
+      this.halfOpenInFlight = 0;
+      this.halfOpenSuccessCount = 0;
+    } else {
+      this.lastOpenedAt = null;
+      this.halfOpenInFlight = 0;
+    }
+    if (next === "HALF_OPEN" /* HALF_OPEN */ || next === "CLOSED" /* CLOSED */) {
+      this.metrics.reset();
+      this.halfOpenSuccessCount = 0;
+    }
+    this.emitter.emit("stateChange", { previous, current: next });
+  }
+  rejectExecution() {
+    const error = new CircuitBreakerOpenError();
+    this.emitter.emit("reject", {
+      state: this.state,
+      error
+    });
+    throw error;
+  }
+  validateOptions(options) {
+    const { failureThreshold, minRequests, openTimeoutMs, halfOpenMaxRequests } = options;
+    if (!Number.isFinite(failureThreshold) || failureThreshold <= 0 || failureThreshold >= 1) {
+      throw new Error("failureThreshold must be a number between 0 and 1");
+    }
+    if (!Number.isInteger(minRequests) || minRequests <= 0) {
+      throw new Error("minRequests must be a positive integer");
+    }
+    if (!Number.isFinite(openTimeoutMs) || openTimeoutMs <= 0) {
+      throw new Error("openTimeoutMs must be a positive number");
+    }
+    if (!Number.isInteger(halfOpenMaxRequests) || halfOpenMaxRequests <= 0) {
+      throw new Error("halfOpenMaxRequests must be a positive integer");
+    }
+    return { failureThreshold, minRequests, openTimeoutMs, halfOpenMaxRequests };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CircuitBreaker,
+  CircuitBreakerOpenError,
+  CircuitBreakerState
+});

package/dist/index.d.cts

@@ -0,0 +1,63 @@
+declare enum CircuitBreakerState {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN"
+}
+
+interface StateChangeEvent {
+    previous: CircuitBreakerState;
+    current: CircuitBreakerState;
+}
+interface SuccessEvent {
+    state: CircuitBreakerState;
+    durationMs: number;
+}
+interface FailureEvent {
+    state: CircuitBreakerState;
+    error: unknown;
+}
+interface RejectEvent {
+    state: CircuitBreakerState;
+    error: Error;
+}
+interface CircuitBreakerEvents extends Record<string, unknown> {
+    stateChange: StateChangeEvent;
+    success: SuccessEvent;
+    failure: FailureEvent;
+    reject: RejectEvent;
+}
+type Listener<T> = (payload: T) => void;
+
+interface CircuitBreakerOptions {
+    failureThreshold: number;
+    minRequests: number;
+    openTimeoutMs: number;
+    halfOpenMaxRequests: number;
+}
+type ExecutionAction<T> = () => PromiseLike<T> | T;
+declare class CircuitBreaker {
+    private readonly options;
+    private readonly metrics;
+    private readonly emitter;
+    private state;
+    private lastOpenedAt;
+    private halfOpenInFlight;
+    private halfOpenSuccessCount;
+    constructor(options: CircuitBreakerOptions);
+    getState(): CircuitBreakerState;
+    on<K extends keyof CircuitBreakerEvents>(event: K, listener: Listener<CircuitBreakerEvents[K]>): () => void;
+    off<K extends keyof CircuitBreakerEvents>(event: K, listener: Listener<CircuitBreakerEvents[K]>): void;
+    execute<T>(action: ExecutionAction<T>): Promise<T>;
+    private handleSuccess;
+    private handleFailure;
+    private maybeTransitionFromOpen;
+    private transitionTo;
+    private rejectExecution;
+    private validateOptions;
+}
+
+declare class CircuitBreakerOpenError extends Error {
+    constructor(message?: string);
+}
+
+export { CircuitBreaker, type CircuitBreakerEvents, CircuitBreakerOpenError, type CircuitBreakerOptions, CircuitBreakerState, type ExecutionAction, type FailureEvent, type Listener, type RejectEvent, type StateChangeEvent, type SuccessEvent };

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+declare enum CircuitBreakerState {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN"
+}
+
+interface StateChangeEvent {
+    previous: CircuitBreakerState;
+    current: CircuitBreakerState;
+}
+interface SuccessEvent {
+    state: CircuitBreakerState;
+    durationMs: number;
+}
+interface FailureEvent {
+    state: CircuitBreakerState;
+    error: unknown;
+}
+interface RejectEvent {
+    state: CircuitBreakerState;
+    error: Error;
+}
+interface CircuitBreakerEvents extends Record<string, unknown> {
+    stateChange: StateChangeEvent;
+    success: SuccessEvent;
+    failure: FailureEvent;
+    reject: RejectEvent;
+}
+type Listener<T> = (payload: T) => void;
+
+interface CircuitBreakerOptions {
+    failureThreshold: number;
+    minRequests: number;
+    openTimeoutMs: number;
+    halfOpenMaxRequests: number;
+}
+type ExecutionAction<T> = () => PromiseLike<T> | T;
+declare class CircuitBreaker {
+    private readonly options;
+    private readonly metrics;
+    private readonly emitter;
+    private state;
+    private lastOpenedAt;
+    private halfOpenInFlight;
+    private halfOpenSuccessCount;
+    constructor(options: CircuitBreakerOptions);
+    getState(): CircuitBreakerState;
+    on<K extends keyof CircuitBreakerEvents>(event: K, listener: Listener<CircuitBreakerEvents[K]>): () => void;
+    off<K extends keyof CircuitBreakerEvents>(event: K, listener: Listener<CircuitBreakerEvents[K]>): void;
+    execute<T>(action: ExecutionAction<T>): Promise<T>;
+    private handleSuccess;
+    private handleFailure;
+    private maybeTransitionFromOpen;
+    private transitionTo;
+    private rejectExecution;
+    private validateOptions;
+}
+
+declare class CircuitBreakerOpenError extends Error {
+    constructor(message?: string);
+}
+
+export { CircuitBreaker, type CircuitBreakerEvents, CircuitBreakerOpenError, type CircuitBreakerOptions, CircuitBreakerState, type ExecutionAction, type FailureEvent, type Listener, type RejectEvent, type StateChangeEvent, type SuccessEvent };

package/dist/index.js

@@ -0,0 +1,212 @@
+// src/errors.ts
+var CircuitBreakerOpenError = class extends Error {
+  constructor(message = "Circuit breaker is open") {
+    super(message);
+    this.name = "CircuitBreakerOpenError";
+  }
+};
+
+// src/events.ts
+var EventDispatcher = class {
+  constructor() {
+    this.listeners = {};
+  }
+  on(event, listener) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = /* @__PURE__ */ new Set();
+    }
+    this.listeners[event].add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners[event]?.delete(listener);
+  }
+  emit(event, payload) {
+    const handlers = this.listeners[event];
+    if (!handlers || handlers.size === 0) {
+      return;
+    }
+    for (const handler of handlers) {
+      handler(payload);
+    }
+  }
+};
+
+// src/metrics.ts
+var Metrics = class {
+  constructor() {
+    this.successCount = 0;
+    this.failureCount = 0;
+  }
+  recordSuccess() {
+    this.successCount += 1;
+  }
+  recordFailure() {
+    this.failureCount += 1;
+  }
+  get totalCount() {
+    return this.successCount + this.failureCount;
+  }
+  get failureRate() {
+    const total = this.totalCount;
+    if (total === 0) {
+      return 0;
+    }
+    return this.failureCount / total;
+  }
+  reset() {
+    this.successCount = 0;
+    this.failureCount = 0;
+  }
+};
+
+// src/state.ts
+var CircuitBreakerState = /* @__PURE__ */ ((CircuitBreakerState2) => {
+  CircuitBreakerState2["CLOSED"] = "CLOSED";
+  CircuitBreakerState2["OPEN"] = "OPEN";
+  CircuitBreakerState2["HALF_OPEN"] = "HALF_OPEN";
+  return CircuitBreakerState2;
+})(CircuitBreakerState || {});
+
+// src/CircuitBreaker.ts
+var CircuitBreaker = class {
+  constructor(options) {
+    this.metrics = new Metrics();
+    this.emitter = new EventDispatcher();
+    this.state = "CLOSED" /* CLOSED */;
+    this.lastOpenedAt = null;
+    this.halfOpenInFlight = 0;
+    this.halfOpenSuccessCount = 0;
+    this.options = this.validateOptions(options);
+  }
+  getState() {
+    return this.state;
+  }
+  on(event, listener) {
+    return this.emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+  }
+  async execute(action) {
+    this.maybeTransitionFromOpen();
+    if (this.state === "OPEN" /* OPEN */) {
+      this.rejectExecution();
+    }
+    let countedProbe = false;
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      if (this.halfOpenInFlight >= this.options.halfOpenMaxRequests) {
+        this.rejectExecution();
+      }
+      this.halfOpenInFlight += 1;
+      countedProbe = true;
+    }
+    const start = Date.now();
+    try {
+      const result = await action();
+      this.handleSuccess();
+      this.emitter.emit("success", {
+        state: this.state,
+        durationMs: Date.now() - start
+      });
+      return result;
+    } catch (error) {
+      this.handleFailure();
+      this.emitter.emit("failure", {
+        state: this.state,
+        error
+      });
+      throw error;
+    } finally {
+      if (countedProbe) {
+        this.halfOpenInFlight = Math.max(0, this.halfOpenInFlight - 1);
+      }
+    }
+  }
+  handleSuccess() {
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.halfOpenSuccessCount += 1;
+      if (this.halfOpenSuccessCount >= this.options.halfOpenMaxRequests) {
+        this.transitionTo("CLOSED" /* CLOSED */);
+      }
+      return;
+    }
+    if (this.state === "CLOSED" /* CLOSED */) {
+      this.metrics.recordSuccess();
+    }
+  }
+  handleFailure() {
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.transitionTo("OPEN" /* OPEN */);
+      return;
+    }
+    if (this.state !== "CLOSED" /* CLOSED */) {
+      return;
+    }
+    this.metrics.recordFailure();
+    if (this.metrics.totalCount < this.options.minRequests) {
+      return;
+    }
+    if (this.metrics.failureRate > this.options.failureThreshold) {
+      this.transitionTo("OPEN" /* OPEN */);
+    }
+  }
+  maybeTransitionFromOpen() {
+    if (this.state !== "OPEN" /* OPEN */ || this.lastOpenedAt === null) {
+      return;
+    }
+    const elapsed = Date.now() - this.lastOpenedAt;
+    if (elapsed >= this.options.openTimeoutMs) {
+      this.transitionTo("HALF_OPEN" /* HALF_OPEN */);
+    }
+  }
+  transitionTo(next) {
+    if (this.state === next) {
+      return;
+    }
+    const previous = this.state;
+    this.state = next;
+    if (next === "OPEN" /* OPEN */) {
+      this.lastOpenedAt = Date.now();
+      this.halfOpenInFlight = 0;
+      this.halfOpenSuccessCount = 0;
+    } else {
+      this.lastOpenedAt = null;
+      this.halfOpenInFlight = 0;
+    }
+    if (next === "HALF_OPEN" /* HALF_OPEN */ || next === "CLOSED" /* CLOSED */) {
+      this.metrics.reset();
+      this.halfOpenSuccessCount = 0;
+    }
+    this.emitter.emit("stateChange", { previous, current: next });
+  }
+  rejectExecution() {
+    const error = new CircuitBreakerOpenError();
+    this.emitter.emit("reject", {
+      state: this.state,
+      error
+    });
+    throw error;
+  }
+  validateOptions(options) {
+    const { failureThreshold, minRequests, openTimeoutMs, halfOpenMaxRequests } = options;
+    if (!Number.isFinite(failureThreshold) || failureThreshold <= 0 || failureThreshold >= 1) {
+      throw new Error("failureThreshold must be a number between 0 and 1");
+    }
+    if (!Number.isInteger(minRequests) || minRequests <= 0) {
+      throw new Error("minRequests must be a positive integer");
+    }
+    if (!Number.isFinite(openTimeoutMs) || openTimeoutMs <= 0) {
+      throw new Error("openTimeoutMs must be a positive number");
+    }
+    if (!Number.isInteger(halfOpenMaxRequests) || halfOpenMaxRequests <= 0) {
+      throw new Error("halfOpenMaxRequests must be a positive integer");
+    }
+    return { failureThreshold, minRequests, openTimeoutMs, halfOpenMaxRequests };
+  }
+};
+export {
+  CircuitBreaker,
+  CircuitBreakerOpenError,
+  CircuitBreakerState
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "steady-circuit-breaker",
+  "version": "1.0.0",
+  "description": "Deterministic, promise-based circuit breaker for Node.js.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean --out-dir dist",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "circuit-breaker",
+    "resilience",
+    "typescript"
+  ],
+  "sideEffects": false,
+  "author": "",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}