@clayroach/effect 3.19.14-source-capture.7 → 3.19.14-source-capture.8

package/src/Layer.ts

@@ -1,1251 +0,0 @@
-/**
- * A `Layer<ROut, E, RIn>` describes how to build one or more services in your
- * application. Services can be injected into effects via
- * `Effect.provideService`. Effects can require services via `Effect.service`.
- *
- * Layer can be thought of as recipes for producing bundles of services, given
- * their dependencies (other services).
- *
- * Construction of services can be effectful and utilize resources that must be
- * acquired and safely released when the services are done being utilized.
- *
- * By default layers are shared, meaning that if the same layer is used twice
- * the layer will only be allocated a single time.
- *
- * Because of their excellent composition properties, layers are the idiomatic
- * way in Effect-TS to create services that depend on other services.
- *
- * @since 2.0.0
- */
-import type * as Cause from "./Cause.js"
-import type * as Clock from "./Clock.js"
-import type { ConfigProvider } from "./ConfigProvider.js"
-import * as Context from "./Context.js"
-import type * as Effect from "./Effect.js"
-import type * as Exit from "./Exit.js"
-import type { FiberRef } from "./FiberRef.js"
-import { dual, type LazyArg } from "./Function.js"
-import { clockTag } from "./internal/clock.js"
-import * as core from "./internal/core.js"
-import * as defaultServices from "./internal/defaultServices.js"
-import * as fiberRuntime from "./internal/fiberRuntime.js"
-import * as internal from "./internal/layer.js"
-import * as circularLayer from "./internal/layer/circular.js"
-import * as query from "./internal/query.js"
-import { randomTag } from "./internal/random.js"
-import type { LogLevel } from "./LogLevel.js"
-import type * as Option from "./Option.js"
-import type { Pipeable } from "./Pipeable.js"
-import type * as Random from "./Random.js"
-import type * as Request from "./Request.js"
-import type * as Runtime from "./Runtime.js"
-import type * as Schedule from "./Schedule.js"
-import * as Scheduler from "./Scheduler.js"
-import type * as Scope from "./Scope.js"
-import type * as Stream from "./Stream.js"
-import type * as Tracer from "./Tracer.js"
-import type * as Types from "./Types.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const LayerTypeId: unique symbol = internal.LayerTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type LayerTypeId = typeof LayerTypeId
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Layer<in ROut, out E = never, out RIn = never> extends Layer.Variance<ROut, E, RIn>, Pipeable {}
-
-/**
- * @since 2.0.0
- */
-export declare namespace Layer {
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<in ROut, out E, out RIn> {
-    readonly [LayerTypeId]: {
-      readonly _ROut: Types.Contravariant<ROut>
-      readonly _E: Types.Covariant<E>
-      readonly _RIn: Types.Covariant<RIn>
-    }
-  }
-  /**
-   * @since 3.9.0
-   * @category type-level
-   */
-  export interface Any {
-    readonly [LayerTypeId]: {
-      readonly _ROut: Types.Contravariant<never>
-      readonly _E: Types.Covariant<any>
-      readonly _RIn: Types.Covariant<any>
-    }
-  }
-  /**
-   * @since 2.0.0
-   * @category type-level
-   */
-  export type Context<T extends Any> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _RIn
-    : never
-  /**
-   * @since 2.0.0
-   * @category type-level
-   */
-  export type Error<T extends Any> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _E
-    : never
-  /**
-   * @since 2.0.0
-   * @category type-level
-   */
-  export type Success<T extends Any> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _ROut
-    : never
-}
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const MemoMapTypeId: unique symbol = internal.MemoMapTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type MemoMapTypeId = typeof MemoMapTypeId
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface MemoMap {
-  readonly [MemoMapTypeId]: MemoMapTypeId
-
-  /** @internal */
-  readonly getOrElseMemoize: <RIn, E, ROut>(
-    layer: Layer<ROut, E, RIn>,
-    scope: Scope.Scope
-  ) => Effect.Effect<Context.Context<ROut>, E, RIn>
-}
-
-/**
- * @since 3.13.0
- * @category models
- */
-export interface CurrentMemoMap {
-  readonly _: unique symbol
-}
-
-/**
- * @since 3.13.0
- * @category models
- */
-export const CurrentMemoMap: Context.Reference<CurrentMemoMap, MemoMap> = internal.CurrentMemoMap
-
-/**
- * Returns `true` if the specified value is a `Layer`, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-export const isLayer: (u: unknown) => u is Layer<unknown, unknown, unknown> = internal.isLayer
-
-/**
- * Returns `true` if the specified `Layer` is a fresh version that will not be
- * shared, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-export const isFresh: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => boolean = internal.isFresh
-
-/**
- * @since 3.3.0
- * @category tracing
- */
-export const annotateLogs: {
-  (key: string, value: unknown): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
-  (values: Record<string, unknown>): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
-  <A, E, R>(self: Layer<A, E, R>, key: string, value: unknown): Layer<A, E, R>
-  <A, E, R>(self: Layer<A, E, R>, values: Record<string, unknown>): Layer<A, E, R>
-} = internal.annotateLogs
-
-/**
- * @since 3.3.0
- * @category tracing
- */
-export const annotateSpans: {
-  (key: string, value: unknown): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
-  (values: Record<string, unknown>): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
-  <A, E, R>(self: Layer<A, E, R>, key: string, value: unknown): Layer<A, E, R>
-  <A, E, R>(self: Layer<A, E, R>, values: Record<string, unknown>): Layer<A, E, R>
-} = internal.annotateSpans
-
-/**
- * Builds a layer into a scoped value.
- *
- * @since 2.0.0
- * @category destructors
- */
-export const build: <RIn, E, ROut>(
-  self: Layer<ROut, E, RIn>
-) => Effect.Effect<Context.Context<ROut>, E, Scope.Scope | RIn> = internal.build
-
-/**
- * Builds a layer into an `Effect` value. Any resources associated with this
- * layer will be released when the specified scope is closed unless their scope
- * has been extended. This allows building layers where the lifetime of some of
- * the services output by the layer exceed the lifetime of the effect the
- * layer is provided to.
- *
- * @since 2.0.0
- * @category destructors
- */
-export const buildWithScope: {
-  (scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>
-  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, scope: Scope.Scope): Effect.Effect<Context.Context<ROut>, E, RIn>
-} = internal.buildWithScope
-
-/**
- * Recovers from all errors.
- *
- * @since 2.0.0
- * @category error handling
- */
-export const catchAll: {
-  <E, RIn2, E2, ROut2>(
-    onError: (error: E) => Layer<ROut2, E2, RIn2>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer<ROut, E, RIn>,
-    onError: (error: E) => Layer<ROut2, E2, RIn2>
-  ): Layer<ROut & ROut2, E2, RIn | RIn2>
-} = internal.catchAll
-
-/**
- * Recovers from all errors.
- *
- * @since 2.0.0
- * @category error handling
- */
-export const catchAllCause: {
-  <E, RIn2, E2, ROut2>(
-    onError: (cause: Cause.Cause<E>) => Layer<ROut2, E2, RIn2>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>
-  <RIn, E, ROut, RIn2, E2, ROut22>(
-    self: Layer<ROut, E, RIn>,
-    onError: (cause: Cause.Cause<E>) => Layer<ROut22, E2, RIn2>
-  ): Layer<ROut & ROut22, E2, RIn | RIn2>
-} = internal.catchAllCause
-
-/**
- * Constructs a `Layer` that passes along the specified context as an
- * output.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const context: <R>() => Layer<R, never, R> = internal.context
-
-/**
- * Constructs a layer that dies with the specified defect.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const die: (defect: unknown) => Layer<unknown> = internal.die
-
-/**
- * Constructs a layer that dies with the specified defect.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const dieSync: (evaluate: LazyArg<unknown>) => Layer<unknown> = internal.dieSync
-
-/**
- * Replaces the layer's output with `never` and includes the layer only for its
- * side-effects.
- *
- * @since 2.0.0
- * @category mapping
- */
-export const discard: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Layer<never, E, RIn> = internal.discard
-
-/**
- * Constructs a layer from the specified effect.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const effect: {
-  <I, S>(tag: Context.Tag<I, S>): <E, R>(effect: Effect.Effect<Types.NoInfer<S>, E, R>) => Layer<I, E, R>
-  <I, S, E, R>(tag: Context.Tag<I, S>, effect: Effect.Effect<Types.NoInfer<S>, E, R>): Layer<I, E, R>
-} = internal.fromEffect
-
-/**
- * Constructs a layer from the specified effect, discarding its output.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const effectDiscard: <X, E, R>(effect: Effect.Effect<X, E, R>) => Layer<never, E, R> = internal.fromEffectDiscard
-
-/**
- * Constructs a layer from the specified effect, which must return one or more
- * services.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const effectContext: <A, E, R>(effect: Effect.Effect<Context.Context<A>, E, R>) => Layer<A, E, R> =
-  internal.fromEffectContext
-
-/**
- * A Layer that constructs an empty Context.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const empty: Layer<never> = internal.empty
-
-/**
- * Extends the scope of this layer, returning a new layer that when provided
- * to an effect will not immediately release its associated resources when
- * that effect completes execution but instead when the scope the resulting
- * effect depends on is closed.
- *
- * @since 2.0.0
- * @category utils
- */
-export const extendScope: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, Scope.Scope | RIn> =
-  internal.extendScope
-
-/**
- * Constructs a layer that fails with the specified error.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const fail: <E>(error: E) => Layer<unknown, E> = internal.fail
-
-/**
- * Constructs a layer that fails with the specified error.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const failSync: <E>(evaluate: LazyArg<E>) => Layer<unknown, E> = internal.failSync
-
-/**
- * Constructs a layer that fails with the specified cause.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const failCause: <E>(cause: Cause.Cause<E>) => Layer<unknown, E> = internal.failCause
-
-/**
- * Constructs a layer that fails with the specified cause.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Layer<unknown, E> = internal.failCauseSync
-
-/**
- * Constructs a layer dynamically based on the output of this layer.
- *
- * @since 2.0.0
- * @category sequencing
- */
-export const flatMap: {
-  <A, A2, E2, R2>(
-    f: (context: Context.Context<A>) => Layer<A2, E2, R2>
-  ): <E, R>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(
-    self: Layer<A, E, R>,
-    f: (context: Context.Context<A>) => Layer<A2, E2, R2>
-  ): Layer<A2, E | E2, R | R2>
-} = internal.flatMap
-
-/**
- * Flattens layers nested in the context of an effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-export const flatten: {
-  <I, A, E2, R2>(tag: Context.Tag<I, Layer<A, E2, R2>>): <E, R>(self: Layer<I, E, R>) => Layer<A, E2 | E, R2 | R>
-  <I, E, R, A, E2, R2>(self: Layer<I, E, R>, tag: Context.Tag<I, Layer<A, E2, R2>>): Layer<A, E | E2, R | R2>
-} = internal.flatten
-
-/**
- * Creates a fresh version of this layer that will not be shared.
- *
- * @since 2.0.0
- * @category utils
- */
-export const fresh: <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R> = internal.fresh
-
-/**
- * @since 3.17.0
- * @category Testing
- */
-export type PartialEffectful<A extends object> = Types.Simplify<
-  & {
-    [
-      K in keyof A as A[K] extends
-        | Effect.Effect<any, any, any>
-        | Stream.Stream<any, any, any>
-        | ((...args: any) => Effect.Effect<any, any, any> | Stream.Stream<any, any, any>) ? K
-        : never
-    ]?: A[K]
-  }
-  & {
-    [
-      K in keyof A as A[K] extends
-        | Effect.Effect<any, any, any>
-        | Stream.Stream<any, any, any>
-        | ((...args: any) => Effect.Effect<any, any, any> | Stream.Stream<any, any, any>) ? never
-        : K
-    ]: A[K]
-  }
->
-
-/**
- * Creates a mock layer for testing purposes. You can provide a partial
- * implementation of the service, and any methods not provided will
- * throw an `UnimplementedError` defect when called.
- *
- * **Example**
- *
- * ```ts
- * import { Context, Effect, Layer } from "effect"
- *
- * class MyService extends Context.Tag("MyService")<
- *   MyService,
- *   {
- *     one: Effect.Effect<number>
- *     two(): Effect.Effect<number>
- *   }
- * >() {}
- *
- * const MyServiceTest = Layer.mock(MyService, {
- *   two: () => Effect.succeed(2)
- * })
- * ```
- *
- * @since 3.17.0
- * @category Testing
- */
-export const mock: {
-  <I, S extends object>(tag: Context.Tag<I, S>): (service: PartialEffectful<S>) => Layer<I>
-  <I, S extends object>(tag: Context.Tag<I, S>, service: PartialEffectful<S>): Layer<I>
-} = internal.mock
-
-const fromFunction: <I1, S1, I2, S2>(
-  tagA: Context.Tag<I1, S1>,
-  tagB: Context.Tag<I2, S2>,
-  f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>
-) => Layer<I2, never, I1> = internal.fromFunction
-
-export {
-  /**
-   * Constructs a layer from the context using the specified function.
-   *
-   * @since 2.0.0
-   * @category constructors
-   */
-  fromFunction as function
-}
-
-/**
- * Builds this layer and uses it until it is interrupted. This is useful when
- * your entire application is a layer, such as an HTTP server.
- *
- * @since 2.0.0
- * @category conversions
- */
-export const launch: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<never, E, RIn> = internal.launch
-
-/**
- * Returns a new layer whose output is mapped by the specified function.
- *
- * @since 2.0.0
- * @category mapping
- */
-export const map: {
-  <A, B>(f: (context: Context.Context<A>) => Context.Context<B>): <E, R>(self: Layer<A, E, R>) => Layer<B, E, R>
-  <A, E, R, B>(self: Layer<A, E, R>, f: (context: Context.Context<A>) => Context.Context<B>): Layer<B, E, R>
-} = internal.map
-
-/**
- * Returns a layer with its error channel mapped using the specified function.
- *
- * @since 2.0.0
- * @category mapping
- */
-export const mapError: {
-  <E, E2>(f: (error: E) => E2): <A, R>(self: Layer<A, E, R>) => Layer<A, E2, R>
-  <A, E, R, E2>(self: Layer<A, E, R>, f: (error: E) => E2): Layer<A, E2, R>
-} = internal.mapError
-
-/**
- * Feeds the error or output services of this layer into the input of either
- * the specified `failure` or `success` layers, resulting in a new layer with
- * the inputs of this layer, and the error or outputs of the specified layer.
- *
- * @since 2.0.0
- * @category folding
- */
-export const match: {
-  <E, A2, E2, R2, A, A3, E3, R3>(
-    options: {
-      readonly onFailure: (error: E) => Layer<A2, E2, R2>
-      readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
-    }
-  ): <R>(self: Layer<A, E, R>) => Layer<A2 & A3, E2 | E3, R2 | R3 | R>
-  <A, E, R, A2, E2, R2, A3, E3, R3>(
-    self: Layer<A, E, R>,
-    options: {
-      readonly onFailure: (error: E) => Layer<A2, E2, R2>
-      readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
-    }
-  ): Layer<A2 & A3, E2 | E3, R | R2 | R3>
-} = internal.match
-
-/**
- * Feeds the error or output services of this layer into the input of either
- * the specified `failure` or `success` layers, resulting in a new layer with
- * the inputs of this layer, and the error or outputs of the specified layer.
- *
- * @since 2.0.0
- * @category folding
- */
-export const matchCause: {
-  <E, A2, E2, R2, A, A3, E3, R3>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => Layer<A2, E2, R2>
-      readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
-    }
-  ): <R>(self: Layer<A, E, R>) => Layer<A2 & A3, E2 | E3, R2 | R3 | R>
-  <A, E, R, A2, E2, R2, A3, E3, R3>(
-    self: Layer<A, E, R>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => Layer<A2, E2, R2>
-      readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
-    }
-  ): Layer<A2 & A3, E2 | E3, R | R2 | R3>
-} = internal.matchCause
-
-/**
- * Returns a scoped effect that, if evaluated, will return the lazily computed
- * result of this layer.
- *
- * @since 2.0.0
- * @category utils
- */
-export const memoize: <RIn, E, ROut>(
-  self: Layer<ROut, E, RIn>
-) => Effect.Effect<Layer<ROut, E, RIn>, never, Scope.Scope> = internal.memoize
-
-/**
- * Merges this layer with the specified layer concurrently, producing a new layer with combined input and output types.
- *
- * @since 2.0.0
- * @category zipping
- */
-export const merge: {
-  <RIn2, E2, ROut2>(
-    that: Layer<ROut2, E2, RIn2>
-  ): <RIn, E1, ROut>(self: Layer<ROut, E1, RIn>) => Layer<ROut2 | ROut, E2 | E1, RIn2 | RIn>
-  <RIn, E1, ROut, RIn2, E2, ROut2>(
-    self: Layer<ROut, E1, RIn>,
-    that: Layer<ROut2, E2, RIn2>
-  ): Layer<ROut | ROut2, E1 | E2, RIn | RIn2>
-} = internal.merge
-
-/**
- * Combines all the provided layers concurrently, creating a new layer with merged input, error, and output types.
- *
- * @since 2.0.0
- * @category zipping
- */
-export const mergeAll: <Layers extends readonly [Layer<never, any, any>, ...Array<Layer<never, any, any>>]>(
-  ...layers: Layers
-) => Layer<
-  { [k in keyof Layers]: Layer.Success<Layers[k]> }[number],
-  { [k in keyof Layers]: Layer.Error<Layers[k]> }[number],
-  { [k in keyof Layers]: Layer.Context<Layers[k]> }[number]
-> = internal.mergeAll
-
-/**
- * Translates effect failure into death of the fiber, making all failures
- * unchecked and not a part of the type of the layer.
- *
- * @since 2.0.0
- * @category error handling
- */
-export const orDie: <A, E, R>(self: Layer<A, E, R>) => Layer<A, never, R> = internal.orDie
-
-/**
- * Executes this layer and returns its output, if it succeeds, but otherwise
- * executes the specified layer.
- *
- * @since 2.0.0
- * @category error handling
- */
-export const orElse: {
-  <A2, E2, R2>(that: LazyArg<Layer<A2, E2, R2>>): <A, E, R>(self: Layer<A, E, R>) => Layer<A & A2, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(self: Layer<A, E, R>, that: LazyArg<Layer<A2, E2, R2>>): Layer<A & A2, E | E2, R | R2>
-} = internal.orElse
-
-/**
- * Returns a new layer that produces the outputs of this layer but also
- * passes through the inputs.
- *
- * @since 2.0.0
- * @category utils
- */
-export const passthrough: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Layer<RIn | ROut, E, RIn> = internal.passthrough
-
-/**
- * Projects out part of one of the services output by this layer using the
- * specified function.
- *
- * @since 2.0.0
- * @category utils
- */
-export const project: {
-  <I1, S1, I2, S2>(
-    tagA: Context.Tag<I1, S1>,
-    tagB: Context.Tag<I2, S2>,
-    f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>
-  ): <RIn, E>(self: Layer<I1, E, RIn>) => Layer<I2, E, RIn>
-  <RIn, E, I1, S1, I2, S2>(
-    self: Layer<I1, E, RIn>,
-    tagA: Context.Tag<I1, S1>,
-    tagB: Context.Tag<I2, S2>,
-    f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>
-  ): Layer<I2, E, RIn>
-} = internal.project
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const locallyEffect: {
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>
-  ): (self: Layer<ROut, E, RIn>) => Layer<ROut2, E2, RIn2>
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer<ROut, E, RIn>,
-    f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>
-  ): Layer<ROut2, E2, RIn2>
-} = internal.locallyEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const locally: {
-  <X>(
-    ref: FiberRef<X>,
-    value: X
-  ): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
-  <A, E, R, X>(
-    self: Layer<A, E, R>,
-    ref: FiberRef<X>,
-    value: X
-  ): Layer<A, E, R>
-} = internal.fiberRefLocally
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const locallyWith: {
-  <X>(ref: FiberRef<X>, value: (_: X) => X): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
-  <A, E, R, X>(self: Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X): Layer<A, E, R>
-} = internal.fiberRefLocallyWith
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const locallyScoped: <A>(self: FiberRef<A>, value: A) => Layer<never> = internal.fiberRefLocallyScoped
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_: A) => A) => Layer<never> =
-  internal.fiberRefLocallyScopedWith
-
-/**
- * Retries constructing this layer according to the specified schedule.
- *
- * @since 2.0.0
- * @category retrying
- */
-export const retry: {
-  <X, E, RIn2>(
-    schedule: Schedule.Schedule<X, NoInfer<E>, RIn2>
-  ): <ROut, RIn>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
-  <ROut, E, RIn, X, RIn2>(
-    self: Layer<ROut, E, RIn>,
-    schedule: Schedule.Schedule<X, E, RIn2>
-  ): Layer<ROut, E, RIn | RIn2>
-} = internal.retry
-
-/**
- * A layer that constructs a scope and closes it when the workflow the layer
- * is provided to completes execution, whether by success, failure, or
- * interruption. This can be used to close a scope when providing a layer to a
- * workflow.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const scope: Layer<Scope.Scope> = internal.scope
-
-/**
- * Constructs a layer from the specified scoped effect.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const scoped: {
-  <I, S>(
-    tag: Context.Tag<I, S>
-  ): <E, R>(effect: Effect.Effect<Types.NoInfer<S>, E, R>) => Layer<I, E, Exclude<R, Scope.Scope>>
-  <I, S, E, R>(
-    tag: Context.Tag<I, S>,
-    effect: Effect.Effect<Types.NoInfer<S>, E, R>
-  ): Layer<I, E, Exclude<R, Scope.Scope>>
-} = internal.scoped
-
-/**
- * Constructs a layer from the specified scoped effect.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const scopedDiscard: <X, E, R>(effect: Effect.Effect<X, E, R>) => Layer<never, E, Exclude<R, Scope.Scope>> =
-  internal.scopedDiscard
-
-/**
- * Constructs a layer from the specified scoped effect, which must return one
- * or more services.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const scopedContext: <A, E, R>(
-  effect: Effect.Effect<Context.Context<A>, E, R>
-) => Layer<A, E, Exclude<R, Scope.Scope>> = internal.scopedContext
-
-/**
- * Constructs a layer that accesses and returns the specified service from the
- * context.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const service: <I, S>(tag: Context.Tag<I, S>) => Layer<I, never, I> = internal.service
-
-/**
- * Constructs a layer from the specified value.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const succeed: {
-  <I, S>(tag: Context.Tag<I, S>): (resource: Types.NoInfer<S>) => Layer<I>
-  <I, S>(tag: Context.Tag<I, S>, resource: Types.NoInfer<S>): Layer<I>
-} = internal.succeed
-
-/**
- * Constructs a layer from the specified value, which must return one or more
- * services.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const succeedContext: <A>(context: Context.Context<A>) => Layer<A> = internal.succeedContext
-
-/**
- * Lazily constructs a layer. This is useful to avoid infinite recursion when
- * creating layers that refer to themselves.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const suspend: <RIn, E, ROut>(evaluate: LazyArg<Layer<ROut, E, RIn>>) => Layer<ROut, E, RIn> = internal.suspend
-
-/**
- * Lazily constructs a layer from the specified value.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const sync: {
-  <I, S>(tag: Context.Tag<I, S>): (evaluate: LazyArg<Types.NoInfer<S>>) => Layer<I>
-  <I, S>(tag: Context.Tag<I, S>, evaluate: LazyArg<Types.NoInfer<S>>): Layer<I>
-} = internal.sync
-
-/**
- * Lazily constructs a layer from the specified value, which must return one or more
- * services.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const syncContext: <A>(evaluate: LazyArg<Context.Context<A>>) => Layer<A> = internal.syncContext
-
-/**
- * Performs the specified effect if this layer succeeds.
- *
- * @since 2.0.0
- * @category sequencing
- */
-export const tap: {
-  <ROut, XR extends ROut, RIn2, E2, X>(
-    f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>
-  ): <RIn, E>(self: Layer<ROut, E, RIn>) => Layer<ROut, E2 | E, RIn2 | RIn>
-  <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(
-    self: Layer<ROut, E, RIn>,
-    f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>
-  ): Layer<ROut, E | E2, RIn | RIn2>
-} = internal.tap
-
-/**
- * Performs the specified effect if this layer fails.
- *
- * @since 2.0.0
- * @category sequencing
- */
-export const tapError: {
-  <E, XE extends E, RIn2, E2, X>(
-    f: (e: XE) => Effect.Effect<X, E2, RIn2>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>
-  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
-    self: Layer<ROut, E, RIn>,
-    f: (e: XE) => Effect.Effect<X, E2, RIn2>
-  ): Layer<ROut, E | E2, RIn | RIn2>
-} = internal.tapError
-
-/**
- * Performs the specified effect if this layer fails.
- *
- * @since 2.0.0
- * @category sequencing
- */
-export const tapErrorCause: {
-  <E, XE extends E, RIn2, E2, X>(
-    f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>
-  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
-    self: Layer<ROut, E, RIn>,
-    f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>
-  ): Layer<ROut, E | E2, RIn | RIn2>
-} = internal.tapErrorCause
-
-/**
- * Converts a layer that requires no services into a scoped runtime, which can
- * be used to execute effects.
- *
- * @since 2.0.0
- * @category conversions
- */
-export const toRuntime: <RIn, E, ROut>(
-  self: Layer<ROut, E, RIn>
-) => Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn> = internal.toRuntime
-
-/**
- * Converts a layer that requires no services into a scoped runtime, which can
- * be used to execute effects.
- *
- * @since 2.0.0
- * @category conversions
- */
-export const toRuntimeWithMemoMap: {
-  (
-    memoMap: MemoMap
-  ): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>
-  <RIn, E, ROut>(
-    self: Layer<ROut, E, RIn>,
-    memoMap: MemoMap
-  ): Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>
-} = internal.toRuntimeWithMemoMap
-
-/**
- * Feeds the output services of this builder into the input of the specified
- * builder, resulting in a new builder with the inputs of this builder as
- * well as any leftover inputs, and the outputs of the specified builder.
- *
- * @since 2.0.0
- * @category utils
- */
-export const provide: {
-  <RIn, E, ROut>(
-    that: Layer<ROut, E, RIn>
-  ): <RIn2, E2, ROut2>(self: Layer<ROut2, E2, RIn2>) => Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
-  <const Layers extends readonly [Layer.Any, ...Array<Layer.Any>]>(
-    that: Layers
-  ): <A, E, R>(
-    self: Layer<A, E, R>
-  ) => Layer<
-    A,
-    E | { [k in keyof Layers]: Layer.Error<Layers[k]> }[number],
-    | { [k in keyof Layers]: Layer.Context<Layers[k]> }[number]
-    | Exclude<R, { [k in keyof Layers]: Layer.Success<Layers[k]> }[number]>
-  >
-  <RIn2, E2, ROut2, RIn, E, ROut>(
-    self: Layer<ROut2, E2, RIn2>,
-    that: Layer<ROut, E, RIn>
-  ): Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
-  <A, E, R, const Layers extends readonly [Layer.Any, ...Array<Layer.Any>]>(
-    self: Layer<A, E, R>,
-    that: Layers
-  ): Layer<
-    A,
-    E | { [k in keyof Layers]: Layer.Error<Layers[k]> }[number],
-    | { [k in keyof Layers]: Layer.Context<Layers[k]> }[number]
-    | Exclude<R, { [k in keyof Layers]: Layer.Success<Layers[k]> }[number]>
-  >
-} = internal.provide
-
-/**
- * Feeds the output services of this layer into the input of the specified
- * layer, resulting in a new layer with the inputs of this layer, and the
- * outputs of both layers.
- *
- * @since 2.0.0
- * @category utils
- */
-export const provideMerge: {
-  <RIn, E, ROut>(
-    self: Layer<ROut, E, RIn>
-  ): <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>) => Layer<ROut | ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
-  <RIn2, E2, ROut2, RIn, E, ROut>(
-    that: Layer<ROut2, E2, RIn2>,
-    self: Layer<ROut, E, RIn>
-  ): Layer<ROut2 | ROut, E2 | E, RIn | Exclude<RIn2, ROut>>
-} = internal.provideMerge
-
-/**
- * Combines this layer with the specified layer concurrently, creating a new layer with merged input types and
- * combined output types using the provided function.
- *
- * @since 2.0.0
- * @category zipping
- */
-export const zipWith: {
-  <B, E2, R2, A, C>(
-    that: Layer<B, E2, R2>,
-    f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
-  ): <E, R>(self: Layer<A, E, R>) => Layer<C, E2 | E, R2 | R>
-  <A, E, R, B, E2, R2, C>(
-    self: Layer<A, E, R>,
-    that: Layer<B, E2, R2>,
-    f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
-  ): Layer<C, E | E2, R | R2>
-} = internal.zipWith
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const unwrapEffect: <A, E1, R1, E, R>(self: Effect.Effect<Layer<A, E1, R1>, E, R>) => Layer<A, E | E1, R | R1> =
-  internal.unwrapEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const unwrapScoped: <A, E1, R1, E, R>(
-  self: Effect.Effect<Layer<A, E1, R1>, E, R>
-) => Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>> = internal.unwrapScoped
-
-/**
- * @since 2.0.0
- * @category clock
- */
-export const setClock: <A extends Clock.Clock>(clock: A) => Layer<never> = <A extends Clock.Clock>(
-  clock: A
-): Layer<never> =>
-  scopedDiscard(
-    fiberRuntime.fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(clockTag, clock))
-  )
-
-/**
- * Sets the current `ConfigProvider`.
- *
- * @since 2.0.0
- * @category config
- */
-export const setConfigProvider: (configProvider: ConfigProvider) => Layer<never> = circularLayer.setConfigProvider
-
-/**
- * Adds the provided span to the span stack.
- *
- * @since 2.0.0
- * @category tracing
- */
-export const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSpan> = circularLayer.parentSpan
-
-/**
- * @since 3.15.0
- * @category Random
- */
-export const setRandom = <A extends Random.Random>(random: A): Layer<never> =>
-  scopedDiscard(
-    fiberRuntime.fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(randomTag, random))
-  )
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-export const setRequestBatching: (requestBatching: boolean) => Layer<never> = (
-  requestBatching: boolean
-) =>
-  scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(core.currentRequestBatching, requestBatching)
-  )
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-export const setRequestCaching: (requestCaching: boolean) => Layer<never> = (
-  requestCaching: boolean
-) =>
-  scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(query.currentCacheEnabled, requestCaching)
-  )
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-export const setRequestCache: {
-  <E, R>(
-    cache: Effect.Effect<Request.Cache, E, R>
-  ): Layer<never, E, Exclude<R, Scope.Scope>>
-  (
-    cache: Request.Cache
-  ): Layer<never>
-} = (<E, R>(cache: Request.Cache | Effect.Effect<Request.Cache, E, R>) =>
-  scopedDiscard(
-    core.isEffect(cache) ?
-      core.flatMap(cache, (x) => fiberRuntime.fiberRefLocallyScoped(query.currentCache as any, x)) :
-      fiberRuntime.fiberRefLocallyScoped(query.currentCache as any, cache)
-  )) as any
-
-/**
- * @since 2.0.0
- * @category scheduler
- */
-export const setScheduler: (scheduler: Scheduler.Scheduler) => Layer<never> = (
-  scheduler: Scheduler.Scheduler
-): Layer<never> =>
-  scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(Scheduler.currentScheduler, scheduler)
-  )
-
-/**
- * Create and add a span to the current span stack.
- *
- * The span is ended when the Layer is released.
- *
- * @since 2.0.0
- * @category tracing
- */
-export const span: (
-  name: string,
-  options?: Tracer.SpanOptions & {
-    readonly onEnd?:
-      | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
-      | undefined
-  }
-) => Layer<Tracer.ParentSpan> = circularLayer.span
-
-/**
- * Create a Layer that sets the current Tracer
- *
- * @since 2.0.0
- * @category tracing
- */
-export const setTracer: (tracer: Tracer.Tracer) => Layer<never> = circularLayer.setTracer
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-export const setTracerEnabled: (enabled: boolean) => Layer<never> = (enabled: boolean) =>
-  scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(core.currentTracerEnabled, enabled)
-  )
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-export const setTracerTiming: (enabled: boolean) => Layer<never> = (enabled: boolean) =>
-  scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(core.currentTracerTimingEnabled, enabled)
-  )
-
-/**
- * A layer that enables source location capture for forked fibers.
- *
- * When enabled, `Effect.fork` and similar operations will capture the call
- * site (file, line, column) and store it in a FiberRef that can be read by
- * Supervisors. This enables automatic tracing with meaningful span names
- * like `"sendEmail (user-handlers.ts:42)"` instead of `"anonymous"`.
- *
- * @example
- * ```ts
- * import { Effect, Layer } from "effect"
- *
- * // Enable source capture for entire program
- * Effect.runPromise(
- *   program.pipe(Effect.provide(Layer.enableSourceCapture))
- * )
- * ```
- *
- * @since 3.15.0
- * @category tracing
- */
-export const enableSourceCapture: Layer<never> = internal.enableSourceCapture
-
-/**
- * @since 2.0.0
- * @category logging
- */
-export const setUnhandledErrorLogLevel: (level: Option.Option<LogLevel>) => Layer<never> = (
-  level: Option.Option<LogLevel>
-): Layer<never> =>
-  scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(core.currentUnhandledErrorLogLevel, level)
-  )
-
-/**
- * @since 3.17.0
- * @category logging
- */
-export const setVersionMismatchErrorLogLevel: (level: Option.Option<LogLevel>) => Layer<never> = (
-  level: Option.Option<LogLevel>
-): Layer<never> =>
-  scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(core.currentVersionMismatchErrorLogLevel, level)
-  )
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-export const withSpan: {
-  (
-    name: string,
-    options?: Tracer.SpanOptions & {
-      readonly onEnd?:
-        | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
-        | undefined
-    }
-  ): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
-  <A, E, R>(
-    self: Layer<A, E, R>,
-    name: string,
-    options?: Tracer.SpanOptions & {
-      readonly onEnd?:
-        | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
-        | undefined
-    }
-  ): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
-} = internal.withSpan
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-export const withParentSpan: {
-  (span: Tracer.AnySpan): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
-  <A, E, R>(self: Layer<A, E, R>, span: Tracer.AnySpan): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
-} = internal.withParentSpan
-
-// -----------------------------------------------------------------------------
-// memo map
-// -----------------------------------------------------------------------------
-
-/**
- * Constructs a `MemoMap` that can be used to build additional layers.
- *
- * @since 2.0.0
- * @category memo map
- */
-export const makeMemoMap: Effect.Effect<MemoMap> = internal.makeMemoMap
-
-/**
- * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
- * the layer construction.
- *
- * @since 2.0.0
- * @category memo map
- */
-export const buildWithMemoMap: {
-  (
-    memoMap: MemoMap,
-    scope: Scope.Scope
-  ): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>
-  <RIn, E, ROut>(
-    self: Layer<ROut, E, RIn>,
-    memoMap: MemoMap,
-    scope: Scope.Scope
-  ): Effect.Effect<Context.Context<ROut>, E, RIn>
-} = internal.buildWithMemoMap
-
-/**
- * Updates a service in the context with a new implementation.
- *
- * **Details**
- *
- * This function modifies the existing implementation of a service in the
- * context. It retrieves the current service, applies the provided
- * transformation function `f`, and replaces the old service with the
- * transformed one.
- *
- * **When to Use**
- *
- * This is useful for adapting or extending a service's behavior during the
- * creation of a layer.
- *
- * @since 3.13.0
- * @category utils
- */
-export const updateService = dual<
-  <I, A>(
-    tag: Context.Tag<I, A>,
-    f: (a: A) => A
-  ) => <A1, E1, R1>(layer: Layer<A1, E1, R1>) => Layer<A1, E1, I | R1>,
-  <A1, E1, R1, I, A>(
-    layer: Layer<A1, E1, R1>,
-    tag: Context.Tag<I, A>,
-    f: (a: A) => A
-  ) => Layer<A1, E1, I | R1>
->(3, (layer, tag, f) =>
-  provide(
-    layer,
-    map(context(), (c) => Context.add(c, tag, f(Context.unsafeGet(c, tag))))
-  ))