@depup/effect 3.20.0-depup.0

package/src/internal/core-effect.ts

@@ -0,0 +1,2293 @@
+import * as Arr from "../Array.js"
+import type * as Cause from "../Cause.js"
+import * as Chunk from "../Chunk.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 { Exit } from "../Exit.js"
+import type * as Fiber from "../Fiber.js"
+import type * as FiberId from "../FiberId.js"
+import type * as FiberRef from "../FiberRef.js"
+import * as FiberRefs from "../FiberRefs.js"
+import type * as FiberRefsPatch from "../FiberRefsPatch.js"
+import type { LazyArg } from "../Function.js"
+import { constFalse, constTrue, constVoid, dual, identity, pipe } from "../Function.js"
+import * as HashMap from "../HashMap.js"
+import * as HashSet from "../HashSet.js"
+import * as List from "../List.js"
+import * as LogLevel from "../LogLevel.js"
+import * as LogSpan from "../LogSpan.js"
+import type * as Metric from "../Metric.js"
+import type * as MetricLabel from "../MetricLabel.js"
+import * as Option from "../Option.js"
+import * as Predicate from "../Predicate.js"
+import type * as Random from "../Random.js"
+import * as Ref from "../Ref.js"
+import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
+import * as Tracer from "../Tracer.js"
+import type * as Types from "../Types.js"
+import type { Unify } from "../Unify.js"
+import { internalCall } from "../Utils.js"
+import * as internalCause from "./cause.js"
+import { clockTag } from "./clock.js"
+import * as core from "./core.js"
+import * as defaultServices from "./defaultServices.js"
+import * as doNotation from "./doNotation.js"
+import * as fiberRefsPatch from "./fiberRefs/patch.js"
+import type { FiberRuntime } from "./fiberRuntime.js"
+import * as metricLabel from "./metric/label.js"
+import * as runtimeFlags from "./runtimeFlags.js"
+import * as internalTracer from "./tracer.js"
+
+/* @internal */
+export const annotateLogs = dual<
+  {
+    (key: string, value: unknown): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+    (
+      values: Record<string, unknown>
+    ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  },
+  {
+    <A, E, R>(effect: Effect.Effect<A, E, R>, key: string, value: unknown): Effect.Effect<A, E, R>
+    <A, E, R>(effect: Effect.Effect<A, E, R>, values: Record<string, unknown>): Effect.Effect<A, E, R>
+  }
+>(
+  (args) => core.isEffect(args[0]),
+  function<A, E, R>() {
+    const args = arguments
+    return core.fiberRefLocallyWith(
+      args[0] as Effect.Effect<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
+          )
+    )
+  }
+)
+
+/* @internal */
+export const asSome = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Option.Option<A>, E, R> =>
+  core.map(self, Option.some)
+
+/* @internal */
+export const asSomeError = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Option.Option<E>, R> =>
+  core.mapError(self, Option.some)
+
+/* @internal */
+export const try_: {
+  <A, E>(options: {
+    readonly try: LazyArg<A>
+    readonly catch: (error: unknown) => E
+  }): Effect.Effect<A, E>
+  <A>(thunk: LazyArg<A>): Effect.Effect<A, Cause.UnknownException>
+} = <A, E>(
+  arg: LazyArg<A> | {
+    readonly try: LazyArg<A>
+    readonly catch: (error: unknown) => E
+  }
+) => {
+  let evaluate: LazyArg<A>
+  let onFailure: ((error: unknown) => E) | undefined = undefined
+  if (typeof arg === "function") {
+    evaluate = arg
+  } else {
+    evaluate = arg.try
+    onFailure = arg.catch
+  }
+  return core.suspend(() => {
+    try {
+      return core.succeed(internalCall(evaluate))
+    } catch (error) {
+      return core.fail(
+        onFailure
+          ? internalCall(() => onFailure(error))
+          : new core.UnknownException(error, "An unknown error occurred in Effect.try")
+      )
+    }
+  })
+}
+
+/* @internal */
+export const _catch: {
+  <N extends keyof E, K extends E[N] & string, E, A1, E1, R1>(
+    discriminator: N,
+    options: {
+      readonly failure: K
+      readonly onFailure: (error: Extract<E, { [n in N]: K }>) => Effect.Effect<A1, E1, R1>
+    }
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<
+    A | A1,
+    Exclude<E, { [n in N]: K }> | E1,
+    R | R1
+  >
+  <A, E, R, N extends keyof E, K extends E[N] & string, A1, E1, R1>(
+    self: Effect.Effect<A, E, R>,
+    discriminator: N,
+    options: {
+      readonly failure: K
+      readonly onFailure: (error: Extract<E, { [n in N]: K }>) => Effect.Effect<A1, E1, R1>
+    }
+  ): Effect.Effect<A | A1, Exclude<E, { [n in N]: K }> | E1, R | R1>
+} = dual(
+  3,
+  (self, tag, options) =>
+    core.catchAll(self, (e) => {
+      if (Predicate.hasProperty(e, tag) && e[tag] === options.failure) {
+        return options.onFailure(e)
+      }
+      return core.fail(e)
+    })
+)
+
+/* @internal */
+export const catchAllDefect = dual<
+  <A2, E2, R2>(
+    f: (defect: unknown) => Effect.Effect<A2, E2, R2>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E | E2, R | R2>,
+  <A, E, R, A2, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    f: (defect: unknown) => Effect.Effect<A2, E2, R2>
+  ) => Effect.Effect<A | A2, E | E2, R | R2>
+>(2, <A, E, R, A2, E2, R2>(
+  self: Effect.Effect<A, E, R>,
+  f: (defect: unknown) => Effect.Effect<A2, E2, R2>
+): Effect.Effect<A | A2, E | E2, R | R2> =>
+  core.catchAllCause(
+    self,
+    (cause): Effect.Effect<A | A2, E | E2, R | R2> => {
+      const option = internalCause.find(cause, (_) => internalCause.isDieType(_) ? Option.some(_) : Option.none())
+      switch (option._tag) {
+        case "None": {
+          return core.failCause(cause)
+        }
+        case "Some": {
+          return f(option.value.defect)
+        }
+      }
+    }
+  ))
+
+/* @internal */
+export const catchSomeCause: {
+  <E, A2, E2, R2>(
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A, E | E2, R2 | R>
+  <A, E, R, A2, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ): Effect.Effect<A2 | A, E | E2, R2 | R>
+} = dual(
+  2,
+  <A, E, R, A2, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ): Effect.Effect<A2 | A, E | E2, R2 | R> =>
+    core.matchCauseEffect(self, {
+      onFailure: (cause): Effect.Effect<A2, E | E2, R2> => {
+        const option = f(cause)
+        switch (option._tag) {
+          case "None": {
+            return core.failCause(cause)
+          }
+          case "Some": {
+            return option.value
+          }
+        }
+      },
+      onSuccess: core.succeed
+    })
+)
+
+/* @internal */
+export const catchSomeDefect = dual<
+  <A2, E2, R2>(
+    pf: (defect: unknown) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E | E2, R | R2>,
+  <A, E, R, A2, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    pf: (defect: unknown) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ) => Effect.Effect<A | A2, E | E2, R | R2>
+>(
+  2,
+  <A, E, R, A2, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    pf: (defect: unknown) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ): Effect.Effect<A | A2, E | E2, R | R2> =>
+    core.catchAllCause(
+      self,
+      (cause): Effect.Effect<A | A2, E | E2, R | R2> => {
+        const option = internalCause.find(cause, (_) => internalCause.isDieType(_) ? Option.some(_) : Option.none())
+        switch (option._tag) {
+          case "None": {
+            return core.failCause(cause)
+          }
+          case "Some": {
+            const optionEffect = pf(option.value.defect)
+            return optionEffect._tag === "Some" ? optionEffect.value : core.failCause(cause)
+          }
+        }
+      }
+    )
+)
+
+/* @internal */
+export const catchTag: {
+  <
+    E,
+    const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>,
+    A1,
+    E1,
+    R1
+  >(
+    ...args: [
+      ...tags: K,
+      f: (e: Extract<Types.NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>
+    ]
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
+  <
+    A,
+    E,
+    R,
+    const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>,
+    A1,
+    E1,
+    R1
+  >(
+    self: Effect.Effect<A, E, R>,
+    ...args: [
+      ...tags: K,
+      f: (e: Extract<Types.NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>
+    ]
+  ): Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
+} = dual(
+  (args: any) => core.isEffect(args[0]),
+  <A, E, R, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, R1, E1, A1>(
+    self: Effect.Effect<A, E, R>,
+    ...args: [
+      ...tags: K & { [I in keyof K]: E extends { _tag: string } ? E["_tag"] : never },
+      f: (e: Extract<Types.NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>
+    ]
+  ): Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1> => {
+    const f = args[args.length - 1] as any
+    let predicate: Predicate.Predicate<E>
+    if (args.length === 2) {
+      predicate = Predicate.isTagged(args[0] as string)
+    } else {
+      predicate = (e) => {
+        const tag = Predicate.hasProperty(e, "_tag") ? e["_tag"] : undefined
+        if (!tag) return false
+        for (let i = 0; i < args.length - 1; i++) {
+          if (args[i] === tag) return true
+        }
+        return false
+      }
+    }
+    return core.catchIf(self, predicate as Predicate.Refinement<E, Extract<E, { _tag: K[number] }>>, f) as any
+  }
+) as any
+
+/** @internal */
+export const catchTags: {
+  <
+    E,
+    Cases extends (E extends { _tag: string } ? {
+        [K in E["_tag"]]+?: (error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>
+      } :
+      {})
+  >(
+    cases: Cases
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<
+    | A
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<infer A, any, any>) ? A : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
+    }[keyof Cases],
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, any, infer R>) ? R : never
+    }[keyof Cases]
+  >
+  <
+    R,
+    E,
+    A,
+    Cases extends (E extends { _tag: string } ? {
+        [K in E["_tag"]]+?: (error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>
+      } :
+      {})
+  >(
+    self: Effect.Effect<A, E, R>,
+    cases: Cases
+  ): Effect.Effect<
+    | A
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<infer A, any, any>) ? A : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
+    }[keyof Cases],
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, any, infer R>) ? R : never
+    }[keyof Cases]
+  >
+} = dual(2, (self, cases) => {
+  let keys: Array<string>
+  return core.catchIf(
+    self,
+    (e): e is { readonly _tag: string } => {
+      keys ??= Object.keys(cases)
+      return Predicate.hasProperty(e, "_tag") && Predicate.isString(e["_tag"]) && keys.includes(e["_tag"])
+    },
+    (e) => cases[e["_tag"]](e)
+  )
+})
+
+/* @internal */
+export const cause = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Cause.Cause<E>, never, R> =>
+  core.matchCause(self, { onFailure: identity, onSuccess: () => internalCause.empty })
+
+/* @internal */
+export const clockWith: <A, E, R>(f: (clock: Clock.Clock) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
+  Clock.clockWith
+
+/* @internal */
+export const clock: Effect.Effect<Clock.Clock> = clockWith(core.succeed)
+
+/* @internal */
+export const delay = dual<
+  (duration: Duration.DurationInput) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, duration: Duration.DurationInput) => Effect.Effect<A, E, R>
+>(2, (self, duration) => core.zipRight(Clock.sleep(duration), self))
+
+/* @internal */
+export const descriptorWith = <A, E, R>(
+  f: (descriptor: Fiber.Fiber.Descriptor) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, R> =>
+  core.withFiberRuntime((state, status) =>
+    f({
+      id: state.id(),
+      status,
+      interruptors: internalCause.interruptors(state.getFiberRef(core.currentInterruptedCause))
+    })
+  ) as Effect.Effect<A, E, R>
+
+/* @internal */
+export const allowInterrupt: Effect.Effect<void> = descriptorWith(
+  (descriptor) =>
+    HashSet.size(descriptor.interruptors) > 0
+      ? core.interrupt
+      : core.void
+)
+
+/* @internal */
+export const descriptor: Effect.Effect<Fiber.Fiber.Descriptor> = descriptorWith(core.succeed)
+
+/* @internal */
+export const diffFiberRefs = <A, E, R>(
+  self: Effect.Effect<A, E, R>
+): Effect.Effect<[FiberRefsPatch.FiberRefsPatch, A], E, R> => summarized(self, fiberRefs, fiberRefsPatch.diff)
+
+/* @internal */
+export const diffFiberRefsAndRuntimeFlags = <A, E, R>(
+  self: Effect.Effect<A, E, R>
+): Effect.Effect<[[FiberRefsPatch.FiberRefsPatch, runtimeFlagsPatch.RuntimeFlagsPatch], A], E, R> =>
+  summarized(
+    self,
+    core.zip(fiberRefs, core.runtimeFlags),
+    ([refs, flags], [refsNew, flagsNew]) => [fiberRefsPatch.diff(refs, refsNew), runtimeFlags.diff(flags, flagsNew)]
+  )
+
+/* @internal */
+export const Do: Effect.Effect<{}> = core.succeed({})
+
+/* @internal */
+export const bind: {
+  <N extends string, A extends object, B, E2, R2>(
+    name: Exclude<N, keyof A>,
+    f: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): <E1, R1>(
+    self: Effect.Effect<A, E1, R1>
+  ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E1, R2 | R1>
+  <A extends object, N extends string, E1, R1, B, E2, R2>(
+    self: Effect.Effect<A, E1, R1>,
+    name: Exclude<N, keyof A>,
+    f: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E1 | E2, R1 | R2>
+} = doNotation.bind<Effect.EffectTypeLambda>(core.map, core.flatMap)
+
+/* @internal */
+export const bindTo: {
+  <N extends string>(name: N): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<{ [K in N]: A }, E, R>
+  <A, E, R, N extends string>(self: Effect.Effect<A, E, R>, name: N): Effect.Effect<{ [K in N]: A }, E, R>
+} = doNotation.bindTo<Effect.EffectTypeLambda>(core.map)
+
+/* @internal */
+export const let_: {
+  <N extends string, A extends object, B>(
+    name: Exclude<N, keyof A>,
+    f: (a: Types.NoInfer<A>) => B
+  ): <E, R>(
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
+  <A extends object, N extends string, E, R, B>(
+    self: Effect.Effect<A, E, R>,
+    name: Exclude<N, keyof A>,
+    f: (a: Types.NoInfer<A>) => B
+  ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
+} = doNotation.let_<Effect.EffectTypeLambda>(core.map)
+
+/* @internal */
+export const dropUntil: {
+  <A, E, R>(
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Array<A>, E, R>
+} = dual(
+  2,
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Array<A>, E, R> =>
+    core.suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const builder: Array<A> = []
+      let next: IteratorResult<A, any>
+      let dropping: Effect.Effect<boolean, E, R> = core.succeed(false)
+      let i = 0
+      while ((next = iterator.next()) && !next.done) {
+        const a = next.value
+        const index = i++
+        dropping = core.flatMap(dropping, (bool) => {
+          if (bool) {
+            builder.push(a)
+            return core.succeed(true)
+          }
+          return predicate(a, index)
+        })
+      }
+      return core.map(dropping, () => builder)
+    })
+)
+
+/* @internal */
+export const dropWhile: {
+  <A, E, R>(
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Array<A>, E, R>
+} = dual(
+  2,
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Array<A>, E, R> =>
+    core.suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const builder: Array<A> = []
+      let next
+      let dropping: Effect.Effect<boolean, E, R> = core.succeed(true)
+      let i = 0
+      while ((next = iterator.next()) && !next.done) {
+        const a = next.value
+        const index = i++
+        dropping = core.flatMap(dropping, (d) =>
+          core.map(d ? predicate(a, index) : core.succeed(false), (b) => {
+            if (!b) {
+              builder.push(a)
+            }
+            return b
+          }))
+      }
+      return core.map(dropping, () => builder)
+    })
+)
+
+/* @internal */
+export const contextWith = <R, A>(f: (context: Context.Context<R>) => A): Effect.Effect<A, never, R> =>
+  core.map(core.context<R>(), f)
+
+/* @internal */
+export const eventually = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, never, R> =>
+  core.orElse(self, () => core.flatMap(core.yieldNow(), () => eventually(self)))
+
+/* @internal */
+export const filterMap = dual<
+  <Eff extends Effect.Effect<any, any, any>, B>(
+    pf: (a: Effect.Effect.Success<Eff>) => Option.Option<B>
+  ) => (elements: Iterable<Eff>) => Effect.Effect<Array<B>, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>>,
+  <Eff extends Effect.Effect<any, any, any>, B>(
+    elements: Iterable<Eff>,
+    pf: (a: Effect.Effect.Success<Eff>) => Option.Option<B>
+  ) => Effect.Effect<Array<B>, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>>
+>(2, (elements, pf) =>
+  core.map(
+    core.forEachSequential(elements, identity),
+    Arr.filterMap(pf)
+  ))
+
+/* @internal */
+export const filterOrDie: {
+  <A, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    orDieWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => unknown
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
+  <A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orDieWith: (a: Types.NoInfer<A>) => unknown
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R, B extends A>(
+    self: Effect.Effect<A, E, R>,
+    refinement: Predicate.Refinement<A, B>,
+    orDieWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => unknown
+  ): Effect.Effect<B, E, R>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    orDieWith: (a: A) => unknown
+  ): Effect.Effect<A, E, R>
+} = dual(
+  3,
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    orDieWith: (a: A) => unknown
+  ): Effect.Effect<A, E, R> => filterOrElse(self, predicate, (a) => core.dieSync(() => orDieWith(a)))
+)
+
+/* @internal */
+export const filterOrDieMessage: {
+  <A, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    message: string
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
+  <A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    message: string
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R, B extends A>(
+    self: Effect.Effect<A, E, R>,
+    refinement: Predicate.Refinement<A, B>,
+    message: string
+  ): Effect.Effect<B, E, R>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    message: string
+  ): Effect.Effect<A, E, R>
+} = dual(
+  3,
+  <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<A>, message: string): Effect.Effect<A, E, R> =>
+    filterOrElse(self, predicate, () => core.dieMessage(message))
+)
+
+/* @internal */
+export const filterOrElse: {
+  <A, C, E2, R2, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    orElse: (a: Types.EqualsWith<A, B, Types.NoInfer<A>, Exclude<Types.NoInfer<A>, B>>) => Effect.Effect<C, E2, R2>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
+  <A, C, E2, R2>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orElse: (a: Types.NoInfer<A>) => Effect.Effect<C, E2, R2>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | C, E2 | E, R2 | R>
+  <A, E, R, C, E2, R2, B extends A>(
+    self: Effect.Effect<A, E, R>,
+    refinement: Predicate.Refinement<A, B>,
+    orElse: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<B | C, E | E2, R | R2>
+  <A, E, R, C, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    orElse: (a: A) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<A | C, E | E2, R | R2>
+} = dual(3, <A, E, R, B, E2, R2>(
+  self: Effect.Effect<A, E, R>,
+  predicate: Predicate.Predicate<A>,
+  orElse: (a: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<A | B, E | E2, R | R2> =>
+  core.flatMap(
+    self,
+    (a) => predicate(a) ? core.succeed<A | B>(a) : orElse(a)
+  ))
+
+/** @internal */
+export const liftPredicate = dual<
+  <T extends A, E, B extends T = T, A = T>(
+    predicate: Predicate.Refinement<T, B> | Predicate.Predicate<T>,
+    orFailWith: (a: Types.EqualsWith<T, B, A, Exclude<A, B>>) => E
+  ) => (a: A) => Effect.Effect<Types.EqualsWith<T, B, A, B>, E>,
+  <A, E, B extends A = A>(
+    self: A,
+    predicate: Predicate.Refinement<A, B> | Predicate.Predicate<A>,
+    orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E
+  ) => Effect.Effect<B, E>
+>(
+  3,
+  <A, E, B extends A = A>(
+    self: A,
+    predicate: Predicate.Refinement<A, B> | Predicate.Predicate<A>,
+    orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E
+  ): Effect.Effect<B, E> =>
+    core.suspend(() => predicate(self) ? core.succeed(self as B) : core.fail(orFailWith(self as any)))
+)
+
+/* @internal */
+export const filterOrFail: {
+  <A, E2, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    orFailWith: (a: Types.EqualsWith<A, B, Types.NoInfer<A>, Exclude<Types.NoInfer<A>, B>>) => E2
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Types.NoInfer<B>, E2 | E, R>
+  <A, E2>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orFailWith: (a: Types.NoInfer<A>) => E2
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2 | E, R>
+  <A, E, R, E2, B extends A>(
+    self: Effect.Effect<A, E, R>,
+    refinement: Predicate.Refinement<A, B>,
+    orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E2
+  ): Effect.Effect<Types.NoInfer<B>, E2 | E, R>
+  <A, E, R, E2>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    orFailWith: (a: A) => E2
+  ): Effect.Effect<A, E2 | E, R>
+  <A, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Types.NoInfer<B>, Cause.NoSuchElementException | E, R>
+  <A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Cause.NoSuchElementException | E, R>
+  <A, E, R, B extends A>(
+    self: Effect.Effect<A, E, R>,
+    refinement: Predicate.Refinement<A, B>
+  ): Effect.Effect<Types.NoInfer<B>, E | Cause.NoSuchElementException, R>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>
+  ): Effect.Effect<A, E | Cause.NoSuchElementException, R>
+} = dual((args) => core.isEffect(args[0]), <A, E, R, E2>(
+  self: Effect.Effect<A, E, R>,
+  predicate: Predicate.Predicate<A>,
+  orFailWith?: (a: A) => E2
+): Effect.Effect<A, E | E2 | Cause.NoSuchElementException, R> =>
+  filterOrElse(
+    self,
+    predicate,
+    (a): Effect.Effect<never, E2 | Cause.NoSuchElementException, never> =>
+      orFailWith === undefined ? core.fail(new core.NoSuchElementException()) : core.failSync(() => orFailWith(a))
+  ))
+
+/* @internal */
+export const findFirst: {
+  <A, E, R>(
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): (elements: Iterable<A>) => Effect.Effect<Option.Option<A>, E, R>
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Option.Option<A>, E, R>
+} = dual(
+  2,
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Option.Option<A>, E, R> =>
+    core.suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const next = iterator.next()
+      if (!next.done) {
+        return findLoop(iterator, 0, predicate, next.value)
+      }
+      return core.succeed(Option.none())
+    })
+)
+
+const findLoop = <A, E, R>(
+  iterator: Iterator<A>,
+  index: number,
+  f: (a: A, i: number) => Effect.Effect<boolean, E, R>,
+  value: A
+): Effect.Effect<Option.Option<A>, E, R> =>
+  core.flatMap(f(value, index), (result) => {
+    if (result) {
+      return core.succeed(Option.some(value))
+    }
+    const next = iterator.next()
+    if (!next.done) {
+      return findLoop(iterator, index + 1, f, next.value)
+    }
+    return core.succeed(Option.none())
+  })
+
+/* @internal */
+export const firstSuccessOf = <Eff extends Effect.Effect<any, any, any>>(
+  effects: Iterable<Eff>
+): Effect.Effect<Effect.Effect.Success<Eff>, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>> =>
+  core.suspend(() => {
+    const list = Chunk.fromIterable(effects)
+    if (!Chunk.isNonEmpty(list)) {
+      return core.dieSync(() => new core.IllegalArgumentException(`Received an empty collection of effects`))
+    }
+    return pipe(
+      Chunk.tailNonEmpty(list),
+      Arr.reduce(Chunk.headNonEmpty(list), (left, right) => core.orElse(left, () => right) as Eff)
+    )
+  })
+
+/* @internal */
+export const flipWith: {
+  <E, A, R, E2, A2, R2>(
+    f: (effect: Effect.Effect<E, A, R>) => Effect.Effect<E2, A2, R2>
+  ): (self: Effect.Effect<A, E, R>) => Effect.Effect<A2, E2, R2>
+  <A, E, R, E2, A2, R2>(
+    self: Effect.Effect<A, E, R>,
+    f: (effect: Effect.Effect<E, A, R>) => Effect.Effect<E2, A2, R2>
+  ): Effect.Effect<A2, E2, R2>
+} = dual(2, <A, E, R, E2, A2, R2>(
+  self: Effect.Effect<A, E, R>,
+  f: (effect: Effect.Effect<E, A, R>) => Effect.Effect<E2, A2, R2>
+): Effect.Effect<A2, E2, R2> => core.flip(f(core.flip(self))))
+
+/* @internal */
+export const match: {
+  <E, A2, A, A3>(
+    options: {
+      readonly onFailure: (error: E) => A2
+      readonly onSuccess: (value: A) => A3
+    }
+  ): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A3, never, R>
+  <A, E, R, A2, A3>(
+    self: Effect.Effect<A, E, R>,
+    options: {
+      readonly onFailure: (error: E) => A2
+      readonly onSuccess: (value: A) => A3
+    }
+  ): Effect.Effect<A2 | A3, never, R>
+} = dual(2, <A, E, R, A2, A3>(
+  self: Effect.Effect<A, E, R>,
+  options: {
+    readonly onFailure: (error: E) => A2
+    readonly onSuccess: (value: A) => A3
+  }
+): Effect.Effect<A2 | A3, never, R> =>
+  core.matchEffect(self, {
+    onFailure: (e) => core.succeed(options.onFailure(e)),
+    onSuccess: (a) => core.succeed(options.onSuccess(a))
+  }))
+
+/* @internal */
+export const every: {
+  <A, E, R>(
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): (elements: Iterable<A>) => Effect.Effect<boolean, E, R>
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<boolean, E, R>
+} = dual(
+  2,
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<boolean, E, R> => core.suspend(() => forAllLoop(elements[Symbol.iterator](), 0, predicate))
+)
+
+const forAllLoop = <A, E, R>(
+  iterator: Iterator<A>,
+  index: number,
+  f: (a: A, i: number) => Effect.Effect<boolean, E, R>
+): Effect.Effect<boolean, E, R> => {
+  const next = iterator.next()
+  return next.done
+    ? core.succeed(true)
+    : core.flatMap(
+      f(next.value, index),
+      (b) => b ? forAllLoop(iterator, index + 1, f) : core.succeed(b)
+    )
+}
+
+/* @internal */
+export const forever = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<never, E, R> => {
+  const loop: Effect.Effect<never, E, R> = core.flatMap(core.flatMap(self, () => core.yieldNow()), () => loop)
+  return loop
+}
+
+/* @internal */
+export const fiberRefs: Effect.Effect<FiberRefs.FiberRefs> = core.withFiberRuntime((state) =>
+  core.succeed(state.getFiberRefs())
+)
+
+/* @internal */
+export const head = <A, E, R>(
+  self: Effect.Effect<Iterable<A>, E, R>
+): Effect.Effect<A, E | Cause.NoSuchElementException, R> =>
+  core.flatMap(self, (as) => {
+    const iterator = as[Symbol.iterator]()
+    const next = iterator.next()
+    if (next.done) {
+      return core.fail(new core.NoSuchElementException())
+    }
+    return core.succeed(next.value)
+  })
+
+/* @internal */
+export const ignore = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, never, R> =>
+  match(self, { onFailure: constVoid, onSuccess: constVoid })
+
+/* @internal */
+export const ignoreLogged = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, never, R> =>
+  core.matchCauseEffect(self, {
+    onFailure: (cause) => logDebug(cause, "An error was silently ignored because it is not anticipated to be useful"),
+    onSuccess: () => core.void
+  })
+
+/* @internal */
+export const inheritFiberRefs = (childFiberRefs: FiberRefs.FiberRefs) =>
+  updateFiberRefs((parentFiberId, parentFiberRefs) => FiberRefs.joinAs(parentFiberRefs, parentFiberId, childFiberRefs))
+
+/* @internal */
+export const isFailure = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<boolean, never, R> =>
+  match(self, { onFailure: constTrue, onSuccess: constFalse })
+
+/* @internal */
+export const isSuccess = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<boolean, never, R> =>
+  match(self, { onFailure: constFalse, onSuccess: constTrue })
+
+/* @internal */
+export const iterate: {
+  <A, B extends A, R, E>(
+    initial: A,
+    options: {
+      readonly while: Predicate.Refinement<A, B>
+      readonly body: (b: B) => Effect.Effect<A, E, R>
+    }
+  ): Effect.Effect<A, E, R>
+  <A, R, E>(
+    initial: A,
+    options: {
+      readonly while: Predicate.Predicate<A>
+      readonly body: (a: A) => Effect.Effect<A, E, R>
+    }
+  ): Effect.Effect<A, E, R>
+} = <A, E, R>(
+  initial: A,
+  options: {
+    readonly while: Predicate.Predicate<A>
+    readonly body: (z: A) => Effect.Effect<A, E, R>
+  }
+): Effect.Effect<A, E, R> =>
+  core.suspend<A, E, R>(() => {
+    if (options.while(initial)) {
+      return core.flatMap(options.body(initial), (z2) => iterate(z2, options))
+    }
+    return core.succeed(initial)
+  })
+
+/** @internal */
+export const logWithLevel = (level?: LogLevel.LogLevel) =>
+(
+  ...message: ReadonlyArray<any>
+): Effect.Effect<void> => {
+  const levelOption = Option.fromNullable(level)
+  let cause: Cause.Cause<unknown> | undefined = undefined
+  for (let i = 0, len = message.length; i < len; i++) {
+    const msg = message[i]
+    if (internalCause.isCause(msg)) {
+      if (cause !== undefined) {
+        cause = internalCause.sequential(cause, msg)
+      } else {
+        cause = msg
+      }
+      message = [...message.slice(0, i), ...message.slice(i + 1)]
+      i--
+    }
+  }
+  if (cause === undefined) {
+    cause = internalCause.empty
+  }
+  return core.withFiberRuntime((fiberState) => {
+    fiberState.log(message, cause, levelOption)
+    return core.void
+  })
+}
+
+/** @internal */
+export const log: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel()
+
+/** @internal */
+export const logTrace: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Trace
+)
+
+/** @internal */
+export const logDebug: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Debug
+)
+
+/** @internal */
+export const logInfo: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Info
+)
+
+/** @internal */
+export const logWarning: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Warning
+)
+
+/** @internal */
+export const logError: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Error
+)
+
+/** @internal */
+export const logFatal: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Fatal
+)
+
+/* @internal */
+export const withLogSpan = dual<
+  (label: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, label: string) => Effect.Effect<A, E, R>
+>(2, (effect, label) =>
+  core.flatMap(Clock.currentTimeMillis, (now) =>
+    core.fiberRefLocallyWith(
+      effect,
+      core.currentLogSpan,
+      List.prepend(LogSpan.make(label, now))
+    )))
+
+/* @internal */
+export const logAnnotations: Effect.Effect<HashMap.HashMap<string, unknown>> = core
+  .fiberRefGet(
+    core.currentLogAnnotations
+  )
+
+/* @internal */
+export const loop: {
+  <A, B extends A, C, E, R>(
+    initial: A,
+    options: {
+      readonly while: Predicate.Refinement<A, B>
+      readonly step: (b: B) => A
+      readonly body: (b: B) => Effect.Effect<C, E, R>
+      readonly discard?: false | undefined
+    }
+  ): Effect.Effect<Array<C>, E, R>
+  <A, C, E, R>(
+    initial: A,
+    options: {
+      readonly while: (a: A) => boolean
+      readonly step: (a: A) => A
+      readonly body: (a: A) => Effect.Effect<C, E, R>
+      readonly discard?: false | undefined
+    }
+  ): Effect.Effect<Array<C>, E, R>
+  <A, B extends A, C, E, R>(
+    initial: A,
+    options: {
+      readonly while: Predicate.Refinement<A, B>
+      readonly step: (b: B) => A
+      readonly body: (b: B) => Effect.Effect<R, E, C>
+      readonly discard: true
+    }
+  ): Effect.Effect<void, E, R>
+  <A, C, E, R>(
+    initial: A,
+    options: {
+      readonly while: (a: A) => boolean
+      readonly step: (a: A) => A
+      readonly body: (a: A) => Effect.Effect<C, E, R>
+      readonly discard: true
+    }
+  ): Effect.Effect<void, E, R>
+} = <A, C, E, R>(
+  initial: A,
+  options: {
+    readonly while: Predicate.Predicate<A>
+    readonly step: (a: A) => A
+    readonly body: (a: A) => Effect.Effect<C, E, R>
+    readonly discard?: boolean | undefined
+  }
+): any =>
+  options.discard
+    ? loopDiscard(initial, options.while, options.step, options.body)
+    : core.map(loopInternal(initial, options.while, options.step, options.body), Arr.fromIterable)
+
+const loopInternal = <Z, A, E, R>(
+  initial: Z,
+  cont: Predicate.Predicate<Z>,
+  inc: (z: Z) => Z,
+  body: (z: Z) => Effect.Effect<A, E, R>
+): Effect.Effect<List.List<A>, E, R> =>
+  core.suspend(() =>
+    cont(initial)
+      ? core.flatMap(body(initial), (a) =>
+        core.map(
+          loopInternal(inc(initial), cont, inc, body),
+          List.prepend(a)
+        ))
+      : core.sync(() => List.empty())
+  )
+
+const loopDiscard = <S, X, E, R>(
+  initial: S,
+  cont: Predicate.Predicate<S>,
+  inc: (s: S) => S,
+  body: (s: S) => Effect.Effect<X, E, R>
+): Effect.Effect<void, E, R> =>
+  core.suspend(() =>
+    cont(initial)
+      ? core.flatMap(
+        body(initial),
+        () => loopDiscard(inc(initial), cont, inc, body)
+      )
+      : core.void
+  )
+
+/* @internal */
+export const mapAccum: {
+  <S, A, B, E, R, I extends Iterable<A> = Iterable<A>>(
+    initial: S,
+    f: (state: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
+  ): (elements: I) => Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
+  <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
+    elements: I,
+    initial: S,
+    f: (state: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
+  ): Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
+} = dual(3, <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
+  elements: I,
+  initial: S,
+  f: (state: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
+): Effect.Effect<[S, Array<B>], E, R> =>
+  core.suspend(() => {
+    const iterator = elements[Symbol.iterator]()
+    const builder: Array<B> = []
+    let result: Effect.Effect<S, E, R> = core.succeed(initial)
+    let next: IteratorResult<A, any>
+    let i = 0
+    while (!(next = iterator.next()).done) {
+      const index = i++
+      const value = next.value
+      result = core.flatMap(result, (state) =>
+        core.map(f(state, value, index), ([z, b]) => {
+          builder.push(b)
+          return z
+        }))
+    }
+    return core.map(result, (z) => [z, builder])
+  }))
+
+/* @internal */
+export const mapErrorCause: {
+  <E, E2>(
+    f: (cause: Cause.Cause<E>) => Cause.Cause<E2>
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2, R>
+  <A, E, R, E2>(self: Effect.Effect<A, E, R>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Effect.Effect<A, E2, R>
+} = dual(
+  2,
+  <A, E, R, E2>(self: Effect.Effect<A, E, R>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Effect.Effect<A, E2, R> =>
+    core.matchCauseEffect(self, {
+      onFailure: (c) => core.failCauseSync(() => f(c)),
+      onSuccess: core.succeed
+    })
+)
+
+/* @internal */
+export const memoize = <A, E, R>(
+  self: Effect.Effect<A, E, R>
+): Effect.Effect<Effect.Effect<A, E, R>> =>
+  pipe(
+    core.deferredMake<[[FiberRefsPatch.FiberRefsPatch, runtimeFlagsPatch.RuntimeFlagsPatch], A], E>(),
+    core.flatMap((deferred) =>
+      pipe(
+        diffFiberRefsAndRuntimeFlags(self),
+        core.intoDeferred(deferred),
+        once,
+        core.map((complete) =>
+          core.zipRight(
+            complete,
+            pipe(
+              core.deferredAwait(deferred),
+              core.flatMap(([patch, a]) =>
+                core.as(core.zip(patchFiberRefs(patch[0]), core.updateRuntimeFlags(patch[1])), a)
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+/* @internal */
+export const merge = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<E | A, never, R> =>
+  core.matchEffect(self, {
+    onFailure: (e) => core.succeed(e),
+    onSuccess: core.succeed
+  })
+
+/* @internal */
+export const negate = <E, R>(self: Effect.Effect<boolean, E, R>): Effect.Effect<boolean, E, R> =>
+  core.map(self, (b) => !b)
+
+/* @internal */
+export const none = <A, E, R>(
+  self: Effect.Effect<Option.Option<A>, E, R>
+): Effect.Effect<void, E | Cause.NoSuchElementException, R> =>
+  core.flatMap(self, (option) => {
+    switch (option._tag) {
+      case "None":
+        return core.void
+      case "Some":
+        return core.fail(new core.NoSuchElementException())
+    }
+  })
+
+/* @internal */
+export const once = <A, E, R>(
+  self: Effect.Effect<A, E, R>
+): Effect.Effect<Effect.Effect<void, E, R>> =>
+  core.map(
+    Ref.make(true),
+    (ref) => core.asVoid(core.whenEffect(self, Ref.getAndSet(ref, false)))
+  )
+
+/* @internal */
+export const option = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Option.Option<A>, never, R> =>
+  core.matchEffect(self, {
+    onFailure: () => core.succeed(Option.none()),
+    onSuccess: (a) => core.succeed(Option.some(a))
+  })
+
+/* @internal */
+export const orElseFail = dual<
+  <E2>(evaluate: LazyArg<E2>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2, R>,
+  <A, E, R, E2>(self: Effect.Effect<A, E, R>, evaluate: LazyArg<E2>) => Effect.Effect<A, E2, R>
+>(2, (self, evaluate) => core.orElse(self, () => core.failSync(evaluate)))
+
+/* @internal */
+export const orElseSucceed = dual<
+  <A2>(evaluate: LazyArg<A2>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, never, R>,
+  <A, E, R, A2>(self: Effect.Effect<A, E, R>, evaluate: LazyArg<A2>) => Effect.Effect<A | A2, never, R>
+>(2, (self, evaluate) => core.orElse(self, () => core.sync(evaluate)))
+
+/* @internal */
+export const parallelErrors = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Array<E>, R> =>
+  core.matchCauseEffect(self, {
+    onFailure: (cause) => {
+      const errors = Arr.fromIterable(internalCause.failures(cause))
+      return errors.length === 0
+        ? core.failCause(cause as Cause.Cause<never>)
+        : core.fail(errors)
+    },
+    onSuccess: core.succeed
+  })
+
+/* @internal */
+export const patchFiberRefs = (patch: FiberRefsPatch.FiberRefsPatch): Effect.Effect<void> =>
+  updateFiberRefs((fiberId, fiberRefs) => pipe(patch, fiberRefsPatch.patch(fiberId, fiberRefs)))
+
+/* @internal */
+export const promise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A> =>
+  evaluate.length >= 1
+    ? core.async((resolve, signal) => {
+      try {
+        evaluate(signal)
+          .then((a) => resolve(core.succeed(a)), (e) => resolve(core.die(e)))
+      } catch (e) {
+        resolve(core.die(e))
+      }
+    })
+    : core.async((resolve) => {
+      try {
+        ;(evaluate as LazyArg<PromiseLike<A>>)()
+          .then((a) => resolve(core.succeed(a)), (e) => resolve(core.die(e)))
+      } catch (e) {
+        resolve(core.die(e))
+      }
+    })
+
+/* @internal */
+export const provideService = dual<
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, I>>,
+  <A, E, R, I, S>(
+    self: Effect.Effect<A, E, R>,
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ) => Effect.Effect<A, E, Exclude<R, I>>
+>(
+  3,
+  <A, E, R, I, S>(
+    self: Effect.Effect<A, E, R>,
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ): Effect.Effect<A, E, Exclude<R, I>> =>
+    core.contextWithEffect((env) =>
+      core.provideContext(
+        self as Effect.Effect<A, E, I | Exclude<R, I>>,
+        Context.add(env, tag, service)
+      )
+    )
+)
+
+/* @internal */
+export const provideServiceEffect = dual<
+  <I, S, E1, R1>(
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<Types.NoInfer<S>, E1, R1>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E1, R1 | Exclude<R, I>>,
+  <A, E, R, I, S, E1, R1>(
+    self: Effect.Effect<A, E, R>,
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<Types.NoInfer<S>, E1, R1>
+  ) => Effect.Effect<A, E | E1, R1 | Exclude<R, I>>
+>(3, <A, E, R, I, S, E1, R1>(
+  self: Effect.Effect<A, E, R>,
+  tag: Context.Tag<I, S>,
+  effect: Effect.Effect<Types.NoInfer<S>, E1, R1>
+) =>
+  core.contextWithEffect((env: Context.Context<R1 | Exclude<R, I>>) =>
+    core.flatMap(
+      effect,
+      (service) => core.provideContext(self, pipe(env, Context.add(tag, service)) as Context.Context<R | R1>)
+    )
+  ))
+
+/* @internal */
+export const random: Effect.Effect<Random.Random> = defaultServices.randomWith(core.succeed)
+
+/* @internal */
+export const reduce = dual<
+  <Z, A, E, R>(
+    zero: Z,
+    f: (z: Z, a: A, i: number) => Effect.Effect<Z, E, R>
+  ) => (elements: Iterable<A>) => Effect.Effect<Z, E, R>,
+  <A, Z, E, R>(
+    elements: Iterable<A>,
+    zero: Z,
+    f: (z: Z, a: A, i: number) => Effect.Effect<Z, E, R>
+  ) => Effect.Effect<Z, E, R>
+>(
+  3,
+  <A, Z, E, R>(
+    elements: Iterable<A>,
+    zero: Z,
+    f: (z: Z, a: A, i: number) => Effect.Effect<Z, E, R>
+  ) =>
+    Arr.fromIterable(elements).reduce(
+      (acc, el, i) => core.flatMap(acc, (a) => f(a, el, i)),
+      core.succeed(zero) as Effect.Effect<Z, E, R>
+    )
+)
+
+/* @internal */
+export const reduceRight = dual<
+  <A, Z, R, E>(
+    zero: Z,
+    f: (a: A, z: Z, i: number) => Effect.Effect<Z, E, R>
+  ) => (elements: Iterable<A>) => Effect.Effect<Z, E, R>,
+  <A, Z, R, E>(
+    elements: Iterable<A>,
+    zero: Z,
+    f: (a: A, z: Z, i: number) => Effect.Effect<Z, E, R>
+  ) => Effect.Effect<Z, E, R>
+>(
+  3,
+  <A, Z, R, E>(elements: Iterable<A>, zero: Z, f: (a: A, z: Z, i: number) => Effect.Effect<Z, E, R>) =>
+    Arr.fromIterable(elements).reduceRight(
+      (acc, el, i) => core.flatMap(acc, (a) => f(el, a, i)),
+      core.succeed(zero) as Effect.Effect<Z, E, R>
+    )
+)
+
+/* @internal */
+export const reduceWhile = dual<
+  <Z, A, E, R>(
+    zero: Z,
+    options: {
+      readonly while: Predicate.Predicate<Z>
+      readonly body: (s: Z, a: A, i: number) => Effect.Effect<Z, E, R>
+    }
+  ) => (elements: Iterable<A>) => Effect.Effect<Z, E, R>,
+  <A, Z, E, R>(
+    elements: Iterable<A>,
+    zero: Z,
+    options: {
+      readonly while: Predicate.Predicate<Z>
+      readonly body: (s: Z, a: A, i: number) => Effect.Effect<Z, E, R>
+    }
+  ) => Effect.Effect<Z, E, R>
+>(3, <A, Z, E, R>(
+  elements: Iterable<A>,
+  zero: Z,
+  options: {
+    readonly while: Predicate.Predicate<Z>
+    readonly body: (s: Z, a: A, i: number) => Effect.Effect<Z, E, R>
+  }
+) =>
+  core.flatMap(
+    core.sync(() => elements[Symbol.iterator]()),
+    (iterator) => reduceWhileLoop(iterator, 0, zero, options.while, options.body)
+  ))
+
+const reduceWhileLoop = <A, R, E, Z>(
+  iterator: Iterator<A>,
+  index: number,
+  state: Z,
+  predicate: Predicate.Predicate<Z>,
+  f: (s: Z, a: A, i: number) => Effect.Effect<Z, E, R>
+): Effect.Effect<Z, E, R> => {
+  const next = iterator.next()
+  if (!next.done && predicate(state)) {
+    return core.flatMap(
+      f(state, next.value, index),
+      (nextState) => reduceWhileLoop(iterator, index + 1, nextState, predicate, f)
+    )
+  }
+  return core.succeed(state)
+}
+
+/* @internal */
+export const repeatN = dual<
+  (n: number) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, n: number) => Effect.Effect<A, E, R>
+>(2, (self, n) => core.suspend(() => repeatNLoop(self, n)))
+
+/* @internal */
+const repeatNLoop = <A, E, R>(self: Effect.Effect<A, E, R>, n: number): Effect.Effect<A, E, R> =>
+  core.flatMap(self, (a) =>
+    n <= 0
+      ? core.succeed(a)
+      : core.zipRight(core.yieldNow(), repeatNLoop(self, n - 1)))
+
+/* @internal */
+export const sandbox = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Cause.Cause<E>, R> =>
+  core.matchCauseEffect(self, {
+    onFailure: core.fail,
+    onSuccess: core.succeed
+  })
+
+/* @internal */
+export const setFiberRefs = (fiberRefs: FiberRefs.FiberRefs): Effect.Effect<void> =>
+  core.suspend(() => FiberRefs.setAll(fiberRefs))
+
+/* @internal */
+export const sleep: (duration: Duration.DurationInput) => Effect.Effect<void> = Clock.sleep
+
+/* @internal */
+export const succeedNone: Effect.Effect<Option.Option<never>> = core.succeed(Option.none())
+
+/* @internal */
+export const succeedSome = <A>(value: A): Effect.Effect<Option.Option<A>> => core.succeed(Option.some(value))
+
+/* @internal */
+export const summarized: {
+  <B, E2, R2, C>(
+    summary: Effect.Effect<B, E2, R2>,
+    f: (start: B, end: B) => C
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<[C, A], E2 | E, R2 | R>
+  <A, E, R, B, E2, R2, C>(
+    self: Effect.Effect<A, E, R>,
+    summary: Effect.Effect<B, E2, R2>,
+    f: (start: B, end: B) => C
+  ): Effect.Effect<[C, A], E2 | E, R2 | R>
+} = dual(
+  3,
+  <A, E, R, B, E2, R2, C>(
+    self: Effect.Effect<A, E, R>,
+    summary: Effect.Effect<B, E2, R2>,
+    f: (start: B, end: B) => C
+  ): Effect.Effect<[C, A], E2 | E, R2 | R> =>
+    core.flatMap(
+      summary,
+      (start) => core.flatMap(self, (value) => core.map(summary, (end) => [f(start, end), value]))
+    )
+)
+
+/* @internal */
+export const tagMetrics = dual<
+  {
+    (key: string, value: string): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+    (
+      values: Record<string, string>
+    ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  },
+  {
+    <A, E, R>(effect: Effect.Effect<A, E, R>, key: string, value: string): Effect.Effect<A, E, R>
+    <A, E, R>(effect: Effect.Effect<A, E, R>, values: Record<string, string>): Effect.Effect<A, E, R>
+  }
+>((args) => core.isEffect(args[0]), function() {
+  return labelMetrics(
+    arguments[0],
+    typeof arguments[1] === "string"
+      ? [metricLabel.make(arguments[1], arguments[2])]
+      : Object.entries<string>(arguments[1]).map(([k, v]) => metricLabel.make(k, v))
+  )
+})
+
+/* @internal */
+export const labelMetrics = dual<
+  (labels: Iterable<MetricLabel.MetricLabel>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, labels: Iterable<MetricLabel.MetricLabel>) => Effect.Effect<A, E, R>
+>(
+  2,
+  (self, labels) => core.fiberRefLocallyWith(self, core.currentMetricLabels, (old) => Arr.union(old, labels))
+)
+
+/* @internal */
+export const takeUntil: {
+  <A, R, E>(
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Array<A>, E, R>
+} = dual(
+  2,
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Array<A>, E, R> =>
+    core.suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const builder: Array<A> = []
+      let next: IteratorResult<A, any>
+      let effect: Effect.Effect<boolean, E, R> = core.succeed(false)
+      let i = 0
+      while ((next = iterator.next()) && !next.done) {
+        const a = next.value
+        const index = i++
+        effect = core.flatMap(effect, (bool) => {
+          if (bool) {
+            return core.succeed(true)
+          }
+          builder.push(a)
+          return predicate(a, index)
+        })
+      }
+      return core.map(effect, () => builder)
+    })
+)
+
+/* @internal */
+export const takeWhile = dual<
+  <A, E, R>(
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ) => (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>,
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ) => Effect.Effect<Array<A>, E, R>
+>(
+  2,
+  <A, E, R>(elements: Iterable<A>, predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>) =>
+    core.suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const builder: Array<A> = []
+      let next: IteratorResult<A, any>
+      let taking: Effect.Effect<boolean, E, R> = core.succeed(true)
+      let i = 0
+      while ((next = iterator.next()) && !next.done) {
+        const a = next.value
+        const index = i++
+        taking = core.flatMap(taking, (taking) =>
+          pipe(
+            taking ? predicate(a, index) : core.succeed(false),
+            core.map((bool) => {
+              if (bool) {
+                builder.push(a)
+              }
+              return bool
+            })
+          ))
+      }
+      return core.map(taking, () => builder)
+    })
+)
+
+/* @internal */
+export const tapBoth = dual<
+  <E, X, E2, R2, A, X1, E3, R3>(
+    options: {
+      readonly onFailure: (e: Types.NoInfer<E>) => Effect.Effect<X, E2, R2>
+      readonly onSuccess: (a: Types.NoInfer<A>) => Effect.Effect<X1, E3, R3>
+    }
+  ) => <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2 | E3, R | R2 | R3>,
+  <A, E, R, X, E2, R2, X1, E3, R3>(
+    self: Effect.Effect<A, E, R>,
+    options: {
+      readonly onFailure: (e: E) => Effect.Effect<X, E2, R2>
+      readonly onSuccess: (a: A) => Effect.Effect<X1, E3, R3>
+    }
+  ) => Effect.Effect<A, E | E2 | E3, R | R2 | R3>
+>(2, (self, { onFailure, onSuccess }) =>
+  core.matchCauseEffect(self, {
+    onFailure: (cause) => {
+      const either = internalCause.failureOrCause(cause)
+      switch (either._tag) {
+        case "Left": {
+          return core.zipRight(onFailure(either.left as any), core.failCause(cause))
+        }
+        case "Right": {
+          return core.failCause(cause)
+        }
+      }
+    },
+    onSuccess: (a) => core.as(onSuccess(a as any), a)
+  }))
+
+/* @internal */
+export const tapDefect = dual<
+  <X, E2, R2>(
+    f: (cause: Cause.Cause<never>) => Effect.Effect<X, E2, R2>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>,
+  <A, E, R, X, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    f: (cause: Cause.Cause<never>) => Effect.Effect<X, E2, R2>
+  ) => Effect.Effect<A, E | E2, R | R2>
+>(2, (self, f) =>
+  core.catchAllCause(self, (cause) =>
+    Option.match(internalCause.keepDefects(cause), {
+      onNone: () => core.failCause(cause),
+      onSome: (a) => core.zipRight(f(a), core.failCause(cause))
+    })))
+
+/* @internal */
+export const tapError = dual<
+  <E, X, E2, R2>(
+    f: (e: Types.NoInfer<E>) => Effect.Effect<X, E2, R2>
+  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>,
+  <A, E, R, X, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    f: (e: E) => Effect.Effect<X, E2, R2>
+  ) => Effect.Effect<A, E | E2, R | R2>
+>(2, (self, f) =>
+  core.matchCauseEffect(self, {
+    onFailure: (cause) => {
+      const either = internalCause.failureOrCause(cause)
+      switch (either._tag) {
+        case "Left":
+          return core.zipRight(f(either.left as any), core.failCause(cause))
+        case "Right":
+          return core.failCause(cause)
+      }
+    },
+    onSuccess: core.succeed
+  }))
+
+/* @internal */
+export const tapErrorTag = dual<
+  <K extends (E extends { _tag: string } ? E["_tag"] : never), E, A1, E1, R1>(
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
+  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E1, R | R1>,
+  <A, E, R, K extends (E extends { _tag: string } ? E["_tag"] : never), A1, E1, R1>(
+    self: Effect.Effect<A, E, R>,
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
+  ) => Effect.Effect<A, E | E1, R | R1>
+>(3, (self, k, f) =>
+  tapError(self, (e) => {
+    if (Predicate.isTagged(e, k)) {
+      return f(e as any)
+    }
+    return core.void as any
+  }))
+
+/* @internal */
+export const tapErrorCause = dual<
+  <E, X, E2, R2>(
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Effect.Effect<X, E2, R2>
+  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>,
+  <A, E, R, X, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<X, E2, R2>
+  ) => Effect.Effect<A, E | E2, R | R2>
+>(2, (self, f) =>
+  core.matchCauseEffect(self, {
+    onFailure: (cause) => core.zipRight(f(cause), core.failCause(cause)),
+    onSuccess: core.succeed
+  }))
+
+/* @internal */
+export const timed = <A, E, R>(
+  self: Effect.Effect<A, E, R>
+): Effect.Effect<[duration: Duration.Duration, result: A], E, R> => timedWith(self, Clock.currentTimeNanos)
+
+/* @internal */
+export const timedWith = dual<
+  <E1, R1>(
+    nanoseconds: Effect.Effect<bigint, E1, R1>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<[Duration.Duration, A], E | E1, R | R1>,
+  <A, E, R, E1, R1>(
+    self: Effect.Effect<A, E, R>,
+    nanoseconds: Effect.Effect<bigint, E1, R1>
+  ) => Effect.Effect<[Duration.Duration, A], E | E1, R | R1>
+>(
+  2,
+  (self, nanos) => summarized(self, nanos, (start, end) => Duration.nanos(end - start))
+)
+
+/* @internal */
+export const tracerWith: <A, E, R>(f: (tracer: Tracer.Tracer) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
+  Tracer.tracerWith
+
+/** @internal */
+export const tracer: Effect.Effect<Tracer.Tracer> = tracerWith(core.succeed)
+
+/* @internal */
+export const tryPromise: {
+  <A, E>(
+    options: {
+      readonly try: (signal: AbortSignal) => PromiseLike<A>
+      readonly catch: (error: unknown) => E
+    }
+  ): Effect.Effect<A, E>
+  <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, Cause.UnknownException>
+} = <A, E>(
+  arg: ((signal: AbortSignal) => PromiseLike<A>) | {
+    readonly try: (signal: AbortSignal) => PromiseLike<A>
+    readonly catch: (error: unknown) => E
+  }
+): Effect.Effect<A, E | Cause.UnknownException> => {
+  let evaluate: (signal?: AbortSignal) => PromiseLike<A>
+  let catcher: ((error: unknown) => E) | undefined = undefined
+  if (typeof arg === "function") {
+    evaluate = arg as (signal?: AbortSignal) => PromiseLike<A>
+  } else {
+    evaluate = arg.try as (signal?: AbortSignal) => PromiseLike<A>
+    catcher = arg.catch
+  }
+  const fail = (e: unknown) =>
+    catcher
+      ? core.failSync(() => catcher(e))
+      : core.fail(new core.UnknownException(e, "An unknown error occurred in Effect.tryPromise"))
+
+  if (evaluate.length >= 1) {
+    return core.async((resolve, signal) => {
+      try {
+        evaluate(signal).then(
+          (a) => resolve(core.succeed(a)),
+          (e) => resolve(fail(e))
+        )
+      } catch (e) {
+        resolve(fail(e))
+      }
+    })
+  }
+
+  return core.async((resolve) => {
+    try {
+      evaluate()
+        .then(
+          (a) => resolve(core.succeed(a)),
+          (e) => resolve(fail(e))
+        )
+    } catch (e) {
+      resolve(fail(e))
+    }
+  })
+}
+
+/* @internal */
+export const tryMap = dual<
+  <A, B, E1>(
+    options: {
+      readonly try: (a: A) => B
+      readonly catch: (error: unknown) => E1
+    }
+  ) => <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E | E1, R>,
+  <A, E, R, B, E1>(
+    self: Effect.Effect<A, E, R>,
+    options: {
+      readonly try: (a: A) => B
+      readonly catch: (error: unknown) => E1
+    }
+  ) => Effect.Effect<B, E | E1, R>
+>(2, (self, options) =>
+  core.flatMap(self, (a) =>
+    try_({
+      try: () => options.try(a),
+      catch: options.catch
+    })))
+
+/* @internal */
+export const tryMapPromise = dual<
+  <A, B, E1>(
+    options: {
+      readonly try: (a: A, signal: AbortSignal) => PromiseLike<B>
+      readonly catch: (error: unknown) => E1
+    }
+  ) => <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E | E1, R>,
+  <A, E, R, B, E1>(
+    self: Effect.Effect<A, E, R>,
+    options: {
+      readonly try: (a: A, signal: AbortSignal) => PromiseLike<B>
+      readonly catch: (error: unknown) => E1
+    }
+  ) => Effect.Effect<B, E | E1, R>
+>(2, <A, E, R, B, E1>(
+  self: Effect.Effect<A, E, R>,
+  options: {
+    readonly try: (a: A, signal: AbortSignal) => PromiseLike<B>
+    readonly catch: (error: unknown) => E1
+  }
+) =>
+  core.flatMap(self, (a) =>
+    tryPromise({
+      try: options.try.length >= 1
+        ? (signal) => options.try(a, signal)
+        : () => (options.try as (a: A) => PromiseLike<B>)(a),
+      catch: options.catch
+    })))
+
+/* @internal */
+export const unless = dual<
+  (condition: LazyArg<boolean>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, condition: LazyArg<boolean>) => Effect.Effect<Option.Option<A>, E, R>
+>(2, (self, condition) =>
+  core.suspend(() =>
+    condition()
+      ? succeedNone
+      : asSome(self)
+  ))
+
+/* @internal */
+export const unlessEffect = dual<
+  <E2, R2>(
+    condition: Effect.Effect<boolean, E2, R2>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E | E2, R | R2>,
+  <A, E, R, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    condition: Effect.Effect<boolean, E2, R2>
+  ) => Effect.Effect<Option.Option<A>, E | E2, R | R2>
+>(2, (self, condition) => core.flatMap(condition, (b) => (b ? succeedNone : asSome(self))))
+
+/* @internal */
+export const unsandbox = <A, E, R>(self: Effect.Effect<A, Cause.Cause<E>, R>) =>
+  mapErrorCause(self, internalCause.flatten)
+
+/* @internal */
+export const updateFiberRefs = (
+  f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs
+): Effect.Effect<void> =>
+  core.withFiberRuntime((state) => {
+    state.setFiberRefs(f(state.id(), state.getFiberRefs()))
+    return core.void
+  })
+
+/* @internal */
+export const updateService = dual<
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    f: (service: Types.NoInfer<S>) => Types.NoInfer<S>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | I>,
+  <A, E, R, I, S>(
+    self: Effect.Effect<A, E, R>,
+    tag: Context.Tag<I, S>,
+    f: (service: Types.NoInfer<S>) => Types.NoInfer<S>
+  ) => Effect.Effect<A, E, R | I>
+>(3, <A, E, R, I, S>(
+  self: Effect.Effect<A, E, R>,
+  tag: Context.Tag<I, S>,
+  f: (service: Types.NoInfer<S>) => Types.NoInfer<S>
+) =>
+  core.mapInputContext(self, (context) =>
+    Context.add(
+      context,
+      tag,
+      f(Context.unsafeGet(context, tag))
+    )) as Effect.Effect<A, E, R | I>)
+
+/* @internal */
+export const when = dual<
+  (condition: LazyArg<boolean>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, condition: LazyArg<boolean>) => Effect.Effect<Option.Option<A>, E, R>
+>(2, (self, condition) =>
+  core.suspend(() =>
+    condition()
+      ? core.map(self, Option.some)
+      : core.succeed(Option.none())
+  ))
+
+/* @internal */
+export const whenFiberRef = dual<
+  <S>(
+    fiberRef: FiberRef.FiberRef<S>,
+    predicate: Predicate.Predicate<S>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<[S, Option.Option<A>], E, R>,
+  <A, E, R, S>(
+    self: Effect.Effect<A, E, R>,
+    fiberRef: FiberRef.FiberRef<S>,
+    predicate: Predicate.Predicate<S>
+  ) => Effect.Effect<[S, Option.Option<A>], E, R>
+>(
+  3,
+  <A, E, R, S>(
+    self: Effect.Effect<A, E, R>,
+    fiberRef: FiberRef.FiberRef<S>,
+    predicate: Predicate.Predicate<S>
+  ) =>
+    core.flatMap(core.fiberRefGet(fiberRef), (s) =>
+      predicate(s)
+        ? core.map(self, (a) => [s, Option.some(a)])
+        : core.succeed<[S, Option.Option<A>]>([s, Option.none()]))
+)
+
+/* @internal */
+export const whenRef = dual<
+  <S>(
+    ref: Ref.Ref<S>,
+    predicate: Predicate.Predicate<S>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<[S, Option.Option<A>], E, R>,
+  <A, E, R, S>(
+    self: Effect.Effect<A, E, R>,
+    ref: Ref.Ref<S>,
+    predicate: Predicate.Predicate<S>
+  ) => Effect.Effect<[S, Option.Option<A>], E, R>
+>(
+  3,
+  <A, E, R, S>(self: Effect.Effect<A, E, R>, ref: Ref.Ref<S>, predicate: Predicate.Predicate<S>) =>
+    core.flatMap(Ref.get(ref), (s) =>
+      predicate(s)
+        ? core.map(self, (a) => [s, Option.some(a)])
+        : core.succeed<[S, Option.Option<A>]>([s, Option.none()]))
+)
+
+/* @internal */
+export const withMetric = dual<
+  <Type, In, Out>(
+    metric: Metric.Metric<Type, In, Out>
+  ) => <A extends In, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A extends In, E, R, Type, In, Out>(
+    self: Effect.Effect<A, E, R>,
+    metric: Metric.Metric<Type, In, Out>
+  ) => Effect.Effect<A, E, R>
+>(2, (self, metric) => metric(self))
+
+/** @internal */
+export const serviceFunctionEffect = <T extends Effect.Effect<any, any, any>, Args extends Array<any>, A, E, R>(
+  getService: T,
+  f: (_: Effect.Effect.Success<T>) => (...args: Args) => Effect.Effect<A, E, R>
+) =>
+(...args: Args): Effect.Effect<A, E | Effect.Effect.Error<T>, R | Effect.Effect.Context<T>> =>
+  core.flatMap(getService, (a) => f(a)(...args))
+
+/** @internal */
+export const serviceFunction = <T extends Effect.Effect<any, any, any>, Args extends Array<any>, A>(
+  getService: T,
+  f: (_: Effect.Effect.Success<T>) => (...args: Args) => A
+) =>
+(...args: Args): Effect.Effect<A, Effect.Effect.Error<T>, Effect.Effect.Context<T>> =>
+  core.map(getService, (a) => f(a)(...args))
+
+/** @internal */
+export const serviceFunctions = <S, SE, SR>(
+  getService: Effect.Effect<S, SE, SR>
+): {
+  [k in keyof S as S[k] extends (...args: Array<any>) => Effect.Effect<any, any, any> ? k : never]: S[k] extends
+    (...args: infer Args) => Effect.Effect<infer A, infer E, infer R>
+    ? (...args: Args) => Effect.Effect<A, E | SE, R | SR>
+    : never
+} =>
+  new Proxy({} as any, {
+    get(_target: any, prop: any, _receiver) {
+      return (...args: Array<any>) => core.flatMap(getService, (s: any) => s[prop](...args))
+    }
+  })
+
+/** @internal */
+export const serviceConstants = <S, SE, SR>(
+  getService: Effect.Effect<S, SE, SR>
+): {
+  [k in { [k in keyof S]: k }[keyof S]]: S[k] extends Effect.Effect<infer A, infer E, infer R> ?
+    Effect.Effect<A, E | SE, R | SR> :
+    Effect.Effect<S[k], SE, SR>
+} =>
+  new Proxy({} as any, {
+    get(_target: any, prop: any, _receiver) {
+      return core.flatMap(getService, (s: any) => core.isEffect(s[prop]) ? s[prop] : core.succeed(s[prop]))
+    }
+  })
+
+/** @internal */
+export const serviceMembers = <S, SE, SR>(getService: Effect.Effect<S, SE, SR>): {
+  functions: {
+    [k in keyof S as S[k] extends (...args: Array<any>) => Effect.Effect<any, any, any> ? k : never]: S[k] extends
+      (...args: infer Args) => Effect.Effect<infer A, infer E, infer R>
+      ? (...args: Args) => Effect.Effect<A, E | SE, R | SR>
+      : never
+  }
+  constants: {
+    [k in { [k in keyof S]: k }[keyof S]]: S[k] extends Effect.Effect<infer A, infer E, infer R> ?
+      Effect.Effect<A, E | SE, R | SR> :
+      Effect.Effect<S[k], SE, SR>
+  }
+} => ({
+  functions: serviceFunctions(getService) as any,
+  constants: serviceConstants(getService)
+})
+
+/** @internal */
+export const serviceOption = <I, S>(tag: Context.Tag<I, S>) => core.map(core.context<never>(), Context.getOption(tag))
+
+/** @internal */
+export const serviceOptional = <I, S>(tag: Context.Tag<I, S>) =>
+  core.flatMap(core.context<never>(), Context.getOption(tag))
+
+// -----------------------------------------------------------------------------
+// tracing
+// -----------------------------------------------------------------------------
+
+/* @internal */
+export const annotateCurrentSpan: {
+  (key: string, value: unknown): Effect.Effect<void>
+  (values: Record<string, unknown>): Effect.Effect<void>
+} = function(): Effect.Effect<void> {
+  const args = arguments
+  return ignore(core.flatMap(
+    currentSpan,
+    (span) =>
+      core.sync(() => {
+        if (typeof args[0] === "string") {
+          span.attribute(args[0], args[1])
+        } else {
+          for (const key in args[0]) {
+            span.attribute(key, args[0][key])
+          }
+        }
+      })
+  ))
+}
+
+/* @internal */
+export const linkSpanCurrent: {
+  (span: Tracer.AnySpan, attributes?: Readonly<Record<string, unknown>> | undefined): Effect.Effect<void>
+  (links: ReadonlyArray<Tracer.SpanLink>): Effect.Effect<void>
+} = function(): Effect.Effect<void> {
+  const args = arguments
+  const links: ReadonlyArray<Tracer.SpanLink> = Array.isArray(args[0])
+    ? args[0]
+    : [{ _tag: "SpanLink", span: args[0], attributes: args[1] ?? {} }]
+  return ignore(core.flatMap(
+    currentSpan,
+    (span) => core.sync(() => span.addLinks(links))
+  ))
+}
+
+/* @internal */
+export const annotateSpans = dual<
+  {
+    (key: string, value: unknown): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+    (
+      values: Record<string, unknown>
+    ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  },
+  {
+    <A, E, R>(effect: Effect.Effect<A, E, R>, key: string, value: unknown): Effect.Effect<A, E, R>
+    <A, E, R>(effect: Effect.Effect<A, E, R>, values: Record<string, unknown>): Effect.Effect<A, E, R>
+  }
+>(
+  (args) => core.isEffect(args[0]),
+  function<A, E, R>() {
+    const args = arguments
+    return core.fiberRefLocallyWith(
+      args[0] as Effect.Effect<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 currentParentSpan: Effect.Effect<Tracer.AnySpan, Cause.NoSuchElementException> = serviceOptional(
+  internalTracer.spanTag
+)
+
+/** @internal */
+export const currentSpan: Effect.Effect<Tracer.Span, Cause.NoSuchElementException> = core.flatMap(
+  core.context<never>(),
+  (context) => {
+    const span = context.unsafeMap.get(internalTracer.spanTag.key) as Tracer.AnySpan | undefined
+    return span !== undefined && span._tag === "Span"
+      ? core.succeed(span)
+      : core.fail(new core.NoSuchElementException())
+  }
+)
+
+/* @internal */
+export const linkSpans = dual<
+  (
+    span: Tracer.AnySpan,
+    attributes?: Record<string, unknown>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    span: Tracer.AnySpan,
+    attributes?: Record<string, unknown>
+  ) => Effect.Effect<A, E, R>
+>(
+  (args) => core.isEffect(args[0]),
+  (self, span, attributes) =>
+    core.fiberRefLocallyWith(
+      self,
+      core.currentTracerSpanLinks,
+      Chunk.append(
+        {
+          _tag: "SpanLink",
+          span,
+          attributes: attributes ?? {}
+        } as const
+      )
+    )
+)
+
+const bigint0 = BigInt(0)
+
+const filterDisablePropagation: (self: Option.Option<Tracer.AnySpan>) => Option.Option<Tracer.AnySpan> = Option.flatMap(
+  (span) =>
+    Context.get(span.context, internalTracer.DisablePropagation)
+      ? span._tag === "Span" ? filterDisablePropagation(span.parent) : Option.none()
+      : Option.some(span)
+)
+
+/** @internal */
+export const unsafeMakeSpan = <XA, XE>(
+  fiber: FiberRuntime<XA, XE>,
+  name: string,
+  options: Tracer.SpanOptions
+) => {
+  const disablePropagation = !fiber.getFiberRef(core.currentTracerEnabled) ||
+    (options.context && Context.get(options.context, internalTracer.DisablePropagation))
+  const context = fiber.getFiberRef(core.currentContext)
+  const parent = options.parent
+    ? Option.some(options.parent)
+    : options.root
+    ? Option.none()
+    : filterDisablePropagation(Context.getOption(context, internalTracer.spanTag))
+
+  let span: Tracer.Span
+
+  if (disablePropagation) {
+    span = core.noopSpan({
+      name,
+      parent,
+      context: Context.add(options.context ?? Context.empty(), internalTracer.DisablePropagation, true)
+    })
+  } else {
+    const services = fiber.getFiberRef(defaultServices.currentServices)
+
+    const tracer = Context.get(services, internalTracer.tracerTag)
+    const clock = Context.get(services, Clock.Clock)
+    const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+
+    const fiberRefs = fiber.getFiberRefs()
+    const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
+    const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
+
+    const links = linksFromEnv._tag === "Some" ?
+      options.links !== undefined ?
+        [
+          ...Chunk.toReadonlyArray(linksFromEnv.value),
+          ...(options.links ?? [])
+        ] :
+        Chunk.toReadonlyArray(linksFromEnv.value) :
+      options.links ?? Arr.empty()
+
+    span = tracer.span(
+      name,
+      parent,
+      options.context ?? Context.empty(),
+      links,
+      timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0,
+      options.kind ?? "internal",
+      options
+    )
+
+    if (annotationsFromEnv._tag === "Some") {
+      HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
+    }
+    if (options.attributes !== undefined) {
+      Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
+    }
+  }
+
+  if (typeof options.captureStackTrace === "function") {
+    internalCause.spanToTrace.set(span, options.captureStackTrace)
+  }
+
+  return span
+}
+
+/** @internal */
+export const makeSpan = (
+  name: string,
+  options?: Tracer.SpanOptions
+): Effect.Effect<Tracer.Span> => {
+  options = internalTracer.addSpanStackTrace(options)
+  return core.withFiberRuntime((fiber) => core.succeed(unsafeMakeSpan(fiber, name, options)))
+}
+
+/* @internal */
+export const spanAnnotations: Effect.Effect<HashMap.HashMap<string, unknown>> = core
+  .fiberRefGet(core.currentTracerSpanAnnotations)
+
+/* @internal */
+export const spanLinks: Effect.Effect<Chunk.Chunk<Tracer.SpanLink>> = core
+  .fiberRefGet(core.currentTracerSpanLinks)
+
+/** @internal */
+export const endSpan = <A, E>(span: Tracer.Span, exit: Exit<A, E>, clock: Clock.Clock, timingEnabled: boolean) =>
+  core.sync(() => {
+    if (span.status._tag === "Ended") {
+      return
+    }
+    if (core.exitIsFailure(exit) && internalCause.spanToTrace.has(span)) {
+      // https://opentelemetry.io/docs/specs/semconv/registry/attributes/code/#code-stacktrace
+      span.attribute("code.stacktrace", internalCause.spanToTrace.get(span)!())
+    }
+    span.end(timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0, exit)
+  })
+
+/** @internal */
+export const useSpan: {
+  <A, E, R>(name: string, evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+  <A, E, R>(
+    name: string,
+    options: Tracer.SpanOptions,
+    evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R>
+  ): Effect.Effect<A, E, R>
+} = <A, E, R>(
+  name: string,
+  ...args: [evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R>] | [
+    options: any,
+    evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R>
+  ]
+) => {
+  const options = internalTracer.addSpanStackTrace(args.length === 1 ? undefined : args[0])
+  const evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R> = args[args.length - 1]
+
+  return core.withFiberRuntime<A, E, R>((fiber) => {
+    const span = unsafeMakeSpan(fiber, name, options)
+    const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+    const clock = Context.get(fiber.getFiberRef(defaultServices.currentServices), clockTag)
+    return core.onExit(evaluate(span), (exit) => endSpan(span, exit, clock, timingEnabled))
+  })
+}
+
+/** @internal */
+export const withParentSpan = dual<
+  (
+    span: Tracer.AnySpan
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, span: Tracer.AnySpan) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+>(2, (self, span) => provideService(self, internalTracer.spanTag, span))
+
+/** @internal */
+export const withSpan: {
+  (
+    name: string,
+    options?: Tracer.SpanOptions | undefined
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    name: string,
+    options?: Tracer.SpanOptions | undefined
+  ): Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = internalTracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
+  if (dataFirst) {
+    const self = arguments[0]
+    return useSpan(name, options, (span) => withParentSpan(self, span))
+  }
+  return (self: Effect.Effect<any, any, any>) => useSpan(name, options, (span) => withParentSpan(self, span))
+} as any
+
+export const functionWithSpan = <Args extends Array<any>, Ret extends Effect.Effect<any, any, any>>(
+  options: {
+    readonly body: (...args: Args) => Ret
+    readonly options: Effect.FunctionWithSpanOptions | ((...args: Args) => Effect.FunctionWithSpanOptions)
+    readonly captureStackTrace?: boolean | undefined
+  }
+): (...args: Args) => Unify<Ret> =>
+  (function(this: any) {
+    let captureStackTrace: LazyArg<string | undefined> | boolean = options.captureStackTrace ?? false
+    if (options.captureStackTrace !== false) {
+      const limit = Error.stackTraceLimit
+      Error.stackTraceLimit = 2
+      const error = new Error()
+      Error.stackTraceLimit = limit
+      let cache: false | string = false
+      captureStackTrace = () => {
+        if (cache !== false) {
+          return cache
+        }
+        if (error.stack) {
+          const stack = error.stack.trim().split("\n")
+          cache = stack.slice(2).join("\n").trim()
+          return cache
+        }
+      }
+    }
+    return core.suspend(() => {
+      const opts = typeof options.options === "function"
+        ? options.options.apply(null, arguments as any)
+        : options.options
+      return withSpan(
+        core.suspend(() => internalCall(() => options.body.apply(this, arguments as any))),
+        opts.name,
+        {
+          ...opts,
+          captureStackTrace
+        }
+      )
+    })
+  }) as any
+
+// -------------------------------------------------------------------------------------
+// optionality
+// -------------------------------------------------------------------------------------
+
+/* @internal */
+export const fromNullable = <A>(value: A): Effect.Effect<NonNullable<A>, Cause.NoSuchElementException> =>
+  value == null ? core.fail(new core.NoSuchElementException()) : core.succeed(value as NonNullable<A>)
+
+/* @internal */
+export const optionFromOptional = <A, E, R>(
+  self: Effect.Effect<A, E, R>
+): Effect.Effect<Option.Option<A>, Exclude<E, Cause.NoSuchElementException>, R> =>
+  core.catchAll(
+    core.map(self, Option.some),
+    (error) =>
+      core.isNoSuchElementException(error) ?
+        succeedNone :
+        core.fail(error as Exclude<E, Cause.NoSuchElementException>)
+  )