import { A as Async, a as RuntimeOptions, b as Runtime, E as Exit, aJ as Task, ay as ScheduleResult, aD as SchedulerStats, R as RuntimeHooks, f as RuntimeEventRecord, h as RuntimeRegistry, k as Fiber } from '../effect-DbEMiMvv.js';
export { u as AbortablePromiseFinish, v as AbortablePromiseLabelStats, w as AbortablePromiseOptions, x as AbortablePromiseOutcome, y as AbortablePromiseStats, z as AbortablePromiseTimerWheel, D as AsyncWithPromise, H as CancelToken, I as Canceler, K as Cause, L as CausePrettyOptions, M as ContextNode, $ as FiberContext, l as FiberId, a1 as FiberInfo, a5 as FiberRunState, m as FiberStatus, ah as Interrupted, ai as InterruptibilityMode, J as JSONValue, al as None, am as NoopHooks, O as Option, as as RestoreInterruptibility, e as RuntimeEmitContext, d as RuntimeEvent, i as RuntimeFiber, g as RuntimeSpanLink, S as Scope, aF as ScopeId, aG as ScopeInfo, aH as Some, T as TraceContext, Z as ZIO, aM as abortablePromiseStats, aN as acquireRelease, aO as async, aP as asyncCatchAll, aQ as asyncFail, aR as asyncFlatMap, aS as asyncFold, aT as asyncInterruptible, aU as asyncMap, aV as asyncMapError, aW as asyncSucceed, aX as asyncSync, aY as asyncTotal, aZ as catchAll, a_ as ctxExtend, a$ as ctxToObject, b0 as emptyContext, b1 as end, b3 as fail, b4 as flatMap, b5 as fork, b6 as formatCause, b7 as fromPromiseAbortable, b8 as getBenchmarkBudget, b9 as getCurrentFiber, bc as interruptible, bd as isCause, bf as linkAbortController, bh as makeCancelToken, bj as makeRuntimeEventRecord, bk as map, bl as mapAsync, bm as mapError, bn as mapTryAsync, bo as none, bp as orElseOptional, bq as prettyCause, br as recordAbortablePromiseFinish, bs as recordAbortablePromiseStart, bt as resetAbortablePromiseStats, bv as runtimeEventRecordContext, bw as runtimeForCaller, bz as setAbortablePromisePerLabelTracking, bA as setBenchmarkBudget, bB as setCurrentFiber, bC as some, bD as succeed, bE as sync, bF as toPromise, bG as toPromiseByCaller, bH as uninterruptible, bI as uninterruptibleMask, bJ as unit, bK as unsafeGetCurrentRuntime, bL as unsafeRunAsync, bM as unsafeRunFoldWithEnv, bN as withAsyncPromise, bO as withCurrentFiber, bP as withScope, bQ as withScopeAsync } from '../effect-DbEMiMvv.js';
export { M as ManagedResource, R as Resource, R as ResourceDescriptor, S as Span, a as SpanContext, b as SpanEvent, c as SpanStatus, T as Tracer, d as TracerConfig, e as bracket, f as ensuring, m as makeResource, g as makeTracer, h as managed, i as managedAll, r as resource, j as resourceAll, k as resourceFromManaged, l as resourceSucceed, u as useManaged, n as useResource } from '../tracing-DIAUf2x8.js';
import { R as RuntimeClock, k as RuntimeTimerId, j as RuntimeClockEnv, a as LayerContext, S as ServiceTag, L as Layer, l as Schedule } from '../layer-CsNGeVee.js';
export { B as BuiltLayer, b as CircuitBreaker, c as CircuitBreakerConfig, d as CircuitBreakerError, e as CircuitBreakerState, C as CircuitBreakerStats, f as LayerErrorOf, g as LayerInputOf, h as LayerOutputOf, i as LayerScope, M as MissingLayerServiceError, m as ScheduleDecision, n as ScheduleDriver, o as ScheduleDriverDecision, p as ScheduleDriverOptions, q as ScheduleDriverSnapshot, r as ScheduleObserver, s as ScheduleObserverEvent, t as ScheduleStepContext, u as ServiceTagMap, v as ServicesOf, T as TestLayerProvider, w as andThenSchedule, x as buildLayer, y as composeAll, z as composeLayer, A as contramapSchedule, D as defineLayer, E as defineService, F as elapsed, G as exponential, H as fibonacci, I as fixed, J as forever, K as formatLayerError, N as getService, O as getServices, P as intersect, Q as jitter, U as jittered, V as jitteredSchedule, W as layer, X as layerEffect, Y as layerFail, Z as layerFrom, _ as layerFromContext, $ as layerSucceed, a0 as layerValue, a1 as linear, a2 as liveClock, a3 as makeCircuitBreaker, a4 as makeLayerScope, a5 as makeScheduleDriver, a6 as makeServiceTag, a7 as makeTestLayer, a8 as makeTestLayers, a9 as mapLayer, aa as mapSchedule, ab as maxDelay, ac as maxElapsed, ad as mergeAll, ae as mergeLayer, af as namedSchedule, ag as never, ah as once, ai as pollWithSchedule, aj as provide, ak as provideContext, al as provideLayer, am as provideLayerContext, an as recurs, ao as repeatWithSchedule, ap as repeatWithScheduleAlias, aq as retryWithSchedule, ar as retryWithScheduleAlias, as as runSchedule, at as runtimeClockFromEnv, au as scheduleDriver, av as serviceTag, aw as spaced, ax as takeSchedule, ay as tapDecision, az as union, aA as untilInput, aB as untilOutput, aC as upTo, aD as useService, aE as useServices, aF as whileInput, aG as whileOutput, aH as windowed } from '../layer-CsNGeVee.js';
import { JsonSchemaLike } from '../schema/index.js';
export { B as BrassEnv, C as Counter, E as EventBus, f as EventBusOptions, g as EventHandler, G as Gauge, H as Histogram, h as HistogramBuckets, I as InMemoryTracer, e as InMemoryTracerOptions, i as InMemoryTracerStats, a as MetricExemplar, b as MetricSnapshot, j as MetricType, k as MetricValue, M as MetricsRegistry, R as RuntimeSpan, l as RuntimeSpanEvent, d as RuntimeTraceIdGenerator, m as defaultTracer, n as makeMetrics, r as runtimeHooksToEventHandler } from '../tracer-CS3yOXZx.js';

type TimeoutError = {
    readonly _tag: "TimeoutError";
    readonly ms: number;
};
/**
 * Suspends the fiber for `ms` milliseconds. Cancellable via fiber interruption.
 */
declare function sleep(ms: number): Async<unknown, never, void>;
/**
 * Runs `effect` with a timeout of `ms` milliseconds.
 * - If the effect completes before the timeout, returns its result.
 * - If the timeout fires first, the effect is cancelled and a TimeoutError is returned.
 *
 * Works with ANY effect type (Async, FlatMap, Fold, etc.) by forking
 * the effect into a child fiber and interrupting it on timeout.
 */
declare function timeout<R, E, A>(effect: Async<R, E, A>, ms: number): Async<R, E | TimeoutError, A>;
type RetryPolicy = {
    /** Maximum number of retry attempts (0 = no retries, just the initial attempt) */
    readonly maxRetries: number;
    /** Base delay in ms for exponential backoff */
    readonly baseDelayMs: number;
    /** Maximum delay cap in ms */
    readonly maxDelayMs: number;
    /** Total time budget in ms (optional). Retries stop if elapsed time exceeds this. */
    readonly maxElapsedMs?: number;
    /** Custom predicate: should this error trigger a retry? Default: always retry. */
    readonly shouldRetry?: (error: unknown, attempt: number) => boolean;
    /** Jitter strategy. Default: "full" (random 0..delay). "none" = no jitter. */
    readonly jitter?: "full" | "none";
};
type RetryState = {
    readonly attempt: number;
    readonly elapsedMs: number;
    readonly lastError: unknown;
};
/**
 * Retries an effect according to the given policy.
 * Uses exponential backoff with full jitter by default.
 *
 * ```ts
 * const result = retry(
 *   fetchData(),
 *   { maxRetries: 3, baseDelayMs: 100, maxDelayMs: 5000 }
 * );
 * ```
 */
declare function retry<R, E, A>(effect: Async<R, E, A>, policy: RetryPolicy): Async<R, E, A>;
/**
 * Retry with a simple count (no backoff, immediate retry).
 * Useful for flaky operations that just need a few attempts.
 */
declare function retryN<R, E, A>(effect: Async<R, E, A>, n: number): Async<R, E, A>;
/**
 * Retry with exponential backoff and full jitter.
 * Convenience wrapper with sensible defaults.
 */
declare function retryWithBackoff<R, E, A>(effect: Async<R, E, A>, opts?: {
    maxRetries?: number;
    baseDelayMs?: number;
    maxDelayMs?: number;
    maxElapsedMs?: number;
    shouldRetry?: (error: unknown, attempt: number) => boolean;
}): Async<R, E, A>;

type EffectSuccess<T> = T extends Async<any, any, infer A> ? A : never;
type EffectFailure<T> = T extends Async<any, infer E, any> ? E : never;
type EffectEnvironment<T> = T extends Async<infer R, any, any> ? R : never;
type MakeRuntimeOptions<R> = Omit<RuntimeOptions<R>, "env">;
/**
 * Create a runtime with a compact options shape.
 *
 * This is an additive DX helper over `new Runtime({ env, ...options })`.
 */
declare function makeRuntime<R extends object = {}>(env?: R, options?: MakeRuntimeOptions<R>): Runtime<R>;
/**
 * Run an effect and resolve with its success value.
 *
 * Accepts either a plain environment or an existing Runtime. For advanced
 * lifecycle/hooks/scheduler behavior, pass the Runtime explicitly.
 */
declare function runPromise<R, E, A>(effect: Async<R, E, A>, envOrRuntime?: R | Runtime<R>): Promise<A>;
/**
 * Run an effect and resolve with the full Exit, preserving typed failures and
 * Cause structure instead of throwing/rejecting.
 */
declare function runExit<R, E, A>(effect: Async<R, E, A>, envOrRuntime?: R | Runtime<R>): Promise<Exit<E, A>>;
declare const runEffect: typeof runPromise;

type Semaphore = {
    /** Current number of available permits. */
    readonly available: () => number;
    /** Total number of permits (capacity). */
    readonly capacity: number;
    /** Number of effects waiting for a permit. */
    readonly waiting: () => number;
    /** Acquire a permit, run the effect, and release the permit. */
    readonly withPermit: <R, E, A>(effect: Async<R, E, A>) => Async<R, E, A>;
    /** Acquire a permit (manual). Must call release() when done. */
    readonly acquire: () => Async<unknown, never, void>;
    /** Release a permit (manual). */
    readonly release: () => void;
};
type SemaphoreStats = {
    readonly capacity: number;
    readonly available: number;
    readonly waiting: number;
    readonly acquired: number;
    readonly released: number;
};
/**
 * Creates a counting semaphore with `n` permits.
 *
 * ```ts
 * const sem = makeSemaphore(5); // max 5 concurrent
 *
 * // Automatic acquire/release:
 * const result = await run(sem.withPermit(fetchData()));
 *
 * // Manual acquire/release:
 * await run(sem.acquire());
 * try { ... } finally { sem.release(); }
 * ```
 */
declare function makeSemaphore(n: number): Semaphore;

type Ref<A> = {
    /** Get the current value. */
    readonly get: () => Async<unknown, never, A>;
    /** Set a new value. */
    readonly set: (value: A) => Async<unknown, never, void>;
    /** Modify the value with a function and return the new value. */
    readonly update: (f: (current: A) => A) => Async<unknown, never, A>;
    /** Modify the value and return a derived result. */
    readonly modify: <B>(f: (current: A) => [B, A]) => Async<unknown, never, B>;
    /** Get the current value synchronously (for non-effect contexts). */
    readonly unsafeGet: () => A;
};
/**
 * Creates a mutable reference with an initial value.
 *
 * ```ts
 * const counter = makeRef(0);
 *
 * // In effects:
 * await run(counter.update(n => n + 1));
 * const value = await run(counter.get());
 *
 * // Synchronous access (outside effects):
 * counter.unsafeGet();
 * ```
 */
declare function makeRef<A>(initial: A): Ref<A>;
/**
 * Creates a derived Ref that applies a lens to a parent Ref.
 *
 * ```ts
 * const state = makeRef({ count: 0, name: "test" });
 * const countRef = derivedRef(state, s => s.count, (s, c) => ({ ...s, count: c }));
 * ```
 */
declare function derivedRef<A, B>(parent: Ref<A>, get: (a: A) => B, set: (a: A, b: B) => A): Ref<B>;

type FiberRef<A> = {
    readonly id: number;
    readonly initial: A;
    readonly get: () => Async<unknown, never, A>;
    readonly set: (value: A) => Async<unknown, never, void>;
    readonly update: (f: (current: A) => A) => Async<unknown, never, A>;
    readonly modify: <B>(f: (current: A) => [B, A]) => Async<unknown, never, B>;
    readonly locally: <R, E, B>(value: A, effect: Async<R, E, B>) => Async<R, E, B>;
    readonly locallyWith: <R, E, B>(f: (current: A) => A, effect: Async<R, E, B>) => Async<R, E, B>;
    readonly unsafeGet: () => A;
    readonly unsafeSet: (value: A) => void;
};
declare function makeFiberRef<A>(initial: A): FiberRef<A>;
declare function getFiberRef<A>(ref: FiberRef<A>): Async<unknown, never, A>;
declare function setFiberRef<A>(ref: FiberRef<A>, value: A): Async<unknown, never, void>;
declare function updateFiberRef<A>(ref: FiberRef<A>, f: (current: A) => A): Async<unknown, never, A>;
declare function modifyFiberRef<A, B>(ref: FiberRef<A>, f: (current: A) => [B, A]): Async<unknown, never, B>;
declare function locallyFiberRef<R, E, A, B>(ref: FiberRef<A>, value: A, effect: Async<R, E, B>): Async<R, E, B>;
declare function locallyFiberRefWith<R, E, A, B>(ref: FiberRef<A>, f: (current: A) => A, effect: Async<R, E, B>): Async<R, E, B>;
declare function unsafeGetFiberRef<A>(ref: FiberRef<A>): A;
declare function unsafeSetFiberRef<A>(ref: FiberRef<A>, value: A): void;
declare function fiberRefSnapshot(): ReadonlyMap<number, unknown>;

type ShutdownConfig = {
    /** Max time to wait for in-flight work to complete. Default: 30000ms */
    readonly timeoutMs?: number;
    /** Called when shutdown starts. */
    readonly onStart?: () => void;
    /** Called when shutdown completes. */
    readonly onComplete?: (stats: ShutdownStats) => void;
    /** Called if shutdown times out. */
    readonly onTimeout?: (stats: ShutdownStats) => void;
};
type ShutdownStats = {
    readonly startedAt: number;
    readonly completedAt: number;
    readonly elapsedMs: number;
    readonly timedOut: boolean;
};
/**
 * Performs a graceful shutdown of the runtime.
 *
 * 1. Signals the scheduler to stop accepting new work
 * 2. Waits for in-flight fibers to complete (up to timeoutMs)
 * 3. Calls the runtime's shutdown hook
 * 4. Reports stats
 *
 * ```ts
 * await gracefulShutdown(runtime, {
 *   timeoutMs: 5000,
 *   onStart: () => console.log("Shutting down..."),
 *   onComplete: (stats) => console.log(`Done in ${stats.elapsedMs}ms`),
 * });
 * ```
 */
declare function gracefulShutdown<R>(runtime: Runtime<R>, config?: ShutdownConfig): Promise<ShutdownStats>;
/**
 * Registers process signal handlers for graceful shutdown.
 * Handles SIGTERM and SIGINT (Ctrl+C).
 *
 * ```ts
 * registerShutdownHooks(runtime, {
 *   timeoutMs: 10000,
 *   onComplete: () => process.exit(0),
 *   onTimeout: () => process.exit(1),
 * });
 * ```
 */
declare function registerShutdownHooks<R>(runtime: Runtime<R>, config?: ShutdownConfig): () => void;

type TestRuntimeOptions = {
    /** Back-compat alias for autoFlush. When false, scheduled tasks only run when flushed. */
    readonly synchronous?: boolean;
    /** Automatically flush scheduled tasks in a microtask. Default: true. */
    readonly autoFlush?: boolean;
    /** Initial virtual clock time in milliseconds. Default: 0. */
    readonly initialTimeMs?: number;
    /** Safety limit for flushAll/runAllTimers. Default: 10_000. */
    readonly maxSteps?: number;
};
type TestScheduledTask = {
    readonly tag: string;
    readonly run: Task;
};
declare class TestScheduler {
    private readonly options;
    private readonly queue;
    private readonly maxSteps;
    private autoFlushScheduled;
    private flushing;
    private enqueuedTasks;
    private executedTasks;
    private droppedTasks;
    private scheduledFlushes;
    private completedFlushes;
    constructor(options?: Pick<TestRuntimeOptions, "autoFlush" | "synchronous" | "maxSteps">);
    schedule(task: Task, tag?: string): ScheduleResult;
    scheduleBatch(tasks: Array<{
        fn: Task;
        tag: string;
    }>): ScheduleResult[];
    stats(): SchedulerStats;
    pending(): readonly TestScheduledTask[];
    size(): number;
    flush(maxTasks?: number): number;
    flushAll(maxSteps?: number): number;
    private requestAutoFlush;
}
type TestClockTimerSnapshot = {
    readonly id: number;
    readonly dueAt: number;
    readonly delayMs: number;
};
declare class TestClock implements RuntimeClock {
    private readonly flushScheduler;
    private readonly maxSteps;
    private nowMs;
    private nextId;
    private nextSeq;
    private readonly timers;
    constructor(initialTimeMs?: number, flushScheduler?: () => void, maxSteps?: number);
    now(): number;
    setTimeout(task: () => void, ms: number): RuntimeTimerId;
    clearTimeout(timer: RuntimeTimerId): void;
    pendingTimers(): readonly TestClockTimerSnapshot[];
    adjust(ms: number): number;
    advance(ms: number): number;
    advanceTo(targetMs: number): number;
    runDue(): number;
    runAll(maxSteps?: number): number;
    clear(): void;
    private nextDueTimer;
}
type TestRuntime<R> = {
    readonly env: R & RuntimeClockEnv;
    readonly runtime: Runtime<R & RuntimeClockEnv>;
    readonly scheduler: TestScheduler;
    readonly clock: TestClock;
    readonly run: <E, A>(effect: Async<any, E, A>) => Promise<A>;
    readonly runExit: <E, A>(effect: Async<any, E, A>) => Promise<Exit<E, A>>;
    readonly fork: <E, A>(effect: Async<any, E, A>) => ReturnType<Runtime<R & RuntimeClockEnv>["fork"]>;
    readonly flush: (maxTasks?: number) => number;
    readonly flushAll: (maxSteps?: number) => number;
    readonly advance: (ms: number) => number;
    readonly advanceTo: (targetMs: number) => number;
    readonly runDueTimers: () => number;
    readonly runAllTimers: (maxSteps?: number) => number;
};
/**
 * Creates a deterministic TypeScript test runtime.
 *
 * The returned runtime uses:
 * - a `TestScheduler` that can be flushed manually,
 * - a `TestClock` for virtual `sleep`, `timeout`, retry backoff, and `Runtime.delay`,
 * - the normal TS fiber interpreter, so tests exercise the same runtime model as production.
 */
declare function makeTestRuntime<R extends object = {}>(env?: R, options?: TestRuntimeOptions): TestRuntime<R>;
/**
 * Asserts that an effect succeeds with a specific value.
 *
 * ```ts
 * await assertSucceeds(myEffect, 42);
 * ```
 */
declare function assertSucceeds<R, E, A>(effect: Async<R, E, A>, expected: A, runtime?: Runtime<R>): Promise<void>;
/**
 * Asserts that an effect fails with a specific error.
 *
 * ```ts
 * await assertFails(myEffect, "not found");
 * ```
 */
declare function assertFails<R, E, A>(effect: Async<R, E, A>, expectedError: E, runtime?: Runtime<R>): Promise<void>;
/**
 * Asserts that an effect fails with an error matching a predicate.
 *
 * ```ts
 * await assertFailsWith(myEffect, (e) => e._tag === "NotFound");
 * ```
 */
declare function assertFailsWith<R, E, A>(effect: Async<R, E, A>, predicate: (error: E) => boolean, runtime?: Runtime<R>): Promise<void>;
/**
 * Asserts that an effect completes within a time limit.
 *
 * ```ts
 * await assertCompletesWithin(myEffect, 100); // must finish in 100ms
 * ```
 */
declare function assertCompletesWithin<R, E, A>(effect: Async<R, E, A>, maxMs: number, runtime?: Runtime<R>): Promise<A>;
/**
 * Creates an effect that fails on the first N calls, then succeeds.
 * Useful for testing retry logic.
 *
 * ```ts
 * const flaky = flakyEffect(3, "success!", "temporary error");
 * // Fails 3 times, then returns "success!"
 * ```
 */
declare function flakyEffect<E, A>(failCount: number, successValue: A, errorValue: E): Async<unknown, E, A>;
/**
 * Creates an effect that takes a specific amount of time to complete.
 * Useful for testing timeouts and concurrency.
 *
 * ```ts
 * const slow = delayedEffect(100, "done"); // completes after 100ms
 * ```
 */
declare function delayedEffect<A>(ms: number, value: A): Async<unknown, never, A>;
/**
 * Creates an effect that never completes (hangs forever).
 * Useful for testing timeouts and interruption.
 */
declare function neverEffect<A = never>(): Async<unknown, never, A>;

type ConfigLayerSource = unknown | ((context: LayerContext) => unknown);
type ConfigLayerOptions = {
    readonly name?: string;
};
declare function makeConfigLayer<A>(tag: ServiceTag<A>, schema: JsonSchemaLike<A>, source: ConfigLayerSource, options?: ConfigLayerOptions): Layer<LayerContext, unknown, LayerContext>;
declare const defineConfigLayer: typeof makeConfigLayer;

declare const RuntimeService: ServiceTag<Runtime<any>>;
type RuntimeLayerEnv<R extends object> = R | ((context: LayerContext) => R);
type RuntimeLayerOptions<R extends object> = Omit<RuntimeOptions<R>, "env"> & {
    readonly tag?: ServiceTag<Runtime<R>>;
};
declare function makeRuntimeLayer<R extends object = {}>(env?: RuntimeLayerEnv<R>, options?: RuntimeLayerOptions<R>): Layer<LayerContext, unknown, LayerContext>;

type WorkerPoolConfig = {
    /** Number of worker threads. Default: number of CPUs - 1 */
    readonly size?: number;
    /** Max queued tasks. Tasks beyond this are rejected. Default: 1000 */
    readonly maxQueue?: number;
    /** Task timeout in ms. Default: 30000 */
    readonly taskTimeoutMs?: number;
};
type WorkerPoolError = {
    readonly _tag: "WorkerPoolFull";
    readonly queued: number;
} | {
    readonly _tag: "WorkerTaskTimeout";
    readonly ms: number;
} | {
    readonly _tag: "WorkerTaskError";
    readonly message: string;
} | {
    readonly _tag: "WorkerPoolClosed";
};
type WorkerPool = {
    /** Execute a function in a worker thread. */
    readonly execute: <A>(fn: () => A) => Async<unknown, WorkerPoolError, A>;
    /** Execute a serializable task (function source + args). */
    readonly run: <A>(taskSource: string, args?: any[]) => Async<unknown, WorkerPoolError, A>;
    /** Current pool stats. */
    readonly stats: () => WorkerPoolStats;
    /** Shutdown the pool (terminate all workers). */
    readonly shutdown: () => Promise<void>;
};
type WorkerPoolStats = {
    readonly size: number;
    readonly busy: number;
    readonly idle: number;
    readonly queued: number;
    readonly completed: number;
    readonly failed: number;
    readonly timedOut: number;
};
/**
 * Creates a worker pool for CPU-intensive tasks.
 *
 * NOTE: This is a simplified implementation that uses setTimeout to simulate
 * async execution. For real worker_threads support, the pool would need to
 * spawn actual Worker instances. This provides the API contract and can be
 * upgraded to real threads when needed.
 *
 * ```ts
 * const pool = makeWorkerPool({ size: 4 });
 *
 * const result = await run(pool.execute(() => heavyComputation()));
 *
 * await pool.shutdown();
 * ```
 */
declare function makeWorkerPool(config?: WorkerPoolConfig): WorkerPool;

type RuntimeRecorderOptions = {
    readonly maxEvents?: number;
};
type RuntimeRecorderStats = {
    readonly size: number;
    readonly capacity: number;
    readonly dropped: number;
    readonly firstSeq?: number;
    readonly lastSeq?: number;
};
type RuntimeRecorderExplainOptions = {
    readonly maxEvents?: number;
};
type RuntimeRecorder = RuntimeHooks & {
    readonly hooks: RuntimeHooks;
    readonly snapshot: () => readonly RuntimeEventRecord[];
    readonly clear: () => void;
    readonly stats: () => RuntimeRecorderStats;
    readonly explain: (options?: RuntimeRecorderExplainOptions) => string;
};
declare function makeRuntimeRecorder(options?: RuntimeRecorderOptions): RuntimeRecorder;

type LogLevel = "debug" | "info" | "warn" | "error";
declare function consoleJsonLogger(): RuntimeHooks;

declare function dumpAllFibers(reg: RuntimeRegistry): string;

/**
 * Base type for tagged errors. All errors should extend this pattern:
 *
 * ```ts
 * type NetworkError = { _tag: "NetworkError"; url: string; status: number };
 * type TimeoutError = { _tag: "TimeoutError"; ms: number };
 * type AppError = NetworkError | TimeoutError;
 * ```
 */
type TaggedError = {
    readonly _tag: string;
};
/**
 * Catches a specific error by its `_tag` field and handles it.
 * Other errors pass through unchanged.
 *
 * ```ts
 * const result = catchTag(effect, "NetworkError", (e) => fallbackValue);
 * // e is narrowed to NetworkError
 * ```
 */
declare function catchTag<R, E extends TaggedError, A, Tag extends E["_tag"], B>(effect: Async<R, E, A>, tag: Tag, handler: (error: Extract<E, {
    _tag: Tag;
}>) => Async<R, Exclude<E, {
    _tag: Tag;
}>, A | B>): Async<R, Exclude<E, {
    _tag: Tag;
}>, A | B>;
/**
 * Catches multiple error tags with a single handler map.
 *
 * ```ts
 * const result = catchTags(effect, {
 *   NetworkError: (e) => asyncSucceed(defaultValue),
 *   TimeoutError: (e) => retry(effect),
 * });
 * ```
 */
declare function catchTags<R, E extends TaggedError, A, Handlers extends Partial<{
    [K in E["_tag"]]: (error: Extract<E, {
        _tag: K;
    }>) => Async<R, any, any>;
}>>(effect: Async<R, E, A>, handlers: Handlers): Async<R, Exclude<E, {
    _tag: keyof Handlers & string;
}>, A>;
/**
 * Maps the error channel of an effect.
 *
 * ```ts
 * const result = mapError(effect, (e) => ({ _tag: "Wrapped", cause: e }));
 * ```
 */
declare function mapError<R, E, E2, A>(effect: Async<R, E, A>, f: (error: E) => E2): Async<R, E2, A>;
/**
 * Wraps any error with a tag, making it part of a discriminated union.
 *
 * ```ts
 * const typed = tagError(fetchData(), "NetworkError", (e) => ({ url, cause: e }));
 * // Error type becomes { _tag: "NetworkError"; url: string; cause: unknown }
 * ```
 */
declare function tagError<R, E, A, Tag extends string, Fields extends Record<string, unknown>>(effect: Async<R, E, A>, tag: Tag, enrich?: (error: E) => Fields): Async<R, {
    _tag: Tag;
} & Fields, A>;
/**
 * If the effect fails, run the fallback instead.
 *
 * ```ts
 * const result = orElse(primary(), () => fallback());
 * ```
 */
declare function orElse<R, E, A, R2, E2, B>(effect: Async<R, E, A>, fallback: (error: E) => Async<R2, E2, B>): Async<R & R2, E2, A | B>;

type SupervisorStrategy = "one-for-one" | "all-for-one";
type SupervisorEscalation = "ignore" | "shutdown";
type SupervisorRestartMode = "never" | "always" | "on-failure";
type SupervisedChildStatus = "running" | "restarting" | "succeeded" | "failed" | "interrupted";
type SupervisorRestartContext = {
    readonly supervisorId: number;
    readonly childId: number;
    readonly name?: string;
    readonly restartCount: number;
    readonly exit: Exit<any, any>;
};
type SupervisorRestartPolicy = SupervisorRestartMode | {
    readonly mode?: SupervisorRestartMode;
    readonly maxRestarts?: number;
    readonly withinMs?: number;
    readonly delayMs?: number | ((context: SupervisorRestartContext) => number);
    readonly schedule?: Schedule<SupervisorRestartContext, unknown>;
};
type SupervisorEvent = {
    readonly type: "child-start" | "child-end" | "child-restart" | "child-escalate" | "shutdown";
    readonly supervisorId: number;
    readonly childId?: number;
    readonly name?: string;
    readonly status?: SupervisedChildStatus;
    readonly restartCount?: number;
    readonly delayMs?: number;
    readonly exit?: Exit<any, any>;
    readonly reason?: string;
};
type SupervisorConfig = {
    readonly strategy?: SupervisorStrategy;
    readonly restart?: SupervisorRestartPolicy;
    readonly escalation?: SupervisorEscalation;
    readonly clock?: () => number;
    readonly onEvent?: (event: SupervisorEvent) => void;
};
type SupervisedChildSpec<R, E, A> = {
    readonly name?: string;
    readonly effect: Async<R, E, A> | (() => Async<R, E, A>);
    readonly restart?: SupervisorRestartPolicy;
};
type SupervisedFiber<E, A> = {
    readonly id: number;
    readonly name?: string;
    readonly current: () => Fiber<E, A> | undefined;
    readonly status: () => SupervisedChildStatus;
    readonly restartCount: () => number;
    readonly interrupt: () => void;
    readonly join: (cb: (exit: Exit<E, A>) => void) => void;
};
declare class Supervisor<R> {
    private readonly runtime;
    readonly id: number;
    private readonly records;
    private readonly strategy;
    private readonly restart;
    private readonly escalation;
    private readonly clock;
    private readonly onEvent?;
    private closed;
    constructor(runtime: Runtime<R>, config?: SupervisorConfig);
    start<E, A>(spec: SupervisedChildSpec<R, E, A>): SupervisedFiber<E, A>;
    startAll<const Specs extends readonly SupervisedChildSpec<R, any, any>[]>(specs: Specs): {
        [K in keyof Specs]: Specs[K] extends SupervisedChildSpec<R, infer E, infer A> ? SupervisedFiber<E, A> : never;
    };
    shutdown(): Async<R, never, void>;
    private handle;
    private launch;
    private onChildExit;
    private restartAll;
    private scheduleRestart;
    private nextDelay;
    private escalate;
    private finish;
    private restartContext;
    private emit;
    private scheduleClock;
}
declare function makeSupervisor<R>(runtime: Runtime<R>, config?: SupervisorConfig): Supervisor<R>;
declare function supervise<R, E, A>(runtime: Runtime<R>, spec: SupervisedChildSpec<R, E, A>, config?: SupervisorConfig): SupervisedFiber<E, A>;
declare function joinSupervised<E, A>(fiber: SupervisedFiber<E, A>): Async<unknown, E, A>;

export { Async, type ConfigLayerOptions, type ConfigLayerSource, type EffectEnvironment, type EffectFailure, type EffectSuccess, Exit, Fiber, type FiberRef, Layer, LayerContext, type LogLevel, type MakeRuntimeOptions, type Ref, type RetryPolicy, type RetryState, Runtime, RuntimeClock, RuntimeClockEnv, RuntimeEventRecord, RuntimeHooks, type RuntimeLayerEnv, type RuntimeLayerOptions, RuntimeOptions, type RuntimeRecorder, type RuntimeRecorderExplainOptions, type RuntimeRecorderOptions, type RuntimeRecorderStats, RuntimeRegistry, RuntimeService, RuntimeTimerId, Schedule, type Semaphore, type SemaphoreStats, ServiceTag, type ShutdownConfig, type ShutdownStats, type SupervisedChildSpec, type SupervisedChildStatus, type SupervisedFiber, Supervisor, type SupervisorConfig, type SupervisorEscalation, type SupervisorEvent, type SupervisorRestartContext, type SupervisorRestartMode, type SupervisorRestartPolicy, type SupervisorStrategy, type TaggedError, TestClock, type TestClockTimerSnapshot, type TestRuntime, type TestRuntimeOptions, type TestScheduledTask, TestScheduler, type TimeoutError, type WorkerPool, type WorkerPoolConfig, type WorkerPoolError, type WorkerPoolStats, assertCompletesWithin, assertFails, assertFailsWith, assertSucceeds, catchTag, catchTags, consoleJsonLogger, defineConfigLayer, delayedEffect, derivedRef, dumpAllFibers, fiberRefSnapshot, flakyEffect, getFiberRef, gracefulShutdown, joinSupervised, locallyFiberRef, locallyFiberRefWith, makeConfigLayer, makeFiberRef, makeRef, makeRuntime, makeRuntimeLayer, makeRuntimeRecorder, makeSemaphore, makeSupervisor, makeTestRuntime, makeWorkerPool, mapError as mapErrorTyped, modifyFiberRef, neverEffect, orElse, registerShutdownHooks, retry, retryN, retryWithBackoff, runEffect, runExit, runPromise, setFiberRef, sleep, supervise, tagError, timeout, unsafeGetFiberRef, unsafeSetFiberRef, updateFiberRef };