import { A as Async, R as RuntimeHooks, e as RuntimeEmitContext } from './effect-DbEMiMvv.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 RuntimeTimerId = unknown;
type RuntimeClock = {
    readonly now: () => number;
    readonly setTimeout: (task: () => void, ms: number) => RuntimeTimerId;
    readonly clearTimeout: (timer: RuntimeTimerId) => void;
};
type RuntimeClockEnv = {
    readonly brass?: {
        readonly clock?: RuntimeClock;
    };
};
declare const liveClock: RuntimeClock;
declare function runtimeClockFromEnv(env: unknown): RuntimeClock;

type ScheduleDecision = {
    readonly continue: boolean;
    readonly delayMs: number;
    readonly attempt?: number;
    readonly elapsedMs?: number;
    readonly reason?: string;
    readonly name?: string;
};
type ScheduleJitterOptions = {
    /** 1 means full jitter in [0, delay], 0.2 means +/-20% around delay. */
    readonly factor?: number;
    /** Deterministic hook for tests. Defaults to Math.random. */
    readonly random?: () => number;
};
type ScheduleStepContext = {
    readonly clock: RuntimeClock;
    readonly startedAtMs: number;
    readonly attempt: number;
    readonly name?: string;
};
type ScheduleObserverEvent<I, O> = {
    readonly name?: string;
    readonly input: I;
    readonly output: O;
    readonly decision: ScheduleDecision;
    readonly attempt: number;
    readonly elapsedMs: number;
    readonly state: unknown;
    readonly nextState: unknown;
    readonly timestamp: number;
};
type ScheduleObserver<I, O> = (event: ScheduleObserverEvent<I, O>) => void;
type ScheduleDriverDecision<O> = {
    readonly continue: boolean;
    readonly delayMs: number;
    readonly output: O;
    readonly decision: ScheduleDecision;
    readonly attempt: number;
    readonly elapsedMs: number;
    readonly state: unknown;
};
type ScheduleDriverSnapshot<O = unknown> = {
    readonly name?: string;
    readonly attempt: number;
    readonly elapsedMs: number;
    readonly state: unknown;
    readonly last?: ScheduleDriverDecision<O>;
};
type ScheduleDriverOptions<I = unknown, O = unknown> = {
    readonly name?: string;
    readonly clock?: RuntimeClock;
    readonly startedAtMs?: number;
    readonly onDecision?: ScheduleObserver<I, O>;
    readonly hooks?: RuntimeHooks;
    readonly emitContext?: RuntimeEmitContext;
    readonly captureInput?: boolean;
    readonly captureOutput?: boolean;
};
type ScheduleDriver<I, O> = {
    readonly next: (input: I) => ScheduleDriverDecision<O>;
    readonly reset: () => void;
    readonly snapshot: () => ScheduleDriverSnapshot<O>;
    readonly state: () => unknown;
    readonly last: () => ScheduleDriverDecision<O> | undefined;
};
/** Retry/repeat up to N times with no delay. */
declare function recurs(n: number): Schedule<unknown, number>;
/** Continue forever with no delay. */
declare function forever(): Schedule<unknown, number>;
/** Never continue. */
declare function never(): Schedule<unknown, number>;
/** Continue exactly once. */
declare function once(): Schedule<unknown, number>;
/** Fixed delay between each retry/repeat. */
declare function fixed(delayMs: number): Schedule<unknown, number>;
/** Alias for fixed delay schedules. */
declare const spaced: typeof fixed;
/** Exponential backoff: delay doubles each time, capped at maxDelayMs. */
declare function exponential(baseMs: number, maxMs?: number): Schedule<unknown, number>;
/** Linear backoff: base, 2*base, 3*base... capped at maxDelayMs. */
declare function linear(baseMs: number, maxMs?: number): Schedule<unknown, number>;
/** Fibonacci backoff: base, base, 2*base, 3*base, 5*base, capped at maxDelayMs. */
declare function fibonacci(baseMs: number, maxMs?: number): Schedule<unknown, number>;
/** Exponential backoff with full jitter (random in [0, delay]). */
declare function jittered(baseMs: number, maxMs?: number): Schedule<unknown, number>;
/** Stop after a total elapsed time. */
declare function elapsed(maxMs: number): Schedule<unknown, number>;
/** Only continue while a predicate holds on the input. */
declare function whileInput<I>(pred: (input: I) => boolean): Schedule<I, I>;
/** Continue until the input predicate becomes true. */
declare function untilInput<I>(pred: (input: I) => boolean): Schedule<I, I>;
/** Limit a schedule to N repetitions. */
declare function take<I, O>(schedule: Schedule<I, O>, n: number): Schedule<I, O>;
/** Transform schedule output while preserving decisions and state. */
declare function map<I, O, O2>(schedule: Schedule<I, O>, f: (output: O) => O2): Schedule<I, O2>;
/** Transform schedule input before it reaches the wrapped schedule. */
declare function contramap<I0, I, O>(schedule: Schedule<I, O>, f: (input: I0) => I): Schedule<I0, O>;
/** Add jitter to any schedule's delay. */
declare function jitteredSchedule<I, O>(schedule: Schedule<I, O>, options?: number | ScheduleJitterOptions): Schedule<I, O>;
declare const jitter: typeof jitteredSchedule;
/**
 * Reset a schedule's internal state after a rolling time window.
 * Useful for retry/polling policies that should forgive old bursts.
 */
declare function windowed<I, O>(schedule: Schedule<I, O>, windowMs: number, clock?: () => number): Schedule<I, O>;
/** Cap a schedule's delay without changing its state or output. */
declare function maxDelay<I, O>(schedule: Schedule<I, O>, maxMs: number): Schedule<I, O>;
/** Stop a schedule after a total elapsed runtime-clock budget. */
declare function maxElapsed<I, O>(schedule: Schedule<I, O>, maxMs: number): Schedule<I, O>;
declare const upTo: typeof maxElapsed;
/** Continue while a predicate holds on the wrapped schedule output. */
declare function whileOutput<I, O>(schedule: Schedule<I, O>, pred: (output: O) => boolean): Schedule<I, O>;
/** Continue until a predicate holds on the wrapped schedule output. */
declare function untilOutput<I, O>(schedule: Schedule<I, O>, pred: (output: O) => boolean): Schedule<I, O>;
/** Attach an observability name to a schedule. */
declare function named<I, O>(name: string, schedule: Schedule<I, O>): Schedule<I, O>;
/** Observe each schedule decision without changing semantics. */
declare function tapDecision<I, O>(schedule: Schedule<I, O>, tap: ScheduleObserver<I, O>): Schedule<I, O>;
/** Compose two schedules: use the first, then switch to the second. */
declare function andThen<I, O1, O2>(first: Schedule<I, O1>, second: Schedule<I, O2>): Schedule<I, O1 | O2>;
/** Run both schedules and continue while BOTH say continue. Use max delay. */
declare function intersect<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
/** Run both schedules and continue while EITHER says continue. Use min delay. */
declare function union<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
declare function makeScheduleDriver<I, O>(schedule: Schedule<I, O>, options?: ScheduleDriverOptions<I, O>): ScheduleDriver<I, O>;
declare const scheduleDriver: typeof makeScheduleDriver;
declare function runSchedule<I, O>(schedule: Schedule<I, O>, inputs: Iterable<I>, options?: ScheduleDriverOptions<I, O>): ScheduleDriverDecision<O>[];
/**
 * Retry an effect according to a schedule.
 * The schedule receives the error as input on each failure.
 */
declare function retryWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<E, O>, options?: ScheduleDriverOptions<E, O>): Async<R, E, A>;
declare const retry: typeof retryWithSchedule;
/**
 * Repeat an effect according to a schedule.
 * The schedule receives the success value as input on each iteration.
 * Returns the last successful value.
 */
declare function repeatWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<A, O>, options?: ScheduleDriverOptions<A, O>): Async<R, E, A>;
declare const repeat: typeof repeatWithSchedule;
declare const poll: typeof repeatWithSchedule;
/**
 * A Schedule<I, O> takes an input I (typically the error or output of an effect)
 * and decides whether to continue and with what delay.
 */
type Schedule<I, O> = {
    readonly _tag: "Schedule";
    readonly name?: string;
    /** Initial state */
    readonly initial: (context?: ScheduleStepContext) => any;
    /** Given current state and input, produce a decision and next state */
    readonly step: (state: any, input: I, context?: ScheduleStepContext) => [ScheduleDecision, any, O];
};
declare const Schedule: Readonly<{
    driver: typeof makeScheduleDriver;
    run: typeof runSchedule;
    recurs: typeof recurs;
    forever: typeof forever;
    never: typeof never;
    once: typeof once;
    fixed: typeof fixed;
    spaced: typeof fixed;
    linear: typeof linear;
    exponential: typeof exponential;
    fibonacci: typeof fibonacci;
    jittered: typeof jittered;
    jitteredSchedule: typeof jitteredSchedule;
    jitter: typeof jitteredSchedule;
    elapsed: typeof elapsed;
    whileInput: typeof whileInput;
    untilInput: typeof untilInput;
    whileOutput: typeof whileOutput;
    untilOutput: typeof untilOutput;
    take: typeof take;
    map: typeof map;
    contramap: typeof contramap;
    maxDelay: typeof maxDelay;
    maxElapsed: typeof maxElapsed;
    upTo: typeof maxElapsed;
    windowed: typeof windowed;
    named: typeof named;
    tapDecision: typeof tapDecision;
    andThen: typeof andThen;
    intersect: typeof intersect;
    union: typeof union;
    retry: typeof retryWithSchedule;
    repeat: typeof repeatWithSchedule;
    poll: typeof repeatWithSchedule;
}>;

type ServiceTag<A> = {
    readonly _tag: "ServiceTag";
    readonly key: symbol;
    readonly name: string;
};
declare class MissingLayerServiceError extends Error {
    readonly _tag: "MissingLayerService";
    readonly serviceName: string;
    constructor(serviceName: string);
}
declare function formatLayerError(error: unknown): string;
declare function makeServiceTag<A>(name: string): ServiceTag<A>;
declare const serviceTag: typeof makeServiceTag;
declare const defineService: typeof makeServiceTag;
declare class LayerContext<Services = unknown> {
    private readonly services;
    constructor(entries?: Iterable<readonly [ServiceTag<any>, unknown]> | Map<symbol, unknown>);
    static empty(): LayerContext<unknown>;
    get<A>(tag: ServiceTag<A>): A | undefined;
    unsafeGet<A>(tag: ServiceTag<A>): A;
    has(tag: ServiceTag<unknown>): boolean;
    add<A>(tag: ServiceTag<A>, service: A): LayerContext<Services & A>;
    merge<Other>(other: LayerContext<Other>): LayerContext<Services & Other>;
    size(): number;
}
type LayerScope = {
    readonly get: <RIn, E, ROut>(layer: Layer<RIn, E, ROut>, deps?: RIn) => Async<unknown, E, ROut>;
    readonly close: () => Async<unknown, never, void>;
    readonly size: () => number;
};
type BuiltLayer<ROut> = {
    readonly service: ROut;
    readonly scope: LayerScope;
    readonly close: () => Async<unknown, never, void>;
    readonly use: <E, A>(body: (service: ROut) => Async<unknown, E, A>) => Async<unknown, E, A>;
};
type AnyLayer = Layer<any, any, any>;
type LayerInputOf<L> = L extends Layer<infer RIn, any, any> ? RIn : never;
type LayerErrorOf<L> = L extends Layer<any, infer E, any> ? E : never;
type LayerOutputOf<L> = L extends Layer<any, any, infer ROut> ? ROut : never;
type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
type LastOf<T extends readonly unknown[]> = T extends readonly [...unknown[], infer Last] ? Last : never;
type ServiceTagMap = Record<string, ServiceTag<any>>;
type ServicesOf<Tags extends ServiceTagMap> = {
    readonly [K in keyof Tags]: Tags[K] extends ServiceTag<infer A> ? A : never;
};
declare function makeLayerScope(): LayerScope;
/**
 * Creates a Layer from an acquire/release pair.
 *
 * ```ts
 * const DbLayer = layer(
 *   () => createPool({ max: 10 }),
 *   (pool) => pool.close()
 * );
 * ```
 */
declare function layer<ROut, E = never>(acquire: () => Async<unknown, E, ROut>, release?: (service: ROut) => Async<unknown, never, void>): Layer<unknown, E, ROut>;
declare function layerValue<A>(tag: ServiceTag<A>, value: A): Layer<LayerContext, never, LayerContext>;
declare const makeTestLayer: typeof layerValue;
type TestLayerProvider<A = unknown> = readonly [ServiceTag<A>, A];
declare function makeTestLayers(...providers: readonly TestLayerProvider[]): Layer<LayerContext, never, LayerContext>;
declare function layerEffect<E, A>(tag: ServiceTag<A>, acquire: (deps: LayerContext) => Async<unknown, E, A>, release?: (service: A) => Async<unknown, never, void>): Layer<LayerContext, E, LayerContext>;
declare const layerFromContext: typeof layerEffect;
declare const defineLayer: typeof layerEffect;
declare function getService<A>(tag: ServiceTag<A>): Async<LayerContext, MissingLayerServiceError, A>;
declare function getServices<Tags extends ServiceTagMap>(tags: Tags): Async<LayerContext, MissingLayerServiceError, ServicesOf<Tags>>;
declare function useService<A, E, B>(tag: ServiceTag<A>, use: (service: A) => Async<unknown, E, B>): (context: LayerContext) => Async<unknown, MissingLayerServiceError | E, B>;
declare function useServices<Tags extends ServiceTagMap, E, A>(tags: Tags, use: (services: ServicesOf<Tags>) => Async<unknown, E, A>): (context: LayerContext) => Async<unknown, MissingLayerServiceError | E, A>;
/**
 * Creates a Layer that depends on another service.
 *
 * ```ts
 * const RepoLayer = layerFrom<DbPool>()(
 *   (pool) => createRepo(pool),
 *   (repo) => repo.close()
 * );
 * ```
 */
declare function layerFrom<RIn>(): <ROut, E = never>(acquire: (deps: RIn) => Async<unknown, E, ROut>, release?: (service: ROut) => Async<unknown, never, void>) => Layer<RIn, E, ROut>;
/**
 * Creates a Layer from a pure value (no lifecycle).
 *
 * ```ts
 * const ConfigLayer = layerSucceed({ port: 3000, host: "localhost" });
 * ```
 */
declare function layerSucceed<ROut>(value: ROut): Layer<unknown, never, ROut>;
/**
 * Creates a Layer that always fails.
 */
declare function layerFail<E>(error: E): Layer<unknown, E, never>;
/**
 * Compose two layers: the output of `from` feeds into `to`.
 *
 * ```ts
 * const AppLayer = compose(DbLayer, RepoLayer);
 * // DbLayer produces DbPool → RepoLayer consumes DbPool → produces Repo
 * ```
 */
declare function compose<R1, E1, Mid, E2, ROut>(from: Layer<R1, E1, Mid>, to: Layer<Mid, E2, ROut>): Layer<R1, E1 | E2, ROut>;
declare function composeAll<Layers extends readonly [AnyLayer, ...AnyLayer[]]>(...layers: Layers): Layer<LayerInputOf<Layers[0]>, LayerErrorOf<Layers[number]>, LayerOutputOf<LastOf<Layers>>>;
/**
 * Merge two independent layers into one that produces both services.
 *
 * ```ts
 * const AppLayer = merge(DbLayer, CacheLayer);
 * // Produces { db: DbPool, cache: CacheClient }
 * ```
 */
declare function merge<R1, E1, A, R2, E2, B>(left: Layer<R1, E1, A>, right: Layer<R2, E2, B>): Layer<R1 & R2, E1 | E2, A & B>;
declare function mergeAll<Layers extends readonly [AnyLayer, ...AnyLayer[]]>(...layers: Layers): Layer<UnionToIntersection<LayerInputOf<Layers[number]>>, LayerErrorOf<Layers[number]>, UnionToIntersection<LayerOutputOf<Layers[number]>>>;
/**
 * Map the output of a layer.
 */
declare function mapLayer<RIn, E, A, B>(l: Layer<RIn, E, A>, f: (a: A) => B): Layer<RIn, E, B>;
declare function buildLayer<RIn, E, ROut>(l: Layer<RIn, E, ROut>, deps?: RIn): Async<unknown, E, BuiltLayer<ROut>>;
/**
 * Builds a layer, runs an effect with the produced service, and releases.
 *
 * ```ts
 * const result = await run(
 *   provideLayer(AppLayer, (services) => services.db.query("SELECT 1"))
 * );
 * ```
 */
declare function provideLayer<RIn, E, ROut, E2, A>(l: Layer<RIn, E, ROut>, use: (service: ROut) => Async<unknown, E2, A>, deps?: RIn): Async<unknown, E | E2, A>;
declare function provideLayerContext<E, E2, A>(l: Layer<LayerContext, E, LayerContext>, use: (context: LayerContext) => Async<unknown, E2, A>, deps?: LayerContext): Async<unknown, E | E2, A>;
declare const provide: typeof provideLayer;
declare const provideContext: typeof provideLayerContext;
/**
 * A Layer describes how to build a service.
 *
 * - RIn: dependencies required to build this service
 * - E: possible failure during construction
 * - ROut: the service produced
 */
type Layer<RIn, E, ROut> = {
    readonly _tag: "Layer";
    readonly build: (deps: RIn) => Async<unknown, E, {
        service: ROut;
        release: () => Async<unknown, never, void>;
    }>;
    readonly buildScoped?: (deps: RIn, scope: LayerScope) => Async<unknown, E, ROut>;
};
declare const Layer: Readonly<{
    make: typeof layer;
    from: typeof layerFrom;
    succeed: typeof layerSucceed;
    fail: typeof layerFail;
    value: typeof layerValue;
    test: typeof layerValue;
    tests: typeof makeTestLayers;
    effect: typeof layerEffect;
    define: typeof layerEffect;
    fromContext: typeof layerEffect;
    compose: typeof compose;
    composeAll: typeof composeAll;
    merge: typeof merge;
    all: typeof mergeAll;
    mergeAll: typeof mergeAll;
    map: typeof mapLayer;
    provide: typeof provideLayer;
    provideContext: typeof provideLayerContext;
    build: typeof buildLayer;
    scope: typeof makeLayerScope;
    context: typeof LayerContext.empty;
    tag: typeof makeServiceTag;
    service: typeof getService;
    services: typeof getServices;
    use: typeof useService;
    useAll: typeof useServices;
}>;

export { layerSucceed as $, contramap as A, type BuiltLayer as B, type CircuitBreakerStats as C, defineLayer as D, defineService as E, elapsed as F, exponential as G, fibonacci as H, fixed as I, forever as J, formatLayerError as K, Layer as L, MissingLayerServiceError as M, getService as N, getServices as O, intersect as P, jitter as Q, type RuntimeClock as R, type ServiceTag as S, type TestLayerProvider as T, jittered as U, jitteredSchedule as V, layer as W, layerEffect as X, layerFail as Y, layerFrom as Z, layerFromContext as _, LayerContext as a, layerValue as a0, linear as a1, liveClock as a2, makeCircuitBreaker as a3, makeLayerScope as a4, makeScheduleDriver as a5, makeServiceTag as a6, makeTestLayer as a7, makeTestLayers as a8, mapLayer as a9, untilInput as aA, untilOutput as aB, upTo as aC, useService as aD, useServices as aE, whileInput as aF, whileOutput as aG, windowed as aH, map as aa, maxDelay as ab, maxElapsed as ac, mergeAll as ad, merge as ae, named as af, never as ag, once as ah, poll as ai, provide as aj, provideContext as ak, provideLayer as al, provideLayerContext as am, recurs as an, repeatWithSchedule as ao, repeat as ap, retryWithSchedule as aq, retry as ar, runSchedule as as, runtimeClockFromEnv as at, scheduleDriver as au, serviceTag as av, spaced as aw, take as ax, tapDecision as ay, union as az, type CircuitBreaker as b, type CircuitBreakerConfig as c, type CircuitBreakerError as d, type CircuitBreakerState as e, type LayerErrorOf as f, type LayerInputOf as g, type LayerOutputOf as h, type LayerScope as i, type RuntimeClockEnv as j, type RuntimeTimerId as k, Schedule as l, type ScheduleDecision as m, type ScheduleDriver as n, type ScheduleDriverDecision as o, type ScheduleDriverOptions as p, type ScheduleDriverSnapshot as q, type ScheduleObserver as r, type ScheduleObserverEvent as s, type ScheduleStepContext as t, type ServiceTagMap as u, type ServicesOf as v, andThen as w, buildLayer as x, composeAll as y, compose as z };