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

package/src/internal/layer.ts

@@ -1,1487 +0,0 @@
-import type * as Arr from "../Array.js"
-import * as Cause from "../Cause.js"
-import * as Clock from "../Clock.js"
-import * as Context from "../Context.js"
-import * as Duration from "../Duration.js"
-import type * as Effect from "../Effect.js"
-import type * as Exit from "../Exit.js"
-import type { FiberRef } from "../FiberRef.js"
-import * as FiberRefsPatch from "../FiberRefsPatch.js"
-import type { LazyArg } from "../Function.js"
-import { constTrue, dual, pipe } from "../Function.js"
-import * as HashMap from "../HashMap.js"
-import type * as Layer from "../Layer.js"
-import type * as ManagedRuntime from "../ManagedRuntime.js"
-import { pipeArguments } from "../Pipeable.js"
-import { hasProperty } from "../Predicate.js"
-import type * as Runtime from "../Runtime.js"
-import type * as Schedule from "../Schedule.js"
-import * as ScheduleDecision from "../ScheduleDecision.js"
-import * as Intervals from "../ScheduleIntervals.js"
-import * as Scope from "../Scope.js"
-import type * as Synchronized from "../SynchronizedRef.js"
-import type * as Tracer from "../Tracer.js"
-import type * as Types from "../Types.js"
-import * as effect from "./core-effect.js"
-import * as core from "./core.js"
-import * as circular from "./effect/circular.js"
-import * as ExecutionStrategy from "./executionStrategy.js"
-import * as fiberRuntime from "./fiberRuntime.js"
-import * as circularManagedRuntime from "./managedRuntime/circular.js"
-import * as EffectOpCodes from "./opCodes/effect.js"
-import * as OpCodes from "./opCodes/layer.js"
-import * as ref from "./ref.js"
-import * as runtime from "./runtime.js"
-import * as runtimeFlags from "./runtimeFlags.js"
-import * as synchronized from "./synchronizedRef.js"
-import * as tracer from "./tracer.js"
-
-/** @internal */
-const LayerSymbolKey = "effect/Layer"
-
-/** @internal */
-export const LayerTypeId: Layer.LayerTypeId = Symbol.for(
-  LayerSymbolKey
-) as Layer.LayerTypeId
-
-const layerVariance = {
-  /* c8 ignore next */
-  _RIn: (_: never) => _,
-  /* c8 ignore next */
-  _E: (_: never) => _,
-  /* c8 ignore next */
-  _ROut: (_: unknown) => _
-}
-
-/** @internal */
-export const proto = {
-  [LayerTypeId]: layerVariance,
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-const MemoMapTypeIdKey = "effect/Layer/MemoMap"
-
-/** @internal */
-export const MemoMapTypeId: Layer.MemoMapTypeId = Symbol.for(
-  MemoMapTypeIdKey
-) as Layer.MemoMapTypeId
-
-/** @internal */
-export const CurrentMemoMap = Context.Reference<Layer.CurrentMemoMap>()("effect/Layer/CurrentMemoMap", {
-  defaultValue: () => unsafeMakeMemoMap()
-})
-
-/** @internal */
-export type Primitive =
-  | ExtendScope
-  | Fold
-  | Fresh
-  | FromEffect
-  | Scoped
-  | Suspend
-  | Locally
-  | ProvideTo
-  | ZipWith
-  | ZipWithPar
-  | MergeAll
-
-/** @internal */
-export type Op<Tag extends string, Body = {}> = Layer.Layer<unknown, unknown, unknown> & Body & {
-  readonly _op_layer: Tag
-}
-
-/** @internal */
-export interface ExtendScope extends
-  Op<OpCodes.OP_EXTEND_SCOPE, {
-    readonly layer: Layer.Layer<unknown>
-  }>
-{}
-
-/** @internal */
-export interface Fold extends
-  Op<OpCodes.OP_FOLD, {
-    readonly layer: Layer.Layer<unknown>
-    failureK(cause: Cause.Cause<unknown>): Layer.Layer<unknown>
-    successK(context: Context.Context<unknown>): Layer.Layer<unknown>
-  }>
-{}
-
-/** @internal */
-export interface Fresh extends
-  Op<OpCodes.OP_FRESH, {
-    readonly layer: Layer.Layer<unknown>
-  }>
-{}
-
-/** @internal */
-export interface FromEffect extends
-  Op<OpCodes.OP_FROM_EFFECT, {
-    readonly effect: Effect.Effect<unknown, unknown, Context.Context<unknown>>
-  }>
-{}
-
-/** @internal */
-export interface Scoped extends
-  Op<OpCodes.OP_SCOPED, {
-    readonly effect: Effect.Effect<unknown, unknown, Context.Context<unknown>>
-  }>
-{}
-
-/** @internal */
-export interface Suspend extends
-  Op<OpCodes.OP_SUSPEND, {
-    evaluate(): Layer.Layer<unknown>
-  }>
-{}
-
-/** @internal */
-export interface Locally extends
-  Op<"Locally", {
-    readonly self: Layer.Layer<unknown>
-    f(_: Effect.Effect<any, any, any>): Effect.Effect<any, any, any>
-  }>
-{}
-
-/** @internal */
-export interface ProvideTo extends
-  Op<OpCodes.OP_PROVIDE, {
-    readonly first: Layer.Layer<unknown>
-    readonly second: Layer.Layer<unknown>
-  }>
-{}
-
-/** @internal */
-export interface ZipWith extends
-  Op<OpCodes.OP_PROVIDE_MERGE, {
-    readonly first: Layer.Layer<unknown>
-    readonly second: Layer.Layer<unknown>
-    zipK(left: Context.Context<unknown>, right: Context.Context<unknown>): Context.Context<unknown>
-  }>
-{}
-
-/** @internal */
-export interface ZipWithPar extends
-  Op<OpCodes.OP_ZIP_WITH, {
-    readonly first: Layer.Layer<unknown>
-    readonly second: Layer.Layer<unknown>
-    zipK(left: Context.Context<unknown>, right: Context.Context<unknown>): Context.Context<unknown>
-  }>
-{}
-
-/** @internal */
-export interface MergeAll extends
-  Op<OpCodes.OP_MERGE_ALL, {
-    readonly layers: Arr.NonEmptyReadonlyArray<Layer.Layer<unknown>>
-  }>
-{}
-
-/** @internal */
-export const isLayer = (u: unknown): u is Layer.Layer<unknown, unknown, unknown> => hasProperty(u, LayerTypeId)
-
-/** @internal */
-export const isFresh = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): boolean => {
-  return (self as Primitive)._op_layer === OpCodes.OP_FRESH
-}
-
-// -----------------------------------------------------------------------------
-// MemoMap
-// -----------------------------------------------------------------------------
-
-/** @internal */
-class MemoMapImpl implements Layer.MemoMap {
-  readonly [MemoMapTypeId]: Layer.MemoMapTypeId
-  constructor(
-    readonly ref: Synchronized.SynchronizedRef<
-      Map<
-        Layer.Layer<any, any, any>,
-        readonly [Effect.Effect<any, any>, Scope.Scope.Finalizer]
-      >
-    >
-  ) {
-    this[MemoMapTypeId] = MemoMapTypeId
-  }
-
-  /**
-   * Checks the memo map to see if a layer exists. If it is, immediately
-   * returns it. Otherwise, obtains the layer, stores it in the memo map,
-   * and adds a finalizer to the `Scope`.
-   */
-  getOrElseMemoize<RIn, E, ROut>(
-    layer: Layer.Layer<ROut, E, RIn>,
-    scope: Scope.Scope
-  ): Effect.Effect<Context.Context<ROut>, E, RIn> {
-    return pipe(
-      synchronized.modifyEffect(this.ref, (map) => {
-        const inMap = map.get(layer)
-        if (inMap !== undefined) {
-          const [acquire, release] = inMap
-          const cached: Effect.Effect<Context.Context<ROut>, E> = pipe(
-            acquire as Effect.Effect<readonly [FiberRefsPatch.FiberRefsPatch, Context.Context<ROut>], E>,
-            core.flatMap(([patch, b]) => pipe(effect.patchFiberRefs(patch), core.as(b))),
-            core.onExit(core.exitMatch({
-              onFailure: () => core.void,
-              onSuccess: () => core.scopeAddFinalizerExit(scope, release)
-            }))
-          )
-          return core.succeed([cached, map] as const)
-        }
-        return pipe(
-          ref.make(0),
-          core.flatMap((observers) =>
-            pipe(
-              core.deferredMake<readonly [FiberRefsPatch.FiberRefsPatch, Context.Context<ROut>], E>(),
-              core.flatMap((deferred) =>
-                pipe(
-                  ref.make<Scope.Scope.Finalizer>(() => core.void),
-                  core.map((finalizerRef) => {
-                    const resource = core.uninterruptibleMask((restore) =>
-                      pipe(
-                        fiberRuntime.scopeMake(),
-                        core.flatMap((innerScope) =>
-                          pipe(
-                            restore(core.flatMap(
-                              makeBuilder(layer, innerScope, true),
-                              (f) => effect.diffFiberRefs(f(this))
-                            )),
-                            core.exit,
-                            core.flatMap((exit) => {
-                              switch (exit._tag) {
-                                case EffectOpCodes.OP_FAILURE: {
-                                  return pipe(
-                                    core.deferredFailCause(deferred, exit.effect_instruction_i0),
-                                    core.zipRight(core.scopeClose(innerScope, exit)),
-                                    core.zipRight(core.failCause(exit.effect_instruction_i0))
-                                  )
-                                }
-                                case EffectOpCodes.OP_SUCCESS: {
-                                  return pipe(
-                                    ref.set(finalizerRef, (exit) =>
-                                      pipe(
-                                        core.scopeClose(innerScope, exit),
-                                        core.whenEffect(
-                                          ref.modify(observers, (n) => [n === 1, n - 1] as const)
-                                        ),
-                                        core.asVoid
-                                      )),
-                                    core.zipRight(ref.update(observers, (n) => n + 1)),
-                                    core.zipRight(
-                                      core.scopeAddFinalizerExit(scope, (exit) =>
-                                        pipe(
-                                          core.sync(() => map.delete(layer)),
-                                          core.zipRight(ref.get(finalizerRef)),
-                                          core.flatMap((finalizer) => finalizer(exit))
-                                        ))
-                                    ),
-                                    core.zipRight(core.deferredSucceed(deferred, exit.effect_instruction_i0)),
-                                    core.as(exit.effect_instruction_i0[1])
-                                  )
-                                }
-                              }
-                            })
-                          )
-                        )
-                      )
-                    )
-                    const memoized = [
-                      pipe(
-                        core.deferredAwait(deferred),
-                        core.onExit(core.exitMatchEffect({
-                          onFailure: () => core.void,
-                          onSuccess: () => ref.update(observers, (n) => n + 1)
-                        }))
-                      ),
-                      (exit: Exit.Exit<unknown, unknown>) =>
-                        pipe(
-                          ref.get(finalizerRef),
-                          core.flatMap((finalizer) => finalizer(exit))
-                        )
-                    ] as const
-                    return [
-                      resource,
-                      isFresh(layer) ? map : map.set(layer, memoized)
-                    ] as const
-                  })
-                )
-              )
-            )
-          )
-        )
-      }),
-      core.flatten
-    )
-  }
-}
-
-/** @internal */
-export const makeMemoMap: Effect.Effect<Layer.MemoMap> = core.suspend(() =>
-  core.map(
-    circular.makeSynchronized<
-      Map<
-        Layer.Layer<any, any, any>,
-        readonly [
-          Effect.Effect<any, any>,
-          Scope.Scope.Finalizer
-        ]
-      >
-    >(new Map()),
-    (ref) => new MemoMapImpl(ref)
-  )
-)
-
-/** @internal */
-export const unsafeMakeMemoMap = (): Layer.MemoMap => new MemoMapImpl(circular.unsafeMakeSynchronized(new Map()))
-
-/** @internal */
-export const build = <RIn, E, ROut>(
-  self: Layer.Layer<ROut, E, RIn>
-): Effect.Effect<Context.Context<ROut>, E, RIn | Scope.Scope> =>
-  fiberRuntime.scopeWith((scope) => buildWithScope(self, scope))
-
-/** @internal */
-export const buildWithScope = dual<
-  (
-    scope: Scope.Scope
-  ) => <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>,
-  <RIn, E, ROut>(
-    self: Layer.Layer<ROut, E, RIn>,
-    scope: Scope.Scope
-  ) => Effect.Effect<Context.Context<ROut>, E, RIn>
->(2, (self, scope) =>
-  core.flatMap(
-    makeMemoMap,
-    (memoMap) => buildWithMemoMap(self, memoMap, scope)
-  ))
-
-/** @internal */
-export const buildWithMemoMap = dual<
-  (
-    memoMap: Layer.MemoMap,
-    scope: Scope.Scope
-  ) => <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>,
-  <RIn, E, ROut>(
-    self: Layer.Layer<ROut, E, RIn>,
-    memoMap: Layer.MemoMap,
-    scope: Scope.Scope
-  ) => Effect.Effect<Context.Context<ROut>, E, RIn>
->(
-  3,
-  (self, memoMap, scope) =>
-    core.flatMap(
-      makeBuilder(self, scope),
-      (run) => effect.provideService(run(memoMap), CurrentMemoMap, memoMap)
-    )
-)
-
-const makeBuilder = <RIn, E, ROut>(
-  self: Layer.Layer<ROut, E, RIn>,
-  scope: Scope.Scope,
-  inMemoMap = false
-): Effect.Effect<(memoMap: Layer.MemoMap) => Effect.Effect<Context.Context<ROut>, E, RIn>> => {
-  const op = self as Primitive
-  switch (op._op_layer) {
-    case "Locally": {
-      return core.sync(() => (memoMap: Layer.MemoMap) => op.f(memoMap.getOrElseMemoize(op.self, scope)))
-    }
-    case "ExtendScope": {
-      return core.sync(() => (memoMap: Layer.MemoMap) =>
-        fiberRuntime.scopeWith(
-          (scope) => memoMap.getOrElseMemoize(op.layer, scope)
-        ) as unknown as Effect.Effect<Context.Context<ROut>, E, RIn>
-      )
-    }
-    case "Fold": {
-      return core.sync(() => (memoMap: Layer.MemoMap) =>
-        pipe(
-          memoMap.getOrElseMemoize(op.layer, scope),
-          core.matchCauseEffect({
-            onFailure: (cause) => memoMap.getOrElseMemoize(op.failureK(cause), scope),
-            onSuccess: (value) => memoMap.getOrElseMemoize(op.successK(value), scope)
-          })
-        )
-      )
-    }
-    case "Fresh": {
-      return core.sync(() => (_: Layer.MemoMap) => pipe(op.layer, buildWithScope(scope)))
-    }
-    case "FromEffect": {
-      return inMemoMap
-        ? core.sync(() => (_: Layer.MemoMap) => op.effect as Effect.Effect<Context.Context<ROut>, E, RIn>)
-        : core.sync(() => (memoMap: Layer.MemoMap) => memoMap.getOrElseMemoize(self, scope))
-    }
-    case "Provide": {
-      return core.sync(() => (memoMap: Layer.MemoMap) =>
-        pipe(
-          memoMap.getOrElseMemoize(op.first, scope),
-          core.flatMap((env) =>
-            pipe(
-              memoMap.getOrElseMemoize(op.second, scope),
-              core.provideContext(env)
-            )
-          )
-        )
-      )
-    }
-    case "Scoped": {
-      return inMemoMap
-        ? core.sync(() => (_: Layer.MemoMap) =>
-          fiberRuntime.scopeExtend(
-            op.effect as Effect.Effect<Context.Context<ROut>, E, RIn>,
-            scope
-          )
-        )
-        : core.sync(() => (memoMap: Layer.MemoMap) => memoMap.getOrElseMemoize(self, scope))
-    }
-    case "Suspend": {
-      return core.sync(() => (memoMap: Layer.MemoMap) =>
-        memoMap.getOrElseMemoize(
-          op.evaluate(),
-          scope
-        )
-      )
-    }
-    case "ProvideMerge": {
-      return core.sync(() => (memoMap: Layer.MemoMap) =>
-        pipe(
-          memoMap.getOrElseMemoize(op.first, scope),
-          core.zipWith(
-            memoMap.getOrElseMemoize(op.second, scope),
-            op.zipK
-          )
-        )
-      )
-    }
-    case "ZipWith": {
-      return core.gen(function*() {
-        const parallelScope = yield* core.scopeFork(scope, ExecutionStrategy.parallel)
-        const firstScope = yield* core.scopeFork(parallelScope, ExecutionStrategy.sequential)
-        const secondScope = yield* core.scopeFork(parallelScope, ExecutionStrategy.sequential)
-        return (memoMap: Layer.MemoMap) =>
-          pipe(
-            memoMap.getOrElseMemoize(op.first, firstScope),
-            fiberRuntime.zipWithOptions(
-              memoMap.getOrElseMemoize(op.second, secondScope),
-              op.zipK,
-              { concurrent: true }
-            )
-          )
-      })
-    }
-    case "MergeAll": {
-      const layers = op.layers
-      return core.map(
-        core.scopeFork(scope, ExecutionStrategy.parallel),
-        (parallelScope) => (memoMap: Layer.MemoMap) => {
-          const contexts = new Array<Context.Context<any>>(layers.length)
-          return core.map(
-            fiberRuntime.forEachConcurrentDiscard(
-              layers,
-              core.fnUntraced(function*(layer, i) {
-                const scope = yield* core.scopeFork(parallelScope, ExecutionStrategy.sequential)
-                const context = yield* memoMap.getOrElseMemoize(layer, scope)
-                contexts[i] = context
-              }),
-              false,
-              false
-            ),
-            () => Context.mergeAll(...contexts)
-          )
-        }
-      )
-    }
-  }
-}
-
-// -----------------------------------------------------------------------------
-// Layer
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const catchAll = dual<
-  <E, RIn2, E2, ROut2>(
-    onError: (error: E) => Layer.Layer<ROut2, E2, RIn2>
-  ) => <RIn, ROut>(self: Layer.Layer<ROut, E, RIn>) => Layer.Layer<ROut & ROut2, E2, RIn | RIn2>,
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer.Layer<ROut, E, RIn>,
-    onError: (error: E) => Layer.Layer<ROut2, E2, RIn2>
-  ) => Layer.Layer<ROut & ROut2, E2, RIn | RIn2>
->(2, (self, onFailure) => match(self, { onFailure, onSuccess: succeedContext }))
-
-/** @internal */
-export const catchAllCause = dual<
-  <E, RIn2, E2, ROut2>(
-    onError: (cause: Cause.Cause<E>) => Layer.Layer<ROut2, E2, RIn2>
-  ) => <RIn, ROut>(self: Layer.Layer<ROut, E, RIn>) => Layer.Layer<ROut & ROut2, E2, RIn | RIn2>,
-  <RIn, E, ROut, RIn2, E2, ROut22>(
-    self: Layer.Layer<ROut, E, RIn>,
-    onError: (cause: Cause.Cause<E>) => Layer.Layer<ROut22, E2, RIn2>
-  ) => Layer.Layer<ROut & ROut22, E2, RIn | RIn2>
->(2, (self, onFailure) => matchCause(self, { onFailure, onSuccess: succeedContext }))
-
-/** @internal */
-export const die = (defect: unknown): Layer.Layer<unknown> => failCause(Cause.die(defect))
-
-/** @internal */
-export const dieSync = (evaluate: LazyArg<unknown>): Layer.Layer<unknown> => failCauseSync(() => Cause.die(evaluate()))
-
-/** @internal */
-export const discard = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): Layer.Layer<never, E, RIn> =>
-  map(self, () => Context.empty())
-
-/** @internal */
-export const context = <R>(): Layer.Layer<R, never, R> => fromEffectContext(core.context<R>())
-
-/** @internal */
-export const extendScope = <RIn, E, ROut>(
-  self: Layer.Layer<ROut, E, RIn>
-): Layer.Layer<ROut, E, RIn | Scope.Scope> => {
-  const extendScope = Object.create(proto)
-  extendScope._op_layer = OpCodes.OP_EXTEND_SCOPE
-  extendScope.layer = self
-  return extendScope
-}
-
-/** @internal */
-export const fail = <E>(error: E): Layer.Layer<unknown, E> => failCause(Cause.fail(error))
-
-/** @internal */
-export const failSync = <E>(evaluate: LazyArg<E>): Layer.Layer<unknown, E> =>
-  failCauseSync(() => Cause.fail(evaluate()))
-
-/** @internal */
-export const failCause = <E>(cause: Cause.Cause<E>): Layer.Layer<unknown, E> => fromEffectContext(core.failCause(cause))
-
-/** @internal */
-export const failCauseSync = <E>(evaluate: LazyArg<Cause.Cause<E>>): Layer.Layer<unknown, E> =>
-  fromEffectContext(core.failCauseSync(evaluate))
-
-/** @internal */
-export const flatMap = dual<
-  <A, A2, E2, R2>(
-    f: (context: Context.Context<A>) => Layer.Layer<A2, E2, R2>
-  ) => <E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2, E | E2, R | R2>,
-  <A, E, R, A2, E2, R2>(
-    self: Layer.Layer<A, E, R>,
-    f: (context: Context.Context<A>) => Layer.Layer<A2, E2, R2>
-  ) => Layer.Layer<A2, E | E2, R | R2>
->(2, (self, f) => match(self, { onFailure: fail, onSuccess: f }))
-
-/** @internal */
-export const flatten = dual<
-  <I, A, E2, R2>(
-    tag: Context.Tag<I, Layer.Layer<A, E2, R2>>
-  ) => <E, R>(
-    self: Layer.Layer<I, E, R>
-  ) => Layer.Layer<A, E | E2, R | R2>,
-  <I, E, R, A, E2, R2>(
-    self: Layer.Layer<I, E, R>,
-    tag: Context.Tag<I, Layer.Layer<A, E2, R2>>
-  ) => Layer.Layer<A, E | E2, R | R2>
->(2, (self, tag) => flatMap(self, Context.get(tag as any) as any))
-
-/** @internal */
-export const fresh = <A, E, R>(self: Layer.Layer<A, E, R>): Layer.Layer<A, E, R> => {
-  const fresh = Object.create(proto)
-  fresh._op_layer = OpCodes.OP_FRESH
-  fresh.layer = self
-  return fresh
-}
-
-/** @internal */
-export const fromEffect = dual<
-  <I, S>(
-    tag: Context.Tag<I, S>
-  ) => <E, R>(
-    effect: Effect.Effect<Types.NoInfer<S>, E, R>
-  ) => Layer.Layer<I, E, R>,
-  <I, S, E, R>(
-    tag: Context.Tag<I, S>,
-    effect: Effect.Effect<Types.NoInfer<S>, E, R>
-  ) => Layer.Layer<I, E, R>
->(2, (a, b) => {
-  const tagFirst = Context.isTag(a)
-  const tag = (tagFirst ? a : b) as Context.Tag<unknown, unknown>
-  const effect = tagFirst ? b : a
-  return fromEffectContext(core.map(effect, (service) => Context.make(tag, service)))
-})
-
-/** @internal */
-export const fromEffectDiscard = <X, E, R>(effect: Effect.Effect<X, E, R>) =>
-  fromEffectContext(core.map(effect, () => Context.empty()))
-
-/** @internal */
-export function fromEffectContext<A, E, R>(
-  effect: Effect.Effect<Context.Context<A>, E, R>
-): Layer.Layer<A, E, R> {
-  const fromEffect = Object.create(proto)
-  fromEffect._op_layer = OpCodes.OP_FROM_EFFECT
-  fromEffect.effect = effect
-  return fromEffect
-}
-
-/** @internal */
-export const fiberRefLocally = dual<
-  <X>(ref: FiberRef<X>, value: X) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <A, E, R, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: X) => Layer.Layer<A, E, R>
->(3, (self, ref, value) => locallyEffect(self, core.fiberRefLocally(ref, value)))
-
-/** @internal */
-export const locallyEffect = dual<
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>
-  ) => (self: Layer.Layer<ROut, E, RIn>) => Layer.Layer<ROut2, E2, RIn2>,
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer.Layer<ROut, E, RIn>,
-    f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>
-  ) => Layer.Layer<ROut2, E2, RIn2>
->(2, (self, f) => {
-  const locally = Object.create(proto)
-  locally._op_layer = "Locally"
-  locally.self = self
-  locally.f = f
-  return locally
-})
-
-/** @internal */
-export const fiberRefLocallyWith = dual<
-  <X>(ref: FiberRef<X>, value: (_: X) => X) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <A, E, R, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X) => Layer.Layer<A, E, R>
->(3, (self, ref, value) => locallyEffect(self, core.fiberRefLocallyWith(ref, value)))
-
-/** @internal */
-export const fiberRefLocallyScoped = <A>(self: FiberRef<A>, value: A): Layer.Layer<never> =>
-  scopedDiscard(fiberRuntime.fiberRefLocallyScoped(self, value))
-
-/** @internal */
-export const fiberRefLocallyScopedWith = <A>(self: FiberRef<A>, value: (_: A) => A): Layer.Layer<never> =>
-  scopedDiscard(fiberRuntime.fiberRefLocallyScopedWith(self, value))
-
-/** @internal */
-export 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.Layer<I2, never, I1> => fromEffectContext(core.map(tagA, (a) => Context.make(tagB, f(a))))
-
-/** @internal */
-export const launch = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): Effect.Effect<never, E, RIn> =>
-  fiberRuntime.scopedEffect(
-    core.zipRight(
-      fiberRuntime.scopeWith((scope) => pipe(self, buildWithScope(scope))),
-      core.never
-    )
-  )
-
-/** @internal */
-export const mock: {
-  <I, S extends object>(tag: Context.Tag<I, S>): (service: Layer.PartialEffectful<S>) => Layer.Layer<I>
-  <I, S extends object>(tag: Context.Tag<I, S>, service: Layer.PartialEffectful<S>): Layer.Layer<I>
-} = function() {
-  if (arguments.length === 1) {
-    return (service: Layer.PartialEffectful<any>) => mockImpl(arguments[0], service)
-  }
-  return mockImpl(arguments[0], arguments[1])
-} as any
-
-const mockImpl = <I, S extends object>(tag: Context.Tag<I, S>, service: Layer.PartialEffectful<S>): Layer.Layer<I> =>
-  succeed(
-    tag,
-    new Proxy({ ...service as object } as S, {
-      get(target, prop, _receiver) {
-        if (prop in target) {
-          return target[prop as keyof S]
-        }
-        const prevLimit = Error.stackTraceLimit
-        Error.stackTraceLimit = 2
-        const error = new Error(`${tag.key}: Unimplemented method "${prop.toString()}"`)
-        Error.stackTraceLimit = prevLimit
-        error.name = "UnimplementedError"
-        return makeUnimplemented(error)
-      },
-      has: constTrue
-    })
-  )
-
-const makeUnimplemented = (error: Error) => {
-  const dead = core.die(error)
-  function unimplemented() {
-    return dead
-  }
-  // @effect-diagnostics-next-line floatingEffect:off
-  Object.assign(unimplemented, dead)
-  Object.setPrototypeOf(unimplemented, Object.getPrototypeOf(dead))
-  return unimplemented
-}
-
-/** @internal */
-export const map = dual<
-  <A, B>(
-    f: (context: Context.Context<A>) => Context.Context<B>
-  ) => <E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<B, E, R>,
-  <A, E, R, B>(
-    self: Layer.Layer<A, E, R>,
-    f: (context: Context.Context<A>) => Context.Context<B>
-  ) => Layer.Layer<B, E, R>
->(2, (self, f) => flatMap(self, (context) => succeedContext(f(context))))
-
-/** @internal */
-export const mapError = dual<
-  <E, E2>(f: (error: E) => E2) => <A, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E2, R>,
-  <A, E, R, E2>(self: Layer.Layer<A, E, R>, f: (error: E) => E2) => Layer.Layer<A, E2, R>
->(2, (self, f) => catchAll(self, (error) => failSync(() => f(error))))
-
-/** @internal */
-export const matchCause = dual<
-  <E, A2, E2, R2, A, A3, E3, R3>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => Layer.Layer<A2, E2, R2>
-      readonly onSuccess: (context: Context.Context<A>) => Layer.Layer<A3, E3, R3>
-    }
-  ) => <R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>,
-  <A, E, R, A2, E2, R2, A3, E3, R3>(
-    self: Layer.Layer<A, E, R>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => Layer.Layer<A2, E2, R2>
-      readonly onSuccess: (context: Context.Context<A>) => Layer.Layer<A3, E3, R3>
-    }
-  ) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>
->(2, (self, { onFailure, onSuccess }) => {
-  const fold = Object.create(proto)
-  fold._op_layer = OpCodes.OP_FOLD
-  fold.layer = self
-  fold.failureK = onFailure
-  fold.successK = onSuccess
-  return fold
-})
-
-/** @internal */
-export const match = dual<
-  <E, A2, E2, R2, A, A3, E3, R3>(
-    options: {
-      readonly onFailure: (error: E) => Layer.Layer<A2, E2, R2>
-      readonly onSuccess: (context: Context.Context<A>) => Layer.Layer<A3, E3, R3>
-    }
-  ) => <R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>,
-  <A, E, R, A2, E2, R2, A3, E3, R3>(
-    self: Layer.Layer<A, E, R>,
-    options: {
-      readonly onFailure: (error: E) => Layer.Layer<A2, E2, R2>
-      readonly onSuccess: (context: Context.Context<A>) => Layer.Layer<A3, E3, R3>
-    }
-  ) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>
->(2, (self, { onFailure, onSuccess }) =>
-  matchCause(self, {
-    onFailure: (cause) => {
-      const failureOrCause = Cause.failureOrCause(cause)
-      switch (failureOrCause._tag) {
-        case "Left": {
-          return onFailure(failureOrCause.left)
-        }
-        case "Right": {
-          return failCause(failureOrCause.right)
-        }
-      }
-    },
-    onSuccess
-  }))
-
-/** @internal */
-export const memoize = <RIn, E, ROut>(
-  self: Layer.Layer<ROut, E, RIn>
-): Effect.Effect<Layer.Layer<ROut, E, RIn>, never, Scope.Scope> =>
-  fiberRuntime.scopeWith((scope) =>
-    core.map(
-      effect.memoize(buildWithScope(self, scope)),
-      fromEffectContext
-    )
-  )
-
-/** @internal */
-export const merge = dual<
-  <RIn2, E2, ROut2>(
-    that: Layer.Layer<ROut2, E2, RIn2>
-  ) => <RIn, E1, ROut>(self: Layer.Layer<ROut, E1, RIn>) => Layer.Layer<
-    ROut | ROut2,
-    E1 | E2,
-    RIn | RIn2
-  >,
-  <RIn, E1, ROut, RIn2, E2, ROut2>(self: Layer.Layer<ROut, E1, RIn>, that: Layer.Layer<ROut2, E2, RIn2>) => Layer.Layer<
-    ROut | ROut2,
-    E1 | E2,
-    RIn | RIn2
-  >
->(2, (self, that) => zipWith(self, that, (a, b) => Context.merge(a, b)))
-
-/** @internal */
-export const mergeAll = <
-  Layers extends readonly [Layer.Layer<never, any, any>, ...Array<Layer.Layer<never, any, any>>]
->(
-  ...layers: Layers
-): Layer.Layer<
-  { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number],
-  { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
-  { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
-> => {
-  const mergeAll = Object.create(proto)
-  mergeAll._op_layer = OpCodes.OP_MERGE_ALL
-  mergeAll.layers = layers
-  return mergeAll as any
-}
-
-/** @internal */
-export const orDie = <A, E, R>(self: Layer.Layer<A, E, R>): Layer.Layer<A, never, R> =>
-  catchAll(self, (defect) => die(defect))
-
-/** @internal */
-export const orElse = dual<
-  <A2, E2, R2>(
-    that: LazyArg<Layer.Layer<A2, E2, R2>>
-  ) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A & A2, E | E2, R | R2>,
-  <A, E, R, A2, E2, R2>(
-    self: Layer.Layer<A, E, R>,
-    that: LazyArg<Layer.Layer<A2, E2, R2>>
-  ) => Layer.Layer<A & A2, E | E2, R | R2>
->(2, (self, that) => catchAll(self, that))
-
-/** @internal */
-export const passthrough = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): Layer.Layer<RIn | ROut, E, RIn> =>
-  merge(context<RIn>(), self)
-
-/** @internal */
-export const project = dual<
-  <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.Layer<I1, E, RIn>) => Layer.Layer<I2, E, RIn>,
-  <RIn, E, I1, S1, I2, S2>(
-    self: Layer.Layer<I1, E, RIn>,
-    tagA: Context.Tag<I1, S1>,
-    tagB: Context.Tag<I2, S2>,
-    f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>
-  ) => Layer.Layer<I2, E, RIn>
->(4, (self, tagA, tagB, f) => map(self, (context) => Context.make(tagB, f(Context.unsafeGet(context, tagA)))))
-
-/** @internal */
-export const retry = dual<
-  <X, E, RIn2>(
-    schedule: Schedule.Schedule<X, E, RIn2>
-  ) => <ROut, RIn>(
-    self: Layer.Layer<ROut, E, RIn>
-  ) => Layer.Layer<ROut, E, RIn | RIn2>,
-  <ROut, E, RIn, X, RIn2>(
-    self: Layer.Layer<ROut, E, RIn>,
-    schedule: Schedule.Schedule<X, E, RIn2>
-  ) => Layer.Layer<ROut, E, RIn | RIn2>
->(2, (self, schedule) =>
-  suspend(() => {
-    const stateTag = Context.GenericTag<{ state: unknown }>("effect/Layer/retry/{ state: unknown }")
-    return pipe(
-      succeed(stateTag, { state: schedule.initial }),
-      flatMap((env: Context.Context<{ state: unknown }>) =>
-        retryLoop(self, schedule, stateTag, pipe(env, Context.get(stateTag)).state)
-      )
-    )
-  }))
-
-const retryLoop = <ROut, E, RIn, X, RIn2>(
-  self: Layer.Layer<ROut, E, RIn>,
-  schedule: Schedule.Schedule<X, E, RIn2>,
-  stateTag: Context.Tag<{ state: unknown }, { state: unknown }>,
-  state: unknown
-): Layer.Layer<ROut, E, RIn | RIn2> => {
-  return pipe(
-    self,
-    catchAll((error) =>
-      pipe(
-        retryUpdate(schedule, stateTag, error, state),
-        flatMap((env) => fresh(retryLoop(self, schedule, stateTag, pipe(env, Context.get(stateTag)).state)))
-      )
-    )
-  )
-}
-
-const retryUpdate = <X, E, RIn>(
-  schedule: Schedule.Schedule<X, E, RIn>,
-  stateTag: Context.Tag<{ state: unknown }, { state: unknown }>,
-  error: E,
-  state: unknown
-): Layer.Layer<{ state: unknown }, E, RIn> => {
-  return fromEffect(
-    stateTag,
-    pipe(
-      Clock.currentTimeMillis,
-      core.flatMap((now) =>
-        pipe(
-          schedule.step(now, error, state),
-          core.flatMap(([state, _, decision]) =>
-            ScheduleDecision.isDone(decision) ?
-              core.fail(error) :
-              pipe(
-                Clock.sleep(Duration.millis(Intervals.start(decision.intervals) - now)),
-                core.as({ state })
-              )
-          )
-        )
-      )
-    )
-  )
-}
-
-/** @internal */
-export const scoped = dual<
-  <I, S>(
-    tag: Context.Tag<I, S>
-  ) => <E, R>(
-    effect: Effect.Effect<Types.NoInfer<S>, E, R>
-  ) => Layer.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.Layer<I, E, Exclude<R, Scope.Scope>>
->(2, (a, b) => {
-  const tagFirst = Context.isTag(a)
-  const tag = (tagFirst ? a : b) as Context.Tag<unknown, unknown>
-  const effect = tagFirst ? b : a
-  return scopedContext(core.map(effect, (service) => Context.make(tag, service)))
-})
-
-/** @internal */
-export const scopedDiscard = <X, E, R>(
-  effect: Effect.Effect<X, E, R>
-): Layer.Layer<never, E, Exclude<R, Scope.Scope>> => scopedContext(pipe(effect, core.as(Context.empty())))
-
-/** @internal */
-export const scopedContext = <A, E, R>(
-  effect: Effect.Effect<Context.Context<A>, E, R>
-): Layer.Layer<A, E, Exclude<R, Scope.Scope>> => {
-  const scoped = Object.create(proto)
-  scoped._op_layer = OpCodes.OP_SCOPED
-  scoped.effect = effect
-  return scoped
-}
-
-/** @internal */
-export const enableSourceCapture: Layer.Layer<never> =
-  fiberRefLocallyScoped(core.currentCaptureStackTraces, true)
-
-/** @internal */
-export const scope: Layer.Layer<Scope.Scope> = scopedContext(
-  core.map(
-    fiberRuntime.acquireRelease(
-      fiberRuntime.scopeMake(),
-      (scope, exit) => scope.close(exit)
-    ),
-    (scope) => Context.make(Scope.Scope, scope)
-  )
-)
-
-/** @internal */
-export const service = <I, S>(
-  tag: Context.Tag<I, S>
-): Layer.Layer<I, never, I> => fromEffect(tag, tag)
-
-/** @internal */
-export const succeed = dual<
-  <I, S>(
-    tag: Context.Tag<I, S>
-  ) => (
-    resource: Types.NoInfer<S>
-  ) => Layer.Layer<I>,
-  <I, S>(
-    tag: Context.Tag<I, S>,
-    resource: Types.NoInfer<S>
-  ) => Layer.Layer<I>
->(2, (a, b) => {
-  const tagFirst = Context.isTag(a)
-  const tag = (tagFirst ? a : b) as Context.Tag<unknown, unknown>
-  const resource = tagFirst ? b : a
-  return fromEffectContext(core.succeed(Context.make(tag, resource)))
-})
-
-/** @internal */
-export const succeedContext = <A>(
-  context: Context.Context<A>
-): Layer.Layer<A> => {
-  return fromEffectContext(core.succeed(context))
-}
-
-/** @internal */
-export const empty = succeedContext(Context.empty())
-
-/** @internal */
-export const suspend = <RIn, E, ROut>(
-  evaluate: LazyArg<Layer.Layer<ROut, E, RIn>>
-): Layer.Layer<ROut, E, RIn> => {
-  const suspend = Object.create(proto)
-  suspend._op_layer = OpCodes.OP_SUSPEND
-  suspend.evaluate = evaluate
-  return suspend
-}
-
-/** @internal */
-export const sync = dual<
-  <I, S>(
-    tag: Context.Tag<I, S>
-  ) => (
-    evaluate: LazyArg<Types.NoInfer<S>>
-  ) => Layer.Layer<I>,
-  <I, S>(
-    tag: Context.Tag<I, S>,
-    evaluate: LazyArg<Types.NoInfer<S>>
-  ) => Layer.Layer<I>
->(2, (a, b) => {
-  const tagFirst = Context.isTag(a)
-  const tag = (tagFirst ? a : b) as Context.Tag<unknown, unknown>
-  const evaluate = tagFirst ? b : a
-  return fromEffectContext(core.sync(() => Context.make(tag, evaluate())))
-})
-
-/** @internal */
-export const syncContext = <A>(evaluate: LazyArg<Context.Context<A>>): Layer.Layer<A> => {
-  return fromEffectContext(core.sync(evaluate))
-}
-
-/** @internal */
-export const tap = dual<
-  <ROut, XR extends ROut, RIn2, E2, X>(
-    f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>
-  ) => <RIn, E>(self: Layer.Layer<ROut, E, RIn>) => Layer.Layer<ROut, E | E2, RIn | RIn2>,
-  <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(
-    self: Layer.Layer<ROut, E, RIn>,
-    f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>
-  ) => Layer.Layer<ROut, E | E2, RIn | RIn2>
->(2, (self, f) => flatMap(self, (context) => fromEffectContext(core.as(f(context), context))))
-
-/** @internal */
-export const tapError = dual<
-  <E, XE extends E, RIn2, E2, X>(
-    f: (e: XE) => Effect.Effect<X, E2, RIn2>
-  ) => <RIn, ROut>(self: Layer.Layer<ROut, E, RIn>) => Layer.Layer<ROut, E | E2, RIn | RIn2>,
-  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
-    self: Layer.Layer<ROut, E, RIn>,
-    f: (e: XE) => Effect.Effect<X, E2, RIn2>
-  ) => Layer.Layer<ROut, E | E2, RIn | RIn2>
->(2, (self, f) =>
-  catchAll(
-    self,
-    (e) => fromEffectContext(core.flatMap(f(e as any), () => core.fail(e)))
-  ))
-
-/** @internal */
-export const tapErrorCause = dual<
-  <E, XE extends E, RIn2, E2, X>(
-    f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>
-  ) => <RIn, ROut>(self: Layer.Layer<ROut, E, RIn>) => Layer.Layer<ROut, E | E2, RIn | RIn2>,
-  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
-    self: Layer.Layer<ROut, E, RIn>,
-    f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>
-  ) => Layer.Layer<ROut, E | E2, RIn | RIn2>
->(2, (self, f) =>
-  catchAllCause(
-    self,
-    (cause) => fromEffectContext(core.flatMap(f(cause as any), () => core.failCause(cause)))
-  ))
-
-/** @internal */
-export const toRuntime = <RIn, E, ROut>(
-  self: Layer.Layer<ROut, E, RIn>
-): Effect.Effect<Runtime.Runtime<ROut>, E, RIn | Scope.Scope> =>
-  pipe(
-    fiberRuntime.scopeWith((scope) => buildWithScope(self, scope)),
-    core.flatMap((context) =>
-      pipe(
-        runtime.runtime<ROut>(),
-        core.provideContext(context)
-      )
-    )
-  )
-
-/** @internal */
-export const toRuntimeWithMemoMap = dual<
-  (
-    memoMap: Layer.MemoMap
-  ) => <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>) => Effect.Effect<Runtime.Runtime<ROut>, E, RIn | Scope.Scope>,
-  <RIn, E, ROut>(
-    self: Layer.Layer<ROut, E, RIn>,
-    memoMap: Layer.MemoMap
-  ) => Effect.Effect<Runtime.Runtime<ROut>, E, RIn | Scope.Scope>
->(2, (self, memoMap) =>
-  core.flatMap(
-    fiberRuntime.scopeWith((scope) => buildWithMemoMap(self, memoMap, scope)),
-    (context) =>
-      pipe(
-        runtime.runtime<any>(),
-        core.provideContext(context)
-      )
-  ))
-
-/** @internal */
-export const provide = dual<
-  {
-    <RIn, E, ROut>(
-      that: Layer.Layer<ROut, E, RIn>
-    ): <RIn2, E2, ROut2>(
-      self: Layer.Layer<ROut2, E2, RIn2>
-    ) => Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
-    <const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
-      that: Layers
-    ): <A, E, R>(
-      self: Layer.Layer<A, E, R>
-    ) => Layer.Layer<
-      A,
-      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
-      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
-      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
-    >
-  },
-  {
-    <RIn2, E2, ROut2, RIn, E, ROut>(
-      self: Layer.Layer<ROut2, E2, RIn2>,
-      that: Layer.Layer<ROut, E, RIn>
-    ): Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
-    <A, E, R, const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
-      self: Layer.Layer<A, E, R>,
-      that: Layers
-    ): Layer.Layer<
-      A,
-      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
-      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
-      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
-    >
-  }
->(2, (
-  self: Layer.Layer.Any,
-  that: Layer.Layer.Any | ReadonlyArray<Layer.Layer.Any>
-) =>
-  suspend(() => {
-    const provideTo = Object.create(proto)
-    provideTo._op_layer = OpCodes.OP_PROVIDE
-    provideTo.first = Object.create(proto, {
-      _op_layer: { value: OpCodes.OP_PROVIDE_MERGE, enumerable: true },
-      first: { value: context(), enumerable: true },
-      second: { value: Array.isArray(that) ? mergeAll(...that as any) : that },
-      zipK: { value: (a: Context.Context<any>, b: Context.Context<any>) => pipe(a, Context.merge(b)) }
-    })
-    provideTo.second = self
-    return provideTo
-  }))
-
-/** @internal */
-export const provideMerge = dual<
-  <RIn, E, ROut>(
-    self: Layer.Layer<ROut, E, RIn>
-  ) => <RIn2, E2, ROut2>(
-    that: Layer.Layer<ROut2, E2, RIn2>
-  ) => Layer.Layer<ROut | ROut2, E2 | E, RIn | Exclude<RIn2, ROut>>,
-  <RIn2, E2, ROut2, RIn, E, ROut>(
-    that: Layer.Layer<ROut2, E2, RIn2>,
-    self: Layer.Layer<ROut, E, RIn>
-  ) => Layer.Layer<ROut | ROut2, E2 | E, RIn | Exclude<RIn2, ROut>>
->(2, <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer.Layer<ROut2, E2, RIn2>, self: Layer.Layer<ROut, E, RIn>) => {
-  const zipWith = Object.create(proto)
-  zipWith._op_layer = OpCodes.OP_PROVIDE_MERGE
-  zipWith.first = self
-  zipWith.second = provide(that, self)
-  zipWith.zipK = (a: Context.Context<ROut>, b: Context.Context<ROut2>): Context.Context<ROut | ROut2> => {
-    return pipe(a, Context.merge(b))
-  }
-  return zipWith
-})
-
-/** @internal */
-export const zipWith = dual<
-  <B, E2, R2, A, C>(
-    that: Layer.Layer<B, E2, R2>,
-    f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
-  ) => <E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<C, E | E2, R | R2>,
-  <A, E, R, B, E2, R2, C>(
-    self: Layer.Layer<A, E, R>,
-    that: Layer.Layer<B, E2, R2>,
-    f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
-  ) => Layer.Layer<C, E | E2, R | R2>
->(3, (self, that, f) =>
-  suspend(() => {
-    const zipWith = Object.create(proto)
-    zipWith._op_layer = OpCodes.OP_ZIP_WITH
-    zipWith.first = self
-    zipWith.second = that
-    zipWith.zipK = f
-    return zipWith
-  }))
-
-/** @internal */
-export const unwrapEffect = <A, E1, R1, E, R>(
-  self: Effect.Effect<Layer.Layer<A, E1, R1>, E, R>
-): Layer.Layer<A, E | E1, R | R1> => {
-  const tag = Context.GenericTag<Layer.Layer<A, E1, R1>>("effect/Layer/unwrapEffect/Layer.Layer<R1, E1, A>")
-  return flatMap(fromEffect(tag, self), (context) => Context.get(context, tag))
-}
-
-/** @internal */
-export const unwrapScoped = <A, E1, R1, E, R>(
-  self: Effect.Effect<Layer.Layer<A, E1, R1>, E, R>
-): Layer.Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>> => {
-  const tag = Context.GenericTag<Layer.Layer<A, E1, R1>>("effect/Layer/unwrapScoped/Layer.Layer<R1, E1, A>")
-  return flatMap(scoped(tag, self), (context) => Context.get(context, tag))
-}
-
-// -----------------------------------------------------------------------------
-// logging
-// -----------------------------------------------------------------------------
-
-export const annotateLogs = dual<
-  {
-    (key: string, value: unknown): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
-    (
-      values: Record<string, unknown>
-    ): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
-  },
-  {
-    <A, E, R>(self: Layer.Layer<A, E, R>, key: string, value: unknown): Layer.Layer<A, E, R>
-    <A, E, R>(self: Layer.Layer<A, E, R>, values: Record<string, unknown>): Layer.Layer<A, E, R>
-  }
->(
-  (args) => isLayer(args[0]),
-  function<A, E, R>() {
-    const args = arguments
-    return fiberRefLocallyWith(
-      args[0] as Layer.Layer<A, E, R>,
-      core.currentLogAnnotations,
-      typeof args[1] === "string"
-        ? HashMap.set(args[1], args[2])
-        : (annotations) =>
-          Object.entries(args[1] as Record<string, unknown>).reduce(
-            (acc, [key, value]) => HashMap.set(acc, key, value),
-            annotations
-          )
-    )
-  }
-)
-
-// -----------------------------------------------------------------------------
-// tracing
-// -----------------------------------------------------------------------------
-
-export const annotateSpans = dual<
-  {
-    (key: string, value: unknown): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
-    (
-      values: Record<string, unknown>
-    ): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
-  },
-  {
-    <A, E, R>(self: Layer.Layer<A, E, R>, key: string, value: unknown): Layer.Layer<A, E, R>
-    <A, E, R>(self: Layer.Layer<A, E, R>, values: Record<string, unknown>): Layer.Layer<A, E, R>
-  }
->(
-  (args) => isLayer(args[0]),
-  function<A, E, R>() {
-    const args = arguments
-    return fiberRefLocallyWith(
-      args[0] as Layer.Layer<A, E, R>,
-      core.currentTracerSpanAnnotations,
-      typeof args[1] === "string"
-        ? HashMap.set(args[1], args[2])
-        : (annotations) =>
-          Object.entries(args[1] as Record<string, unknown>).reduce(
-            (acc, [key, value]) => HashMap.set(acc, key, value),
-            annotations
-          )
-    )
-  }
-)
-
-/** @internal */
-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.Layer<A, E, R>) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
-  <A, E, R>(
-    self: Layer.Layer<A, E, R>,
-    name: string,
-    options?: Tracer.SpanOptions & {
-      readonly onEnd?:
-        | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
-        | undefined
-    }
-  ): Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
-} = function() {
-  const dataFirst = typeof arguments[0] !== "string"
-  const name = dataFirst ? arguments[1] : arguments[0]
-  const options = tracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]) as Tracer.SpanOptions & {
-    readonly onEnd?:
-      | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
-      | undefined
-  }
-  if (dataFirst) {
-    const self = arguments[0]
-    return unwrapScoped(
-      core.map(
-        options?.onEnd
-          ? core.tap(
-            fiberRuntime.makeSpanScoped(name, options),
-            (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
-          )
-          : fiberRuntime.makeSpanScoped(name, options),
-        (span) => withParentSpan(self, span)
-      )
-    )
-  }
-  return (self: Layer.Layer<any, any, any>) =>
-    unwrapScoped(
-      core.map(
-        options?.onEnd
-          ? core.tap(
-            fiberRuntime.makeSpanScoped(name, options),
-            (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
-          )
-          : fiberRuntime.makeSpanScoped(name, options),
-        (span) => withParentSpan(self, span)
-      )
-    )
-} as any
-
-/** @internal */
-export const withParentSpan = dual<
-  (
-    span: Tracer.AnySpan
-  ) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>,
-  <A, E, R>(self: Layer.Layer<A, E, R>, span: Tracer.AnySpan) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
->(2, (self, span) => provide(self, succeedContext(Context.make(tracer.spanTag, span))))
-
-// circular with Effect
-
-const provideSomeLayer = dual<
-  <A2, E2, R2>(
-    layer: Layer.Layer<A2, E2, R2>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R2 | Exclude<R, A2>>,
-  <A, E, R, A2, E2, R2>(
-    self: Effect.Effect<A, E, R>,
-    layer: Layer.Layer<A2, E2, R2>
-  ) => Effect.Effect<A, E | E2, R2 | Exclude<R, A2>>
->(2, (self, layer) =>
-  fiberRuntime.scopedWith((scope) =>
-    core.flatMap(
-      buildWithScope(layer, scope),
-      (context) => core.provideSomeContext(self, context)
-    )
-  ))
-
-const provideSomeRuntime = dual<
-  <R>(context: Runtime.Runtime<R>) => <A, E, R1>(self: Effect.Effect<A, E, R1>) => Effect.Effect<A, E, Exclude<R1, R>>,
-  <A, E, R1, R>(self: Effect.Effect<A, E, R1>, context: Runtime.Runtime<R>) => Effect.Effect<A, E, Exclude<R1, R>>
->(2, (self, rt) => {
-  const patchRefs = FiberRefsPatch.diff(runtime.defaultRuntime.fiberRefs, rt.fiberRefs)
-  const patchFlags = runtimeFlags.diff(runtime.defaultRuntime.runtimeFlags, rt.runtimeFlags)
-  return core.uninterruptibleMask((restore) =>
-    core.withFiberRuntime((fiber) => {
-      const oldContext = fiber.getFiberRef(core.currentContext)
-      const oldRefs = fiber.getFiberRefs()
-      const newRefs = FiberRefsPatch.patch(fiber.id(), oldRefs)(patchRefs)
-      const oldFlags = fiber.currentRuntimeFlags
-      const newFlags = runtimeFlags.patch(patchFlags)(oldFlags)
-      const rollbackRefs = FiberRefsPatch.diff(newRefs, oldRefs)
-      const rollbackFlags = runtimeFlags.diff(newFlags, oldFlags)
-      fiber.setFiberRefs(newRefs)
-      fiber.currentRuntimeFlags = newFlags
-      return fiberRuntime.ensuring(
-        core.provideSomeContext(restore(self), Context.merge(oldContext, rt.context)),
-        core.withFiberRuntime((fiber) => {
-          fiber.setFiberRefs(FiberRefsPatch.patch(fiber.id(), fiber.getFiberRefs())(rollbackRefs))
-          fiber.currentRuntimeFlags = runtimeFlags.patch(rollbackFlags)(fiber.currentRuntimeFlags)
-          return core.void
-        })
-      )
-    })
-  )
-})
-
-/** @internal */
-export const effect_provide = dual<
-  {
-    <const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
-      layers: Layers
-    ): <A, E, R>(
-      self: Effect.Effect<A, E, R>
-    ) => Effect.Effect<
-      A,
-      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
-      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
-      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
-    >
-    <ROut, E2, RIn>(
-      layer: Layer.Layer<ROut, E2, RIn>
-    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, RIn | Exclude<R, ROut>>
-    <R2>(
-      context: Context.Context<R2>
-    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>
-    <R2>(
-      runtime: Runtime.Runtime<R2>
-    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>
-    <E2, R2>(
-      managedRuntime: ManagedRuntime.ManagedRuntime<R2, E2>
-    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, Exclude<R, R2>>
-  },
-  {
-    <A, E, R, const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
-      self: Effect.Effect<A, E, R>,
-      layers: Layers
-    ): Effect.Effect<
-      A,
-      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
-      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
-      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
-    >
-    <A, E, R, ROut, E2, RIn>(
-      self: Effect.Effect<A, E, R>,
-      layer: Layer.Layer<ROut, E2, RIn>
-    ): Effect.Effect<A, E | E2, RIn | Exclude<R, ROut>>
-    <A, E, R, R2>(
-      self: Effect.Effect<A, E, R>,
-      context: Context.Context<R2>
-    ): Effect.Effect<A, E, Exclude<R, R2>>
-    <A, E, R, R2>(
-      self: Effect.Effect<A, E, R>,
-      runtime: Runtime.Runtime<R2>
-    ): Effect.Effect<A, E, Exclude<R, R2>>
-    <A, E, E2, R, R2>(
-      self: Effect.Effect<A, E, R>,
-      managedRuntime: ManagedRuntime.ManagedRuntime<R2, E2>
-    ): Effect.Effect<A, E | E2, Exclude<R, R2>>
-  }
->(
-  2,
-  <A, E, R, ROut>(
-    self: Effect.Effect<A, E, R>,
-    source:
-      | Layer.Layer<ROut, any, any>
-      | Context.Context<ROut>
-      | Runtime.Runtime<ROut>
-      | ManagedRuntime.ManagedRuntime<ROut, any>
-      | Array<Layer.Layer.Any>
-  ): Effect.Effect<any, any, Exclude<R, ROut>> => {
-    if (Array.isArray(source)) {
-      // @ts-expect-error
-      return provideSomeLayer(self, mergeAll(...source))
-    } else if (isLayer(source)) {
-      return provideSomeLayer(self, source as Layer.Layer<ROut, any, any>)
-    } else if (Context.isContext(source)) {
-      return core.provideSomeContext(self, source)
-    } else if (circularManagedRuntime.TypeId in source) {
-      return core.flatMap(
-        (source as ManagedRuntime.ManagedRuntime<ROut, any>).runtimeEffect,
-        (rt) => provideSomeRuntime(self, rt)
-      )
-    } else {
-      return provideSomeRuntime(self, source as Runtime.Runtime<ROut>)
-    }
-  }
-)