brass-runtime 1.15.0 → 1.16.1

package/dist/core/index.d.ts

@@ -1,6 +1,9 @@
-import { A as Async, E as Exit, aa as Runtime } from '../effect-CMOQKX8y.js';
-export { n as AbortablePromiseFinish, o as AbortablePromiseLabelStats, p as AbortablePromiseOptions, q as AbortablePromiseOutcome, r as AbortablePromiseStats, t as AsyncWithPromise, C as CancelToken, v as Canceler, w as Cause, b as Fiber, c as FiberId, d as FiberStatus, _ as Interrupted, a1 as None, a2 as NoopHooks, O as Option, R as RuntimeFiber, ad as RuntimeOptions, S as Scope, ak as ScopeId, al as Some, Z as ZIO, aq as abortablePromiseStats, ar as acquireRelease, as as async, at as asyncCatchAll, au as asyncFail, av as asyncFlatMap, aw as asyncFold, ax as asyncInterruptible, ay as asyncMap, az as asyncMapError, aA as asyncSucceed, aB as asyncSync, aC as asyncTotal, aD as catchAll, aE as end, aG as fail, aH as flatMap, aI as fork, aJ as fromPromiseAbortable, aK as getBenchmarkBudget, aL as getCurrentFiber, aP as linkAbortController, aR as makeCancelToken, aS as map, aT as mapAsync, aU as mapError, aV as mapTryAsync, aW as none, aX as orElseOptional, aY as resetAbortablePromiseStats, a_ as runtimeForCaller, b1 as setBenchmarkBudget, b2 as some, b3 as succeed, b4 as sync, b5 as toPromise, b6 as toPromiseByCaller, b7 as unit, b8 as unsafeGetCurrentRuntime, b9 as unsafeRunAsync, ba as unsafeRunFoldWithEnv, bb as withAsyncPromise, bc as withCurrentFiber, bd as withScope, be as withScopeAsync } from '../effect-CMOQKX8y.js';
-export { C as CircuitBreaker, a as CircuitBreakerConfig, b as CircuitBreakerError, c as CircuitBreakerState, d as CircuitBreakerStats, S as Span, e as SpanContext, f as SpanEvent, g as SpanStatus, T as Tracer, h as TracerConfig, m as makeCircuitBreaker, i as makeTracer } from '../tracing-DNT9jEbr.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";
@@ -67,73 +70,29 @@ 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">;
 /**
- * Acquires a resource, uses it, and guarantees release regardless of outcome.
+ * Create a runtime with a compact options shape.
  *
- * - `acquire` runs uninterruptibly (once started, it completes)
- * - `use` runs with the acquired resource
- * - `release` runs after `use` completes (success, failure, or interruption)
- *
- * ```ts
- * const result = bracket(
- *   openConnection(),                    // acquire
- *   (conn) => queryDatabase(conn),       // use
- *   (conn, exit) => conn.close()         // release (always runs)
- * );
- * ```
- */
-declare function bracket<R, E, A, B>(acquire: Async<R, E, A>, use: (resource: A) => Async<R, E, B>, release: (resource: A, exit: Exit<E, B>) => Async<R, any, void>): Async<R, E, B>;
-/**
- * Runs `effect` and then runs `finalizer` regardless of the outcome.
- * The finalizer receives the exit value for inspection.
- *
- * ```ts
- * const result = ensuring(
- *   doWork(),
- *   (exit) => logCompletion(exit)
- * );
- * ```
+ * This is an additive DX helper over `new Runtime({ env, ...options })`.
  */
-declare function ensuring<R, E, A>(effect: Async<R, E, A>, finalizer: (exit: Exit<E, A>) => Async<R, any, void>): Async<R, E, A>;
+declare function makeRuntime<R extends object = {}>(env?: R, options?: MakeRuntimeOptions<R>): Runtime<R>;
 /**
- * A Managed resource describes how to acquire and release a resource.
- * It can be used multiple times — each `use` call acquires a fresh instance.
- *
- * ```ts
- * const dbPool = managed(
- *   createPool({ max: 10 }),
- *   (pool) => pool.close()
- * );
+ * Run an effect and resolve with its success value.
  *
- * // Use it:
- * const result = useManaged(dbPool, (pool) => pool.query("SELECT 1"));
- * ```
- */
-type Managed<R, E, A> = {
-    readonly _tag: "Managed";
-    readonly acquire: Async<R, E, A>;
-    readonly release: (resource: A, exit: Exit<any, any>) => Async<R, any, void>;
-};
-/**
- * Creates a Managed resource descriptor.
+ * Accepts either a plain environment or an existing Runtime. For advanced
+ * lifecycle/hooks/scheduler behavior, pass the Runtime explicitly.
  */
-declare function managed<R, E, A>(acquire: Async<R, E, A>, release: (resource: A, exit?: Exit<any, any>) => Async<R, any, void>): Managed<R, E, A>;
+declare function runPromise<R, E, A>(effect: Async<R, E, A>, envOrRuntime?: R | Runtime<R>): Promise<A>;
 /**
- * Uses a Managed resource: acquires, runs the body, and releases.
+ * Run an effect and resolve with the full Exit, preserving typed failures and
+ * Cause structure instead of throwing/rejecting.
  */
-declare function useManaged<R, E, A, B>(m: Managed<R, E, A>, body: (resource: A) => Async<R, E, B>): Async<R, E, B>;
-/**
- * Combines multiple Managed resources. All are acquired in order,
- * and released in reverse order (LIFO).
- *
- * ```ts
- * const resources = managedAll([dbPool, cacheConn, fileHandle]);
- * const result = useManaged(resources, ([db, cache, file]) => ...);
- * ```
- */
-declare function managedAll<R, E, Resources extends readonly any[]>(manageds: {
-    [K in keyof Resources]: Managed<R, E, Resources[K]>;
-}): Managed<R, E, Resources>;
+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. */
@@ -209,52 +168,28 @@ 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 ScheduleDecision = {
-    readonly continue: boolean;
-    readonly delayMs: number;
+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;
 };
-/**
- * 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";
-    /** Initial state */
-    readonly initial: () => any;
-    /** Given current state and input, produce a decision and next state */
-    readonly step: (state: any, input: I) => [ScheduleDecision, any, O];
-};
-/** Retry/repeat up to N times with no delay. */
-declare function recurs(n: number): Schedule<unknown, number>;
-/** Fixed delay between each retry/repeat. */
-declare function fixed(delayMs: number): Schedule<unknown, number>;
-/** Exponential backoff: delay doubles each time, capped at maxDelayMs. */
-declare function exponential(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>;
-/** Limit a schedule to N repetitions. */
-declare function take<I, O>(schedule: Schedule<I, O>, n: number): 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]>;
-/**
- * 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>): Async<R, E, A>;
-/**
- * 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>): Async<R, E, A>;
+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 */
@@ -304,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.
  *
@@ -379,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.
  *
@@ -404,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.
  *
@@ -449,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.
  *
@@ -459,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 */
@@ -517,85 +587,32 @@ type WorkerPoolStats = {
  */
 declare function makeWorkerPool(config?: WorkerPoolConfig): WorkerPool;
 
-type MetricType = "counter" | "gauge" | "histogram";
-type MetricValue = {
-    readonly name: string;
-    readonly type: MetricType;
-    readonly value: number;
-    readonly labels: Record<string, string>;
-    readonly timestamp: number;
-};
-type HistogramBuckets = {
-    readonly boundaries: readonly number[];
-    counts: number[];
-    sum: number;
-    count: number;
-    min: number;
-    max: number;
-};
-type MetricsRegistry = {
-    /** Create or get a counter. */
-    readonly counter: (name: string, labels?: Record<string, string>) => Counter;
-    /** Create or get a gauge. */
-    readonly gauge: (name: string, labels?: Record<string, string>) => Gauge;
-    /** Create or get a histogram. */
-    readonly histogram: (name: string, boundaries?: number[], labels?: Record<string, string>) => Histogram;
-    /** Get all current metric values. */
-    readonly snapshot: () => MetricSnapshot;
-    /** Reset all metrics. */
-    readonly reset: () => void;
-};
-type Counter = {
-    readonly increment: (n?: number) => void;
-    readonly value: () => number;
-};
-type Gauge = {
-    readonly set: (value: number) => void;
-    readonly increment: (n?: number) => void;
-    readonly decrement: (n?: number) => void;
-    readonly value: () => number;
-};
-type Histogram = {
-    readonly observe: (value: number) => void;
-    readonly buckets: () => HistogramBuckets;
-    readonly percentile: (p: number) => number;
-};
-type MetricSnapshot = {
-    readonly counters: Array<{
-        name: string;
-        labels: Record<string, string>;
-        value: number;
-    }>;
-    readonly gauges: Array<{
-        name: string;
-        labels: Record<string, string>;
-        value: number;
-    }>;
-    readonly histograms: Array<{
-        name: string;
-        labels: Record<string, string>;
-        buckets: HistogramBuckets;
-    }>;
+type RuntimeRecorderOptions = {
+    readonly maxEvents?: number;
 };
-/**
- * Creates a metrics registry.
- *
- * ```ts
- * const metrics = makeMetrics();
- *
- * const requestCount = metrics.counter("http_requests_total", { method: "GET" });
- * requestCount.increment();
- *
- * const latency = metrics.histogram("http_request_duration_ms");
- * latency.observe(42.5);
- *
- * const activeConns = metrics.gauge("active_connections");
- * activeConns.set(10);
- *
- * console.log(metrics.snapshot());
- * ```
- */
-declare function makeMetrics(): MetricsRegistry;
+type 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:
@@ -670,4 +687,86 @@ declare function tagError<R, E, A, Tag extends string, Fields extends Record<str
  */
 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>;
 
-export { Async, type Counter, Exit, type Gauge, type Histogram, type HistogramBuckets, type Layer, type Managed as ManagedResource, type MetricSnapshot, type MetricType, type MetricValue, type MetricsRegistry, type Ref, type RetryPolicy, type RetryState, Runtime, type Schedule, type ScheduleDecision, type Semaphore, type SemaphoreStats, type ShutdownConfig, type ShutdownStats, type TaggedError, type TestRuntimeOptions, type TimeoutError, type WorkerPool, type WorkerPoolConfig, type WorkerPoolError, type WorkerPoolStats, andThen as andThenSchedule, assertCompletesWithin, assertFails, assertFailsWith, assertSucceeds, bracket, catchTag, catchTags, compose as composeLayer, delayedEffect, derivedRef, elapsed, ensuring, exponential, fixed, flakyEffect, gracefulShutdown, intersect, jittered, layer, layerFail, layerFrom, layerSucceed, makeMetrics, makeRef, makeSemaphore, makeTestRuntime, makeWorkerPool, managed, managedAll, mapError as mapErrorTyped, mapLayer, merge as mergeLayer, neverEffect, orElse, provideLayer, recurs, registerShutdownHooks, repeatWithSchedule, retry, retryN, retryWithBackoff, retryWithSchedule, sleep, tagError, take as takeSchedule, timeout, union, useManaged, whileInput };
+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 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 };