brass-runtime 1.15.0 → 1.16.0

package/dist/tracer-B5tRH9H7.d.ts

@@ -0,0 +1,230 @@
+import { A as Async, R as RuntimeHooks, a as RingBufferOptions, b as RuntimeEvent, c as RuntimeEmitContext, d as RuntimeEventRecord, e as RuntimeSpanLink, T as TraceContext, B as Baggage } from './effect-CGNl5Rqp.js';
+
+type CircuitBreakerState = "closed" | "open" | "half-open";
+type CircuitBreakerError = {
+    readonly _tag: "CircuitBreakerOpen";
+    readonly openSince: number;
+    readonly failures: number;
+};
+type CircuitBreakerConfig = {
+    /** Number of consecutive failures before opening the circuit. Default: 5 */
+    readonly failureThreshold?: number;
+    /** Time in ms to wait before transitioning from OPEN to HALF_OPEN. Default: 30000 */
+    readonly resetTimeoutMs?: number;
+    /** Number of successes in HALF_OPEN needed to close the circuit. Default: 1 */
+    readonly successThreshold?: number;
+    /** Custom predicate: should this error count as a failure? Default: all errors count. */
+    readonly isFailure?: (error: unknown) => boolean;
+    /** Called on state transitions (for observability). */
+    readonly onStateChange?: (from: CircuitBreakerState, to: CircuitBreakerState) => void;
+};
+type CircuitBreakerStats = {
+    readonly state: CircuitBreakerState;
+    readonly failures: number;
+    readonly successes: number;
+    readonly totalRequests: number;
+    readonly totalFailures: number;
+    readonly totalSuccesses: number;
+    readonly totalRejected: number;
+    readonly lastFailureTime: number | null;
+    readonly lastSuccessTime: number | null;
+};
+type CircuitBreaker = {
+    /** Current state of the circuit breaker. */
+    readonly state: () => CircuitBreakerState;
+    /** Run an effect through the circuit breaker. */
+    readonly protect: <R, E, A>(effect: Async<R, E, A>) => Async<R, E | CircuitBreakerError, A>;
+    /** Get current stats. */
+    readonly stats: () => CircuitBreakerStats;
+    /** Manually reset to closed state. */
+    readonly reset: () => void;
+};
+/**
+ * Creates a circuit breaker.
+ *
+ * ```ts
+ * const breaker = makeCircuitBreaker({ failureThreshold: 3, resetTimeoutMs: 10000 });
+ *
+ * // Protect an effect:
+ * const result = await run(breaker.protect(callExternalService()));
+ * // Throws CircuitBreakerOpen if circuit is open
+ * ```
+ */
+declare function makeCircuitBreaker(config?: CircuitBreakerConfig): CircuitBreaker;
+
+type MetricType = "counter" | "gauge" | "histogram";
+type MetricValue = {
+    readonly name: string;
+    readonly type: MetricType;
+    readonly value: number;
+    readonly labels: Record<string, string>;
+    readonly timestamp: number;
+};
+type HistogramBuckets = {
+    readonly boundaries: readonly number[];
+    counts: number[];
+    sum: number;
+    count: number;
+    min: number;
+    max: number;
+    exemplars?: Array<MetricExemplar | undefined>;
+};
+type MetricExemplar = {
+    readonly value: number;
+    readonly timestamp: number;
+    readonly traceId?: string;
+    readonly spanId?: string;
+    readonly labels?: Record<string, string>;
+};
+type MetricsRegistry = {
+    /** Create or get a counter. */
+    readonly counter: (name: string, labels?: Record<string, string>) => Counter;
+    /** Create or get a gauge. */
+    readonly gauge: (name: string, labels?: Record<string, string>) => Gauge;
+    /** Create or get a histogram. */
+    readonly histogram: (name: string, boundaries?: number[], labels?: Record<string, string>) => Histogram;
+    /** Get all current metric values. */
+    readonly snapshot: () => MetricSnapshot;
+    /** Reset all metrics. */
+    readonly reset: () => void;
+};
+type Counter = {
+    readonly increment: (n?: number) => void;
+    readonly value: () => number;
+};
+type Gauge = {
+    readonly set: (value: number) => void;
+    readonly increment: (n?: number) => void;
+    readonly decrement: (n?: number) => void;
+    readonly value: () => number;
+};
+type Histogram = {
+    readonly observe: (value: number, exemplar?: Omit<MetricExemplar, "value"> | MetricExemplar) => void;
+    readonly buckets: () => HistogramBuckets;
+    readonly percentile: (p: number) => number;
+};
+type MetricSnapshot = {
+    readonly counters: Array<{
+        name: string;
+        labels: Record<string, string>;
+        value: number;
+    }>;
+    readonly gauges: Array<{
+        name: string;
+        labels: Record<string, string>;
+        value: number;
+    }>;
+    readonly histograms: Array<{
+        name: string;
+        labels: Record<string, string>;
+        buckets: HistogramBuckets;
+    }>;
+};
+/**
+ * Creates a metrics registry.
+ *
+ * ```ts
+ * const metrics = makeMetrics();
+ *
+ * const requestCount = metrics.counter("http_requests_total", { method: "GET" });
+ * requestCount.increment();
+ *
+ * const latency = metrics.histogram("http_request_duration_ms");
+ * latency.observe(42.5);
+ *
+ * const activeConns = metrics.gauge("active_connections");
+ * activeConns.set(10);
+ *
+ * console.log(metrics.snapshot());
+ * ```
+ */
+declare function makeMetrics(): MetricsRegistry;
+
+type EventHandler = (ev: RuntimeEventRecord) => void;
+declare function runtimeHooksToEventHandler(hooks: RuntimeHooks): EventHandler;
+type EventBusOptions = RingBufferOptions;
+declare class EventBus implements RuntimeHooks {
+    private readonly options;
+    private seq;
+    private subs;
+    private flushScheduled;
+    private readonly boundFlush;
+    constructor(options?: EventBusOptions);
+    emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
+    subscribe(handler: EventHandler, perSubscriberCapacity?: number): () => void;
+    subscribeHooks(hooks: RuntimeHooks, perSubscriberCapacity?: number): () => void;
+    flush(budget?: number): void;
+}
+
+type RuntimeSpanEvent = {
+    wallTs: number;
+    name: string;
+    attrs?: unknown;
+};
+type RuntimeSpan = {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    traceState?: string;
+    name: string;
+    startWallTs: number;
+    endWallTs?: number;
+    attrs: Record<string, unknown>;
+    links: RuntimeSpanLink[];
+    events: RuntimeSpanEvent[];
+};
+type InMemoryTracerOptions = {
+    readonly sanitizeAttributes?: (attrs: Record<string, unknown>) => Record<string, unknown>;
+    readonly sanitizeError?: (error: unknown) => unknown;
+    readonly maxFinishedSpans?: number;
+    readonly maxSpanAgeMs?: number;
+    readonly clock?: () => number;
+};
+type InMemoryTracerStats = {
+    readonly storedSpans: number;
+    readonly finishedSpans: number;
+    readonly prunedFinishedSpans: number;
+};
+declare class InMemoryTracer implements RuntimeHooks {
+    private readonly options;
+    spans: Map<string, RuntimeSpan>;
+    private prunedFinishedSpans;
+    constructor(options?: InMemoryTracerOptions);
+    emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
+    exportFinished(): RuntimeSpan[];
+    pruneFinished(spanIds?: Iterable<string>): number;
+    stats(): InMemoryTracerStats;
+    private attrs;
+    private error;
+    private now;
+    private pruneExpiredFinished;
+    private pruneFinishedOverLimit;
+}
+
+type TraceSamplingInput = {
+    readonly traceId: string;
+    readonly spanName?: string;
+    readonly parentSampled?: boolean;
+    readonly attributes?: Record<string, unknown>;
+};
+type TraceSampler = ((input: TraceSamplingInput) => boolean) | {
+    shouldSample(input: TraceSamplingInput): boolean;
+};
+interface Tracer {
+    newTraceId(): string;
+    newSpanId(): string;
+}
+declare const defaultTracer: Tracer;
+type BrassEnv = {
+    brass?: {
+        tracer?: Tracer;
+        traceSeed?: TraceContext;
+        baggage?: Baggage;
+        sampler?: TraceSampler;
+        respectRemoteSampled?: boolean;
+        forceSampleOnError?: boolean;
+        childName?: (parentName?: string) => string | undefined;
+    };
+};
+
+export { type BrassEnv as B, type CircuitBreakerStats as C, EventBus as E, type Gauge as G, type Histogram as H, InMemoryTracer as I, type MetricsRegistry as M, type RuntimeSpan as R, type TraceSampler as T, type MetricExemplar as a, type MetricSnapshot as b, type TraceSamplingInput as c, type Tracer as d, type InMemoryTracerOptions as e, type CircuitBreaker as f, type CircuitBreakerConfig as g, type CircuitBreakerError as h, type CircuitBreakerState as i, type Counter as j, type EventBusOptions as k, type EventHandler as l, type HistogramBuckets as m, type InMemoryTracerStats as n, type MetricType as o, type MetricValue as p, type RuntimeSpanEvent as q, defaultTracer as r, makeCircuitBreaker as s, makeMetrics as t, runtimeHooksToEventHandler as u };

package/dist/tracing-Dt9S_6V8.d.ts

@@ -0,0 +1,148 @@
+import { A as Async, E as Exit } from './effect-CGNl5Rqp.js';
+
+/**
+ * Acquires a resource, uses it, and guarantees release regardless of outcome.
+ *
+ * - `acquire` runs uninterruptibly (once started, it completes)
+ * - `use` runs with the acquired resource
+ * - `release` runs after `use` completes (success, failure, or interruption)
+ *
+ * ```ts
+ * const result = bracket(
+ *   openConnection(),                    // acquire
+ *   (conn) => queryDatabase(conn),       // use
+ *   (conn, exit) => conn.close()         // release (always runs)
+ * );
+ * ```
+ */
+declare function bracket<R, E, A, B>(acquire: Async<R, E, A>, use: (resource: A) => Async<R, E, B>, release: (resource: A, exit: Exit<E, B>) => Async<R, any, void>): Async<R, E, B>;
+/**
+ * Runs `effect` and then runs `finalizer` regardless of the outcome.
+ * The finalizer receives the exit value for inspection.
+ *
+ * ```ts
+ * const result = ensuring(
+ *   doWork(),
+ *   (exit) => logCompletion(exit)
+ * );
+ * ```
+ */
+declare function ensuring<R, E, A>(effect: Async<R, E, A>, finalizer: (exit: Exit<E, A>) => Async<R, any, void>): Async<R, E, A>;
+declare function resource<R, E, A>(acquire: Async<R, E, A>, release: (resource: A, exit: Exit<any, any>) => Async<R, any, void>): Resource<R, E, A>;
+declare const makeResource: typeof resource;
+declare function resourceSucceed<A>(value: A): Resource<unknown, never, A>;
+declare function resourceFromManaged<R, E, A>(m: Managed<R, E, A>): Resource<R, E, A>;
+declare function useResource<R, E, A, R2, E2, B>(res: Resource<R, E, A>, body: (resource: A) => Async<R2, E2, B>): Async<R & R2, E | E2, B>;
+declare function resourceAll<R, E, Resources extends readonly any[]>(resources: {
+    [K in keyof Resources]: Resource<R, E, Resources[K]>;
+}): Resource<R, E, Resources>;
+/**
+ * A Resource describes a scoped value. It is acquired for each `use`, released
+ * in LIFO order, and can be composed with `map`, `flatMap`, and `zip`.
+ */
+type Resource<R, E, A> = {
+    readonly _tag: "Resource";
+    readonly use: <R2, E2, B>(body: (resource: A) => Async<R2, E2, B>) => Async<R & R2, E | E2, B>;
+    readonly map: <B>(f: (resource: A) => B) => Resource<R, E, B>;
+    readonly flatMap: <R2, E2, B>(f: (resource: A) => Resource<R2, E2, B>) => Resource<R & R2, E | E2, B>;
+    readonly zip: <R2, E2, B>(that: Resource<R2, E2, B>) => Resource<R & R2, E | E2, [A, B]>;
+};
+declare const Resource: Readonly<{
+    make: typeof resource;
+    succeed: typeof resourceSucceed;
+    fromManaged: typeof resourceFromManaged;
+    all: typeof resourceAll;
+    use: typeof useResource;
+}>;
+/**
+ * A Managed resource describes how to acquire and release a resource.
+ * It can be used multiple times — each `use` call acquires a fresh instance.
+ *
+ * ```ts
+ * const dbPool = managed(
+ *   createPool({ max: 10 }),
+ *   (pool) => pool.close()
+ * );
+ *
+ * // Use it:
+ * const result = useManaged(dbPool, (pool) => pool.query("SELECT 1"));
+ * ```
+ */
+type Managed<R, E, A> = {
+    readonly _tag: "Managed";
+    readonly acquire: Async<R, E, A>;
+    readonly release: (resource: A, exit: Exit<any, any>) => Async<R, any, void>;
+};
+/**
+ * Creates a Managed resource descriptor.
+ */
+declare function managed<R, E, A>(acquire: Async<R, E, A>, release: (resource: A, exit?: Exit<any, any>) => Async<R, any, void>): Managed<R, E, A>;
+/**
+ * Uses a Managed resource: acquires, runs the body, and releases.
+ */
+declare function useManaged<R, E, A, B>(m: Managed<R, E, A>, body: (resource: A) => Async<R, E, B>): Async<R, E, B>;
+/**
+ * Combines multiple Managed resources. All are acquired in order,
+ * and released in reverse order (LIFO).
+ *
+ * ```ts
+ * const resources = managedAll([dbPool, cacheConn, fileHandle]);
+ * const result = useManaged(resources, ([db, cache, file]) => ...);
+ * ```
+ */
+declare function managedAll<R, E, Resources extends readonly any[]>(manageds: {
+    [K in keyof Resources]: Managed<R, E, Resources[K]>;
+}): Managed<R, E, Resources>;
+
+type SpanContext = {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId?: string;
+};
+type SpanStatus = "ok" | "error" | "unset";
+type Span = {
+    readonly name: string;
+    readonly context: SpanContext;
+    readonly startTime: number;
+    endTime?: number;
+    status: SpanStatus;
+    readonly attributes: Record<string, string | number | boolean>;
+    readonly events: SpanEvent[];
+};
+type SpanEvent = {
+    readonly name: string;
+    readonly time: number;
+    readonly attributes?: Record<string, string | number | boolean>;
+};
+type TracerConfig = {
+    /** Service name for span metadata. */
+    readonly serviceName: string;
+    /** Called when a span ends (for export). */
+    readonly onSpanEnd?: (span: Span) => void;
+    /** Sampling rate (0.0 to 1.0). Default: 1.0 (sample everything). */
+    readonly sampleRate?: number;
+};
+type Tracer = {
+    /** Wrap an effect in a span. */
+    readonly span: <R, E, A>(name: string, effect: Async<R, E, A>, attributes?: Record<string, string | number | boolean>) => Async<R, E, A>;
+    /** Get all completed spans (for testing). */
+    readonly spans: () => readonly Span[];
+    /** Clear collected spans. */
+    readonly clear: () => void;
+};
+/**
+ * Creates a tracer that wraps effects in spans.
+ *
+ * ```ts
+ * const tracer = makeTracer({ serviceName: "my-app" });
+ *
+ * const result = await run(
+ *   tracer.span("fetchUser", fetchUser(id), { userId: id })
+ * );
+ *
+ * console.log(tracer.spans()); // all completed spans
+ * ```
+ */
+declare function makeTracer(config: TracerConfig): Tracer;
+
+export { type Managed as M, Resource as R, type Span as S, type Tracer as T, type SpanContext as a, type SpanEvent as b, type SpanStatus as c, type TracerConfig as d, bracket as e, ensuring as f, makeTracer as g, managed as h, managedAll as i, resourceAll as j, resourceFromManaged as k, resourceSucceed as l, makeResource as m, useResource as n, resource as r, useManaged as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brass-runtime",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "Effect runtime utilities for TypeScript",
   "license": "MIT",
   "author": "Augusto Vivaldelli",
@@ -18,11 +18,26 @@
       "import": "./dist/http/index.mjs",
       "require": "./dist/http/index.cjs"
     },
+    "./http/testing": {
+      "types": "./dist/http/testing.d.ts",
+      "import": "./dist/http/testing.mjs",
+      "require": "./dist/http/testing.cjs"
+    },
+    "./schema": {
+      "types": "./dist/schema/index.d.ts",
+      "import": "./dist/schema/index.mjs",
+      "require": "./dist/schema/index.cjs"
+    },
     "./core": {
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.mjs",
       "require": "./dist/core/index.cjs"
     },
+    "./observability": {
+      "types": "./dist/observability/index.d.ts",
+      "import": "./dist/observability/index.mjs",
+      "require": "./dist/observability/index.cjs"
+    },
     "./agent": {
       "types": "./dist/agent/index.d.ts",
       "import": "./dist/agent/index.mjs",
@@ -91,6 +106,17 @@
     "agent:vscode:reinstall:global": "npm run agent:vscode:uninstall:global && npm run agent:vscode:install:global",
     "benchmark": "tsx src/benchmarks/runner.ts",
     "benchmark:json": "tsx src/benchmarks/runner.ts --json",
+    "benchmark:http": "tsx src/benchmarks/runner.ts http-concurrent",
+    "benchmark:http:soak": "BRASS_HTTP_BENCH_MODE=soak tsx src/benchmarks/runner.ts http-concurrent",
+    "benchmark:http:budget": "node scripts/check-http-benchmark-budget.mjs",
+    "benchmark:adaptive": "tsx src/benchmarks/runner.ts adaptive-limiter-soak",
+    "benchmark:adaptive:soak": "BRASS_ADAPTIVE_BENCH_MODE=soak tsx src/benchmarks/runner.ts adaptive-limiter-soak",
+    "benchmark:observability": "tsx src/benchmarks/runner.ts observability-overhead",
+    "benchmark:observability:budget": "node scripts/check-observability-benchmark-budget.mjs",
+    "example:observability:express": "tsx src/examples/observabilityExpress.ts",
+    "example:observability:fastify": "tsx src/examples/observabilityFastify.ts",
+    "example:observability:nest": "tsx src/examples/observabilityNest.ts",
+    "smoke:observability:collector": "node scripts/observability-collector-smoke.mjs",
     "context": "node scripts/context-pack.mjs",
     "test:coverage:html": "COVERAGE_GATE=off vitest run --coverage --reporter=default",
     "build:wasm": "cd crates/brass-runtime-wasm-engine && wasm-pack build --target nodejs --out-dir ../../wasm/pkg",

package/dist/chunk-BDYEENHT.js

@@ -1,224 +0,0 @@
-import {
-  asyncEffect,
-  asyncFail,
-  asyncFlatMap,
-  asyncFold,
-  asyncSucceed,
-  unsafeGetCurrentRuntime
-} from "./chunk-BMH5AV44.js";
-
-// src/core/runtime/combinators.ts
-function sleep(ms) {
-  return asyncEffect((_env, cb) => {
-    const delay = Math.max(0, Math.floor(ms));
-    const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), delay);
-    return () => clearTimeout(id);
-  });
-}
-function timeout(effect, ms) {
-  return asyncEffect((env, cb) => {
-    let done = false;
-    let timerId;
-    let effectRunning = true;
-    timerId = setTimeout(() => {
-      if (done) return;
-      done = true;
-      effectRunning = false;
-      cb({
-        _tag: "Failure",
-        cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
-      });
-    }, Math.max(0, Math.floor(ms)));
-    const runtime = unsafeGetCurrentRuntime();
-    if (runtime) {
-      const fiber = runtime.fork(effect);
-      fiber.join((exit) => {
-        if (done) return;
-        done = true;
-        clearTimeout(timerId);
-        cb(exit);
-      });
-      return () => {
-        if (done) return;
-        done = true;
-        clearTimeout(timerId);
-        fiber.interrupt();
-      };
-    }
-    return () => {
-      if (done) return;
-      done = true;
-      clearTimeout(timerId);
-    };
-  });
-}
-function retry(effect, policy) {
-  const shouldRetry = policy.shouldRetry ?? (() => true);
-  const jitter = policy.jitter ?? "full";
-  const maxElapsedMs = policy.maxElapsedMs;
-  const computeDelay = (attempt) => {
-    const exp = policy.baseDelayMs * Math.pow(2, attempt);
-    const capped = Math.min(exp, policy.maxDelayMs);
-    if (jitter === "none") return capped;
-    return Math.floor(Math.random() * capped);
-  };
-  const loop = (attempt, startedAt) => asyncFold(
-    effect,
-    (error) => {
-      if (attempt >= policy.maxRetries) return asyncFail(error);
-      if (!shouldRetry(error, attempt)) return asyncFail(error);
-      if (maxElapsedMs !== void 0) {
-        const elapsed = performance.now() - startedAt;
-        if (elapsed >= maxElapsedMs) return asyncFail(error);
-      }
-      const delay = computeDelay(attempt);
-      return asyncFlatMap(sleep(delay), () => loop(attempt + 1, startedAt));
-    },
-    (value) => asyncSucceed(value)
-  );
-  return asyncFlatMap(
-    { _tag: "Sync", thunk: () => performance.now() },
-    (startedAt) => loop(0, startedAt)
-  );
-}
-function retryN(effect, n) {
-  return retry(effect, {
-    maxRetries: n,
-    baseDelayMs: 0,
-    maxDelayMs: 0,
-    jitter: "none"
-  });
-}
-function retryWithBackoff(effect, opts = {}) {
-  return retry(effect, {
-    maxRetries: opts.maxRetries ?? 3,
-    baseDelayMs: opts.baseDelayMs ?? 100,
-    maxDelayMs: opts.maxDelayMs ?? 1e4,
-    maxElapsedMs: opts.maxElapsedMs,
-    shouldRetry: opts.shouldRetry,
-    jitter: "full"
-  });
-}
-
-// src/core/runtime/circuitBreaker.ts
-function makeCircuitBreaker(config = {}) {
-  const failureThreshold = config.failureThreshold ?? 5;
-  const resetTimeoutMs = config.resetTimeoutMs ?? 3e4;
-  const successThreshold = config.successThreshold ?? 1;
-  const isFailure = config.isFailure ?? (() => true);
-  const onStateChange = config.onStateChange;
-  let currentState = "closed";
-  let consecutiveFailures = 0;
-  let consecutiveSuccesses = 0;
-  let openedAt = 0;
-  let totalRequests = 0;
-  let totalFailures = 0;
-  let totalSuccesses = 0;
-  let totalRejected = 0;
-  let lastFailureTime = null;
-  let lastSuccessTime = null;
-  const transition = (to) => {
-    if (currentState === to) return;
-    const from = currentState;
-    currentState = to;
-    onStateChange?.(from, to);
-  };
-  const onSuccess = () => {
-    totalSuccesses++;
-    lastSuccessTime = Date.now();
-    consecutiveFailures = 0;
-    if (currentState === "half-open") {
-      consecutiveSuccesses++;
-      if (consecutiveSuccesses >= successThreshold) {
-        consecutiveSuccesses = 0;
-        transition("closed");
-      }
-    }
-  };
-  const onFailure = (error) => {
-    if (!isFailure(error)) {
-      onSuccess();
-      return;
-    }
-    totalFailures++;
-    lastFailureTime = Date.now();
-    consecutiveSuccesses = 0;
-    consecutiveFailures++;
-    if (currentState === "half-open") {
-      openedAt = Date.now();
-      transition("open");
-    } else if (currentState === "closed" && consecutiveFailures >= failureThreshold) {
-      openedAt = Date.now();
-      transition("open");
-    }
-  };
-  const shouldAllow = () => {
-    switch (currentState) {
-      case "closed":
-        return true;
-      case "open": {
-        const elapsed = Date.now() - openedAt;
-        if (elapsed >= resetTimeoutMs) {
-          transition("half-open");
-          return true;
-        }
-        return false;
-      }
-      case "half-open":
-        return true;
-    }
-  };
-  const protect = (effect) => {
-    totalRequests++;
-    if (!shouldAllow()) {
-      totalRejected++;
-      return asyncFail({
-        _tag: "CircuitBreakerOpen",
-        openSince: openedAt,
-        failures: consecutiveFailures
-      });
-    }
-    return asyncFold(
-      effect,
-      (error) => {
-        onFailure(error);
-        return asyncFail(error);
-      },
-      (value) => {
-        onSuccess();
-        return asyncSucceed(value);
-      }
-    );
-  };
-  const stats = () => ({
-    state: currentState,
-    failures: consecutiveFailures,
-    successes: consecutiveSuccesses,
-    totalRequests,
-    totalFailures,
-    totalSuccesses,
-    totalRejected,
-    lastFailureTime,
-    lastSuccessTime
-  });
-  const reset = () => {
-    consecutiveFailures = 0;
-    consecutiveSuccesses = 0;
-    transition("closed");
-  };
-  return {
-    state: () => currentState,
-    protect,
-    stats,
-    reset
-  };
-}
-
-export {
-  sleep,
-  timeout,
-  retry,
-  retryN,
-  retryWithBackoff,
-  makeCircuitBreaker
-};