brass-runtime 1.16.0 → 1.17.0

package/dist/core/index.d.ts

@@ -1,9 +1,9 @@
-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';
+import { A as Async, h as RuntimeOptions, f as Runtime, E as Exit, aI as Task, ax as ScheduleResult, aC as SchedulerStats, R as RuntimeHooks, d as RuntimeEventRecord, g as RuntimeRegistry, k as Fiber } from '../effect-DIUHZ9IN.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 CausePrettyOptions, L as ContextNode, _ as FiberContext, l as FiberId, a0 as FiberInfo, a4 as FiberRunState, m as FiberStatus, ag as Interrupted, ah as InterruptibilityMode, J as JSONValue, ak as None, al as NoopHooks, O as Option, ar as RestoreInterruptibility, a as RuntimeEmitContext, c as RuntimeEvent, i as RuntimeFiber, e as RuntimeSpanLink, S as Scope, aE as ScopeId, aF as ScopeInfo, aG as Some, T as TraceContext, Z as ZIO, aL as abortablePromiseStats, aM as acquireRelease, aN as async, aO as asyncCatchAll, aP as asyncFail, aQ as asyncFlatMap, aR as asyncFold, aS as asyncInterruptible, aT as asyncMap, aU as asyncMapError, aV as asyncSucceed, aW as asyncSync, aX as asyncTotal, aY as catchAll, aZ as ctxExtend, a_ as ctxToObject, a$ as emptyContext, b0 as end, b2 as fail, b3 as flatMap, b4 as fork, b5 as formatCause, b6 as fromPromiseAbortable, b7 as getBenchmarkBudget, b8 as getCurrentFiber, bb as interruptible, bc as isCause, be as linkAbortController, bg as makeCancelToken, bi as makeRuntimeEventRecord, bj as map, bk as mapAsync, bl as mapError, bm as mapTryAsync, bn as none, bo as orElseOptional, bp as prettyCause, bq as resetAbortablePromiseStats, bs as runtimeEventRecordContext, bt as runtimeForCaller, bw as setBenchmarkBudget, bx as some, by as succeed, bz as sync, bA as toPromise, bB as toPromiseByCaller, bC as uninterruptible, bD as uninterruptibleMask, bE as unit, bF as unsafeGetCurrentRuntime, bG as unsafeRunAsync, bH as unsafeRunFoldWithEnv, bI as withAsyncPromise, bJ as withCurrentFiber, bK as withScope, bL as withScopeAsync } from '../effect-DIUHZ9IN.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-DqbTKGcf.js';
+import { R as RuntimeClock, g as RuntimeTimerId, f as RuntimeClockEnv, S as Schedule } from '../schedule-CK3Ml_7p.js';
+export { c as CircuitBreaker, d as CircuitBreakerConfig, C as CircuitBreakerError, e as CircuitBreakerState, b as CircuitBreakerStats, h as ScheduleDecision, i as ScheduleDriver, j as ScheduleDriverDecision, k as ScheduleDriverOptions, l as ScheduleDriverSnapshot, a as ScheduleObserver, m as ScheduleObserverEvent, n as ScheduleStepContext, o as andThenSchedule, p as contramapSchedule, q as elapsed, r as exponential, s as fibonacci, t as fixed, u as forever, v as intersect, w as jitter, x as jittered, y as jitteredSchedule, z as linear, A as liveClock, B as makeCircuitBreaker, D as makeScheduleDriver, E as mapSchedule, F as maxDelay, G as maxElapsed, H as namedSchedule, I as never, J as once, K as pollWithSchedule, L as recurs, M as repeatWithSchedule, N as repeatWithScheduleAlias, O as retryWithSchedule, P as retryWithScheduleAlias, Q as runSchedule, T as runtimeClockFromEnv, U as scheduleDriver, V as spaced, W as takeSchedule, X as tapDecision, Y as union, Z as untilInput, _ as untilOutput, $ as upTo, a0 as whileInput, a1 as whileOutput, a2 as windowed } from '../schedule-CK3Ml_7p.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-Hwt1cl7h.js';
 
 type TimeoutError = {
     readonly _tag: "TimeoutError";
@@ -70,6 +70,30 @@ declare function retryWithBackoff<R, E, A>(effect: Async<R, E, A>, opts?: {
     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;
@@ -144,6 +168,29 @@ declare function makeRef<A>(initial: A): Ref<A>;
  */
 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;
@@ -192,24 +239,92 @@ declare function gracefulShutdown<R>(runtime: Runtime<R>, config?: ShutdownConfi
 declare function registerShutdownHooks<R>(runtime: Runtime<R>, config?: ShutdownConfig): () => void;
 
 type TestRuntimeOptions = {
-    /** If true, effects run synchronously where possible. Default: true */
+    /** 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 test runtime that provides controlled execution.
- *
- * ```ts
- * const { runtime, run, runExit } = makeTestRuntime();
+ * Creates a deterministic TypeScript test runtime.
  *
- * const result = await run(myEffect);
- * const exit = await runExit(myEffect); // get full Exit (success or failure)
- * ```
+ * 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 = {}>(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>>;
-};
+declare function makeTestRuntime<R extends object = {}>(env?: R, options?: TestRuntimeOptions): TestRuntime<R>;
 /**
  * Asserts that an effect succeeds with a specific value.
  *
@@ -267,20 +382,43 @@ declare function delayedEffect<A>(ms: number, value: A): Async<unknown, never, A
  */
 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>;
-    }>;
+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>;
+};
+declare function makeLayerScope(): LayerScope;
 /**
  * Creates a Layer from an acquire/release pair.
  *
@@ -292,6 +430,11 @@ type Layer<RIn, E, ROut> = {
  * ```
  */
 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 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>;
 /**
  * Creates a Layer that depends on another service.
  *
@@ -337,6 +480,7 @@ declare function merge<R1, E1, A, R2, E2, B>(left: Layer<R1, E1, A>, right: Laye
  * 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.
  *
@@ -347,6 +491,44 @@ declare function mapLayer<RIn, E, A, B>(l: Layer<RIn, E, A>, f: (a: A) => B): La
  * ```
  */
 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;
+    effect: typeof layerEffect;
+    define: typeof layerEffect;
+    fromContext: typeof layerEffect;
+    compose: typeof compose;
+    merge: typeof merge;
+    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;
+}>;
 
 type WorkerPoolConfig = {
     /** Number of worker threads. Default: number of CPUs - 1 */
@@ -405,6 +587,28 @@ type WorkerPoolStats = {
  */
 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;
 
@@ -559,9 +763,10 @@ declare class Supervisor<R> {
     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, 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 };
+export { Async, type BuiltLayer, type EffectEnvironment, type EffectFailure, type EffectSuccess, Exit, Fiber, type FiberRef, Layer, LayerContext, type LayerScope, type LogLevel, type MakeRuntimeOptions, MissingLayerServiceError, type Ref, type RetryPolicy, type RetryState, Runtime, RuntimeClock, RuntimeClockEnv, RuntimeEventRecord, RuntimeHooks, RuntimeOptions, type RuntimeRecorder, type RuntimeRecorderExplainOptions, type RuntimeRecorderOptions, type RuntimeRecorderStats, RuntimeRegistry, RuntimeTimerId, Schedule, type Semaphore, type SemaphoreStats, type 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, buildLayer, catchTag, catchTags, compose as composeLayer, consoleJsonLogger, defineLayer, defineService, delayedEffect, derivedRef, dumpAllFibers, fiberRefSnapshot, flakyEffect, formatLayerError, getFiberRef, getService, gracefulShutdown, joinSupervised, layer, layerEffect, layerFail, layerFrom, layerFromContext, layerSucceed, layerValue, locallyFiberRef, locallyFiberRefWith, makeFiberRef, makeLayerScope, makeRef, makeRuntime, makeRuntimeRecorder, makeSemaphore, makeServiceTag, makeSupervisor, makeTestRuntime, makeWorkerPool, mapError as mapErrorTyped, mapLayer, merge as mergeLayer, modifyFiberRef, neverEffect, orElse, provide, provideContext, provideLayer, provideLayerContext, registerShutdownHooks, retry, retryN, retryWithBackoff, runEffect, runExit, runPromise, serviceTag, setFiberRef, sleep, supervise, tagError, timeout, unsafeGetFiberRef, unsafeSetFiberRef, updateFiberRef };