brass-runtime 1.14.0 → 1.16.0

package/dist/core/index.d.ts

@@ -0,0 +1,567 @@
+import { A as Async, f as Runtime, E as Exit, R as RuntimeHooks, g as RuntimeRegistry, k as Fiber } from '../effect-CGNl5Rqp.js';
+export { u as AbortablePromiseFinish, v as AbortablePromiseLabelStats, w as AbortablePromiseOptions, x as AbortablePromiseOutcome, y as AbortablePromiseStats, C as AsyncWithPromise, G as CancelToken, H as Canceler, I as Cause, K as ContextNode, Y as FiberContext, l as FiberId, $ as FiberInfo, a3 as FiberRunState, m as FiberStatus, af as Interrupted, J as JSONValue, ai as None, aj as NoopHooks, O as Option, c as RuntimeEmitContext, b as RuntimeEvent, d as RuntimeEventRecord, i as RuntimeFiber, h as RuntimeOptions, e as RuntimeSpanLink, S as Scope, aB as ScopeId, aC as ScopeInfo, aD as Some, T as TraceContext, Z as ZIO, aI as abortablePromiseStats, aJ as acquireRelease, aK as async, aL as asyncCatchAll, aM as asyncFail, aN as asyncFlatMap, aO as asyncFold, aP as asyncInterruptible, aQ as asyncMap, aR as asyncMapError, aS as asyncSucceed, aT as asyncSync, aU as asyncTotal, aV as catchAll, aW as ctxExtend, aX as ctxToObject, aY as emptyContext, aZ as end, a$ as fail, b0 as flatMap, b1 as fork, b2 as fromPromiseAbortable, b3 as getBenchmarkBudget, b4 as getCurrentFiber, b8 as linkAbortController, ba as makeCancelToken, bc as makeRuntimeEventRecord, bd as map, be as mapAsync, bf as mapError, bg as mapTryAsync, bh as none, bi as orElseOptional, bj as resetAbortablePromiseStats, bl as runtimeEventRecordContext, bm as runtimeForCaller, bp as setBenchmarkBudget, bq as some, br as succeed, bs as sync, bt as toPromise, bu as toPromiseByCaller, bv as unit, bw as unsafeGetCurrentRuntime, bx as unsafeRunAsync, by as unsafeRunFoldWithEnv, bz as withAsyncPromise, bA as withCurrentFiber, bB as withScope, bC as withScopeAsync } from '../effect-CGNl5Rqp.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-Dt9S_6V8.js';
+import { S as Schedule } from '../schedule-Fque9Abz.js';
+export { a as ScheduleDecision, b as andThenSchedule, c as contramapSchedule, e as elapsed, d as exponential, f as fibonacci, g as fixed, i as intersect, j as jitter, h as jittered, k as jitteredSchedule, m as mapSchedule, r as recurs, l as repeatWithSchedule, n as retryWithSchedule, t as takeSchedule, u as union, w as whileInput, o as windowed } from '../schedule-Fque9Abz.js';
+export { B as BrassEnv, f as CircuitBreaker, g as CircuitBreakerConfig, h as CircuitBreakerError, i as CircuitBreakerState, C as CircuitBreakerStats, j as Counter, E as EventBus, k as EventBusOptions, l as EventHandler, G as Gauge, H as Histogram, m as HistogramBuckets, I as InMemoryTracer, e as InMemoryTracerOptions, n as InMemoryTracerStats, a as MetricExemplar, b as MetricSnapshot, o as MetricType, p as MetricValue, M as MetricsRegistry, R as RuntimeSpan, q as RuntimeSpanEvent, d as RuntimeTraceIdGenerator, r as defaultTracer, s as makeCircuitBreaker, t as makeMetrics, u as runtimeHooksToEventHandler } from '../tracer-B5tRH9H7.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 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 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 = {
+    /** If true, effects run synchronously where possible. Default: true */
+    readonly synchronous?: boolean;
+};
+/**
+ * Creates a test runtime that provides controlled execution.
+ *
+ * ```ts
+ * const { runtime, run, runExit } = makeTestRuntime();
+ *
+ * const result = await run(myEffect);
+ * const exit = await runExit(myEffect); // get full Exit (success or failure)
+ * ```
+ */
+declare function makeTestRuntime<R = {}>(env?: R, options?: TestRuntimeOptions): {
+    runtime: Runtime<R>;
+    run: <E, A>(effect: Async<R, E, A>) => Promise<A>;
+    runExit: <E, A>(effect: Async<R, E, A>) => Promise<Exit<E, A>>;
+};
+/**
+ * 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>;
+
+/**
+ * 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>;
+    }>;
+};
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+
+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 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;
+}
+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, Exit, Fiber, type Layer, type LogLevel, type Ref, type RetryPolicy, type RetryState, Runtime, RuntimeHooks, RuntimeRegistry, Schedule, type Semaphore, type SemaphoreStats, 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, type TestRuntimeOptions, type TimeoutError, type WorkerPool, type WorkerPoolConfig, type WorkerPoolError, type WorkerPoolStats, assertCompletesWithin, assertFails, assertFailsWith, assertSucceeds, catchTag, catchTags, compose as composeLayer, consoleJsonLogger, delayedEffect, derivedRef, dumpAllFibers, flakyEffect, gracefulShutdown, joinSupervised, layer, layerFail, layerFrom, layerSucceed, makeRef, makeSemaphore, makeSupervisor, makeTestRuntime, makeWorkerPool, mapError as mapErrorTyped, mapLayer, merge as mergeLayer, neverEffect, orElse, provideLayer, registerShutdownHooks, retry, retryN, retryWithBackoff, sleep, supervise, tagError, timeout };