@typed/fx 1.18.4 → 1.20.0

package/src/Fx.ts

@@ -1,140 +1,136 @@
 /**
- * Fx<R, E, A> is a representation of an `Effect`-ful workflow that exists over
- * the time dimension. It operates within a context `R`, can fail with an `E`,
- * and succeed with an `A`.
- *
- * Any `Fx`, shorthand for "Effects", can emit 0 or more errors or events over an
- * indefinite period of time. This is in contrast to `Effect` which can only
- * produce exactly 1 error or event.
- *
- * It is defined as a super-type of `Effect`, `Stream`, and `Cause`. This
- * allows for all operators that accept an `Fx` to also capable of
- * accepting an `Effect`, `Stream`, or `Cause`. An Effect or Cause represents a single
- * event or error, while a Stream represents a series of events or errors that will
- * be pulled from the producer as soon as possible.
- *
- * @since 1.18.0
- */
-
-import type * as Context from "@typed/context"
-import type { Stream } from "effect"
+ * Fx is a push-based reactive primitive built atop of Effect.
+ * @since 1.20.0
+ */
+
+import type * as Ctx from "@typed/context"
+import type {
+  ConfigProvider,
+  Duration,
+  Equivalence,
+  ExecutionStrategy,
+  Exit,
+  Fiber,
+  FiberId,
+  FiberRef,
+  HashSet,
+  Pipeable,
+  Predicate,
+  PubSub,
+  Request,
+  Runtime,
+  Scope,
+  Tracer
+} from "effect"
 import * as Cause from "effect/Cause"
-import type * as Chunk from "effect/Chunk"
 import type { DurationInput } from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
-import type { Equivalence } from "effect/Equivalence"
-import type * as Exit from "effect/Exit"
-import type * as Fiber from "effect/Fiber"
-import type * as FiberId from "effect/FiberId"
-import type { FiberRef } from "effect/FiberRef"
-import { constant, dual, identity } from "effect/Function"
-import type * as HashSet from "effect/HashSet"
-import type { Inspectable } from "effect/Inspectable"
-import type * as Layer from "effect/Layer"
+import { dual, identity } from "effect/Function"
+import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
-import type { Pipeable } from "effect/Pipeable"
-import type * as PubSub from "effect/PubSub"
-import type * as Queue from "effect/Queue"
-import type * as Request from "effect/Request"
-import type * as Runtime from "effect/Runtime"
-import type * as Schedule from "effect/Schedule"
-import type { Scheduler } from "effect/Scheduler"
-import type * as Scope from "effect/Scope"
-import type * as Tracer from "effect/Tracer"
-import type { Emitter } from "./Emitter.js"
+import { hasProperty } from "effect/Predicate"
+import * as Queue from "effect/Queue"
+import * as Schedule from "effect/Schedule"
+import type * as Types from "effect/Types"
+import * as Emitter from "./Emitter.js"
 import * as core from "./internal/core.js"
-import * as primitive from "./internal/fx-primitive.js"
-import * as internal from "./internal/fx.js"
-import * as internalKeyed from "./internal/keyed.js"
-import * as internalProtos from "./internal/protos.js"
-import * as internalRun from "./internal/run.js"
-import * as Share from "./internal/share.js"
+import * as coreKeyed from "./internal/keyed.js"
+import * as protos from "./internal/protos.js"
+import * as coreShare from "./internal/share.js"
 import * as strategies from "./internal/strategies.js"
-import * as internalWithKey from "./internal/withKey.js"
+import * as coreWithKey from "./internal/withKey.js"
 import { type RefSubject, transform } from "./RefSubject.js"
-import type * as Sink from "./Sink.js"
-import type { Subject } from "./Subject.js"
+import * as Sink from "./Sink.js"
+import type * as Subject from "./Subject.js"
 import { TypeId } from "./TypeId.js"
 
-/* #region Model */
-
 /**
- * Fx<R, E, A> is a representation of an `Effect`-ful workflow that exists over
- * the time dimension. It operates within a context `R`, can fail with an `E`,
- * and succeed with an `A`.
- *
- * @since 1.18.0
- * @category models
+ * Fx is a push-based reactive primitive built atop of Effect.
+ * @since 1.20.0
  */
-export interface Fx<R, E, A> extends Fx.Variance<R, E, A>, Pipeable, Inspectable {}
+export interface Fx<out R, out E, out A> extends Pipeable.Pipeable {
+  readonly [TypeId]: Fx.Variance<R, E, A>
 
-/**
- * FxInput<R, E, A> are all the types that can be transformed into an Fx
- *
- * @since 1.18.0
- * @category models
- */
-export type FxInput<R, E, A> = Fx<R, E, A> | Effect.Effect<R, E, A> | Cause.Cause<E> | Iterable<A>
+  /**
+   * @since 1.20.0
+   */
+  run<R2 = never>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown>
+}
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export namespace Fx {
   /**
-   * Extract the Context, Error, or Success type from an Fx
-   * @since 1.18.0
+   * @since 1.20.0
+   */
+  export interface Variance<R, E, A> {
+    readonly _R: Types.Covariant<R>
+    readonly _E: Types.Covariant<E>
+    readonly _A: Types.Covariant<A>
+  }
+
+  /**
+   * @since 1.20.0
    */
   export type Context<T> = T extends Fx<infer R, infer _E, infer _A> ? R : never
 
   /**
-   * Extract the Error type from an Fx
-   * @since 1.18.0
+   * @since 1.20.0
    */
   export type Error<T> = T extends Fx<infer _R, infer E, infer _A> ? E : never
 
   /**
-   * Extract the Success type from an Fx
-   * @since 1.18.0
+   * @since 1.20.0
    */
   export type Success<T> = T extends Fx<infer _R, infer _E, infer A> ? A : never
 
   /**
-   * Configures the variance of an Fx
-   * @since 1.18.0
-   * @category models
+   * @since 1.20.0
    */
-  export interface Variance<R, E, A> {
-    readonly [TypeId]: {
-      readonly _R: (_: never) => R
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
-    }
-  }
+  export type Unify<T> = T extends Fx<infer R, infer E, infer A> | infer _ ? Fx<R, E, A> : never
+}
 
-  /**
-   * @since 1.18.0
-   */
-  export type FromInput<T extends FxInput<any, any, any>> = [T] extends [ReadonlyArray<infer A>] ? Fx<never, never, A>
-    : [T] extends [Iterable<infer A>] ? Fx<never, never, A>
-    : [T] extends [Cause.Cause<infer E>] ? Fx<never, E, never>
-    : [T] extends [Fx<infer R, infer E, infer A>] ? Fx<R, E, A>
-    : [T] extends [Effect.Effect<infer R, infer E, infer A>] ? Fx<R, E, A>
-    : never
+/**
+ * @since 1.20.0
+ */
+export type Context<T> = Fx.Context<T>
+
+/**
+ * @since 1.20.0
+ */
+export type Error<T> = Fx.Error<T>
+
+/**
+ * @since 1.20.0
+ */
+export type Success<T> = Fx.Success<T>
+
+/**
+ * @since 1.20.0
+ */
+export type Unify<T> = Fx.Unify<T>
+
+/**
+ * @since 1.20.0
+ */
+export function isFx<R, E, A>(u: unknown): u is Fx<R, E, A> {
+  return u === null ? false : hasProperty(u, TypeId)
 }
 
 /**
  * FlattenStrategy is a representation of how higher-order effect operators should flatten
  * nested Fx.
  *
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export type FlattenStrategy = Unbounded | Bounded | Switch | Exhaust | ExhaustLatest
 
 /**
  * Strategy which will allow for an unbounded number of concurrent effects to be run.
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface Unbounded {
@@ -143,14 +139,14 @@ export interface Unbounded {
 
 /**
  * Singleton instance of Unbounded
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const Unbounded: Unbounded = strategies.Unbounded
 
 /**
  * Strategy which will allow for a bounded number of concurrent effects to be run.
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface Bounded {
@@ -160,14 +156,14 @@ export interface Bounded {
 
 /**
  * Construct a Bounded strategy
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const Bounded: (capacity: number) => Bounded = strategies.Bounded
 
 /**
  * Strategy which will switch to a new effect as soon as it is available.
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface Switch {
@@ -176,7 +172,7 @@ export interface Switch {
 
 /**
  * Singleton instance of Switch
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const Switch: Switch = strategies.Switch
@@ -186,7 +182,7 @@ export const Switch: Switch = strategies.Switch
  * the first Fx is still running. When the first Fx finished, the next event
  * will execute.
  *
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface Exhaust {
@@ -195,7 +191,7 @@ export interface Exhaust {
 
 /**
  * Singleton instance of Exhaust
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const Exhaust: Exhaust = strategies.Exhaust
@@ -205,7 +201,7 @@ export const Exhaust: Exhaust = strategies.Exhaust
  * the latest Fx is still running. When the latest Fx finishes, the last seend event
  * will execute.
  *
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface ExhaustLatest {
@@ -214,21 +210,21 @@ export interface ExhaustLatest {
 
 /**
  * Singleton instance of ExhaustLatest
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const ExhaustLatest: ExhaustLatest = strategies.ExhaustLatest
 
 /**
  * MergeStrategy is a representation of how multiple Fx should be merged together.
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export type MergeStrategy = Unordered | Ordered | Switch
 
 /**
  * Strategy which will merge Fx in an unordered fashion.
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export interface Unordered {
@@ -238,7 +234,7 @@ export interface Unordered {
 
 /**
  * Construct an Unordered strategy
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export const Unordered: (concurrency: number) => Unordered = strategies.Unordered
@@ -246,7 +242,7 @@ export const Unordered: (concurrency: number) => Unordered = strategies.Unordere
 /**
  * Strategy which will merge Fx in an ordered fashion with
  * the specified level of concurrency.
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export interface Ordered {
@@ -256,2222 +252,1792 @@ export interface Ordered {
 
 /**
  * Construct an Ordered strategy
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export const Ordered: (concurrency: number) => Ordered = strategies.Ordered
 
 /* #endregion */
 
-/* #region Constructor */
-
-/* #region Core */
-
 /**
- * An Fx which will immediately end producing 0 events and 0 errors.
- * @since 1.18.0
- * @category constructors
+ * Type-alias for a Effect.forkIn(scope) that returns a Fiber
+ * @since 1.20.0
+ * @category models
  */
-export const empty: Fx<never, never, never> = core.empty
+export type ScopedFork = <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, never, Fiber.Fiber<E, A>>
 
 /**
- * Construct an Fx<never, E, A> from a Cause<E>
- * @since 1.18.0
- * @category constructors
+ * Type-alias for Effect.forkIn(scope) which runs the Effect runtime
+ * of an Fx in a Scope. Used in for higher-order operators.
+ *
+ * @since 1.20.0
+ * @category models
  */
-export const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never> = core.failCause
+export type FxFork = <R>(
+  effect: Effect.Effect<R, never, void>
+) => Effect.Effect<R, never, void>
 
 /**
- * Construct an Fx<never, never, never> from a defect
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const die = (defect: unknown): Fx<never, never, never> => failCause(Cause.die(defect))
+export const make: {
+  <R, E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<R, never, unknown>): Fx<R, E, A>
+  <E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<never, never, unknown>): Fx<never, E, A>
+  <A>(run: (sink: Sink.Sink<never, never, A>) => Effect.Effect<never, never, unknown>): Fx<never, never, A>
+} = core.make
 
 /**
- * Interrupt the current Fx with the specified FiberId
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const interrupt = (id: FiberId.FiberId): Fx<never, never, never> => failCause(Cause.interrupt(id))
+export const succeed: <A>(value: A) => Fx<never, never, A> = core.succeed
 
 /**
- * Construct an Fx which will fail with the specified error.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fail: <E>(error: E) => Fx<never, E, never> = core.fail
+export const sync: <A>(f: () => A) => Fx<never, never, A> = core.fromSync
 
 /**
- * Construct an Fx<R, E, A> from an Effect<R, E, A>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Fx<R, E, A> = core.fromEffect
+export const fromArray: <const A extends ReadonlyArray<any>>(array: A) => Fx<never, never, A[number]> = core.fromArray
 
 /**
- * Construct an Fx from an Iterable
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromIterable: {
-  <A extends ReadonlyArray<any>>(array: A): Fx<never, never, A[number]>
-  <A>(iterable: Iterable<A>): Fx<never, never, A>
-} = core.fromIterable
+export const fromIterable: <A>(iterable: Iterable<A>) => Fx<never, never, A> = core.fromIterable
 
 /**
- * Construct an Fx<R, E, A> from an Effect<R, E, A>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromStream: <R, E, A>(effect: Stream.Stream<R, E, A>) => Fx<R, E, A> = core.fromStream
+export const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Fx<R, E, A> = core.fromEffect
 
 /**
- * Construct an Fx<R, E, A> from an Effect<R, E, A>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const from: {
-  <A extends ReadonlyArray<any>>(array: A): Fx<never, never, A[number]>
-  <A>(iterable: Iterable<A>): Fx<never, never, A>
-  <E>(cause: Cause.Cause<E>): Fx<never, E, never>
-  <R, E, A>(fx: FxInput<R, E, A>): Fx<R, E, A>
-  <A>(value: A): Fx<never, never, A>
-} = core.from
+export const fromScheduled: {
+  <R2, I, O>(
+    schedule: Schedule.Schedule<R2, I, O>
+  ): <R, E>(input: Effect.Effect<R, E, I>) => Fx<R | R2, E, O>
 
-/**
- * Construct an Fx by describing an Effectful workflow that has access to a Sink
- * to emit events and errors.
- * @since 1.18.0
- * @category constructors
- */
-export const fromSink: <R, E, A>(f: (sink: Sink.Sink<E, A>) => Effect.Effect<R, E, unknown>) => Fx<R, E, A> =
-  core.fromSink
+  <R, E, I, R2, O>(
+    input: Effect.Effect<R, E, I>,
+    schedule: Schedule.Schedule<R2, I, O>
+  ): Fx<R | R2, E, O>
+} = dual(2, core.fromScheduled)
 
 /**
- * Construct an Fx by describing an Scoped Effect that has access to an Emitter
- * to emit events and errors.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromEmitter: <R, E, A>(
-  f: (emitter: Emitter<E, A>) => Effect.Effect<R | Scope.Scope, never, unknown>
-) => Fx<Exclude<R, Scope.Scope>, E, A> = core.fromEmitter
+export const schedule: {
+  <R2, O>(
+    schedule: Schedule.Schedule<R2, unknown, O>
+  ): <R, E, A>(input: Effect.Effect<R, E, A>) => Fx<R | R2, E, A>
+
+  <R, E, A, R2, O>(
+    input: Effect.Effect<R, E, A>,
+    schedule: Schedule.Schedule<R2, unknown, O>
+  ): Fx<R | R2, E, A>
+} = dual(2, core.schedule)
 
 /**
- * An Fx which will never emit any errors or events, and will never end
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const never: Fx<never, never, never> = core.never
+export const periodic: {
+  (period: Duration.DurationInput): <R, E, A>(iterator: Effect.Effect<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(iterator: Effect.Effect<R, E, A>, period: Duration.DurationInput): Fx<R, E, A>
+} = dual(2, <R, E, A>(
+  iterator: Effect.Effect<R, E, A>,
+  period: Duration.DurationInput
+): Fx<R, E, A> => continueWith(fromEffect(iterator), () => schedule(iterator, Schedule.spaced(period))))
 
 /**
- * Construct an Fx which will emit the specified value and then end.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const succeed: <A>(value: A) => Fx<never, never, A> = core.succeed
+export const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never> = core.failCause
 
 /**
- * Construct an Fx which will emit the return of a synchronous function and then end.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const sync: <A>(f: () => A) => Fx<never, never, A> = core.sync
+export const fail: <E>(error: E) => Fx<never, E, never> = core.fail
 
 /**
- * Lazily construct an Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const suspend: <R, E, A>(f: () => Fx<R, E, A>) => Fx<R, E, A> = core.suspend
+export const die: (error: unknown) => Fx<never, never, never> = core.die
 
 /**
- * Helper for constructing your own custom subtypes of an Fx
- * @since 1.18.0
- * @category Subtyping
+ * @since 1.20.0
  */
-export abstract class ToFx<R, E, A> extends primitive.ToFx<R, E, A> implements Fx<R, E, A> {
-  /**
-   * Your implementation of an Fx is returned by this function.
-   * @since 1.18.0
-   */
-  abstract toFx(): Fx<R, E, A>
-}
+export const map: {
+  <A, B>(f: (a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
+  <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B>
+} = dual(2, core.map)
 
 /**
- * Create an Fx which will emit a value after waiting for a specified duration.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const at: {
-  (delay: DurationInput): <A>(value: A) => Fx<never, never, A>
-  <A>(value: A, delay: DurationInput): Fx<never, never, A>
-} = internal.at
+export const filter: {
+  <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
+  <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, B>
+  <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>
+} = dual(2, core.filter)
 
 /**
- * Type-alias for a Effect.forkIn(scope) that returns a Fiber
- * @since 1.18.0
- * @category models
+ * @since 1.20.0
  */
-export type ScopedFork = <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, never, Fiber.Fiber<E, A>>
+export const filterMap: {
+  <A, B>(f: (a: A) => Option.Option<B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
+  <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B>
+} = dual(2, core.filterMap)
 
 /**
- * Type-alias for Effect.forkIn(scope) which runs the Effect runtime
- * of an Fx in a Scope. Used in for higher-order operators.
- *
- * @since 1.18.0
- * @category models
+ * @since 1.20.0
  */
-export type FxFork = <R>(
-  effect: Effect.Effect<R, never, void>
-) => Effect.Effect<R, never, void>
+export const compact = <R, E, A>(fx: Fx<R, E, Option.Option<A>>): Fx<R, E, A> => filterMap(fx, identity)
 
 /**
- * Params for withScopedFork
- * @since 1.18.0
- * @category params
+ * @since 1.20.0
  */
-export type WithScopedForkParams<E, A> = {
-  readonly sink: Sink.Sink<E, A>
-  readonly fork: ScopedFork
-  readonly scope: Scope.Scope
-}
+export const mapEffect: {
+  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, B>
+} = dual(2, core.mapEffect)
 
 /**
- * Construct an Fx which can fork effects into a Scope.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const withScopedFork: <R, E, A>(
-  f: (params: WithScopedForkParams<E, A>) => Effect.Effect<R, never, unknown>
-) => Fx<R, E, A> = core.withScopedFork
+export const filterMapEffect: {
+  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): Fx<R | R2, E | E2, B>
+} = dual(2, core.filterMapEffect)
 
 /**
- * Params for withEarlyExit
- * @since 1.18.0
- * @category params
+ * @since 1.20.0
  */
-export type WithEarlyExitParams<E, A> = {
-  readonly sink: Sink.WithEarlyExit<E, A>
-  readonly fork: ScopedFork
-  readonly scope: Scope.Scope
-}
+export const filterEffect: {
+  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
+} = dual(2, core.filterEffect)
 
 /**
- * Construct an Fx which can exit early from a Scope.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const withEarlyExit: <R, E, A>(
-  f: (params: WithEarlyExitParams<E, A>) => Effect.Effect<R, never, unknown>
-) => Fx<R, E, A> = core.withEarlyExit
+export const tapEffect: {
+  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, unknown>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, unknown>): Fx<R | R2, E | E2, A>
+} = dual(2, core.tapEffect)
 
 /**
- * Params for withFlattenStrategy
- * @since 1.18.0
- * @category params
+ * @since 1.20.0
  */
-export type WithFlattenStrategyParams<E, A> = {
-  readonly sink: Sink.Sink<E, A>
-  readonly fork: FxFork
-  readonly scope: Scope.Scope
-}
+export const tap: {
+  <A>(f: (a: A) => unknown): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, f: (a: A) => unknown): Fx<R, E, A>
+} = dual(2, (fx, f) => tapEffect(fx, (a) => Effect.sync(() => f(a))))
 
 /**
- * Construct an Fx which can flatten nested Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const withFlattenStrategy: <R, E, A>(
-  f: (params: WithFlattenStrategyParams<E, A>) => Effect.Effect<R, never, unknown>,
-  strategy: FlattenStrategy
-) => Fx<R, E, A> = core.withFlattenStrategy
-
-/* #endregion */
-
-/* #region Additions */
+export const loop: {
+  <B, A, C>(seed: B, f: (acc: B, a: A) => readonly [C, B]): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, C>
+  <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<R, E, C>
+} = dual(3, core.loop)
 
 /**
- * Acquire a resource, use it to construct an Fx, and then release the resource
- * after the Fx has exited.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const acquireUseRelease: {
-  <A, R2, E2, B, R3, E3>(
-    use: (a: A) => FxInput<R2, E2, B>,
-    release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, unknown>
-  ): <R, E>(acquire: Effect.Effect<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, B>
-
-  <R, E, A, R2, E2, B, R3, E3>(
-    acquire: Effect.Effect<R, E, A>,
-    use: (a: A) => FxInput<R2, E2, B>,
-    release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, unknown>
-  ): Fx<R | R2 | R3, E | E2 | E3, B>
-} = core.acquireUseRelease
+export const filterMapLoop: {
+  <B, A, C>(seed: B, f: (acc: B, a: A) => readonly [Option.Option<C>, B]): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, C>
+  <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => readonly [Option.Option<C>, B]): Fx<R, E, C>
+} = dual(3, core.filterMapLoop)
 
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * as a tuple of values.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const combine: <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, { readonly [K in keyof FX]: Fx.Success<FX[K]> }> = core.combine
+export const loopEffect: {
+  <R2, E2, B, A, C>(
+    seed: B,
+    f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, C>
+  <R, E, A, R2, E2, B, C>(
+    fx: Fx<R, E, A>,
+    seed: B,
+    f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
+  ): Fx<R | R2, E | E2, C>
+} = dual(3, core.loopEffect)
 
 /**
- * Combine a record of Fx into a single Fx that will emit the results of all Fx
- * as a record of values.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const struct: <const FX extends Readonly<Record<string, Fx<any, any, any>>>>(
-  fxs: FX
-) => Fx<Fx.Context<FX[string]>, Fx.Error<FX[string]>, { readonly [K in keyof FX]: Fx.Success<FX[K]> }> = (fx) =>
-  map(combine(Object.entries(fx).map(([k, fx]) => map(fx, (v) => [k, v] as const))), Object.fromEntries)
+export const filterMapLoopEffect: {
+  <R2, E2, B, A, C>(
+    seed: B,
+    f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, C>
+  <R, E, A, R2, E2, B, C>(
+    fx: Fx<R, E, A>,
+    seed: B,
+    f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>
+  ): Fx<R | R2, E | E2, C>
+} = dual(3, core.filterMapLoopEffect)
 
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * as they occur.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const merge: <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> = core.merge
+export const observe: {
+  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, E | E2, void>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Effect.Effect<R | R2, E | E2, void>
+} = dual(2, core.observe)
 
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * as they occur, but only allowing `n` concurrent Fx to run at a time.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const mergeConcurrently: {
-  (concurrency: number): <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-    fxs: FX
-  ) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-  <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-    fxs: FX,
-    concurrency: number
-  ): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-} = core.mergeConcurrently
+export const drain: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void> = core.drain
 
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * in the order the Fx were provided. All Fx will be executed concurrently,
- * and the results will be buffered if necessary to preserve ordering.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const mergeBuffer: <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> = core.mergeBuffer
+export const reduce: {
+  <A, B>(seed: B, f: (acc: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, B>
+  <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<R, E, B>
+} = dual(3, core.reduce)
 
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * in the order the Fx were provided. All Fx will be executed concurrently, limited
- * by the provided concurrency, and the results will be buffered if necessary to preserve ordering.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const mergeBufferConcurrently: {
-  (concurrency: number): <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-    fxs: FX
-  ) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-  <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-    fxs: FX,
-    concurrency: number
-  ): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-} = core.mergeBufferConcurrently
+export const toReadonlyArray: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>> = core.toReadonlyArray
 
 /**
- * Merge together multiple Fx into a single Fx that will emit the results of all Fx
- * allowing only 1 Fx to run at a time.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const mergeSwitch = <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
-> => core.mergeSwitch(fxs)
+export const slice: {
+  (drop: number, take: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, drop: number, take: number): Fx<R, E, A>
+} = dual(3, core.slice)
 
 /**
- * Merge together multiple Fx into a single Fx that will emit the results of the
- * first Fx to emit a value.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const race: <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> = core.race
+export const take: {
+  (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>
+} = dual(2, core.take)
 
 /**
- * Schedule an Effect to run using the provided Schedule, emitting its success of failure
- * at the intervals specified by the Schedule.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromScheduled: {
-  <R2>(scheduled: Schedule.Schedule<R2, unknown, unknown>): <R, E, A>(fx: Effect.Effect<R, E, A>) => Fx<R | R2, E, A>
-  <R, E, A, R2>(fx: Effect.Effect<R, E, A>, scheduled: Schedule.Schedule<R2, unknown, unknown>): Fx<R | R2, E, A>
-} = core.fromScheduled
+export const drop: {
+  (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>
+} = dual(2, core.drop)
 
 /**
- * Schedule an Effect to run at the specified duration.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const periodic: {
-  (duration: DurationInput): <R, E, A>(fx: Effect.Effect<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Effect.Effect<R, E, A>, duration: DurationInput): Fx<R, E, A>
-} = core.periodic
+export const skipRepeats: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = core.skipRepeats
 
 /**
- * Consume a Dequeue as soon as values become available and emit them as a Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromDequeue: {
-  <A>(dequeue: Queue.Dequeue<A>): Fx<never, never, A>
-  <I, A>(dequeue: Context.Dequeue<I, A>): Fx<I, never, A>
-} = internal.fromDequeue
+export const skipRepeatsWith: {
+  <A>(eq: Equivalence.Equivalence<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, eq: Equivalence.Equivalence<A>): Fx<R, E, A>
+} = dual(2, core.skipRepeatsWith)
 
 /**
- * Consume a PubSub as soon as values become available and emit them as a Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromPubSub: {
-  <A>(PubSub: PubSub.PubSub<A>): Fx<Scope.Scope, never, A>
-  <I, A>(PubSub: Context.PubSub<I, A>): Fx<Scope.Scope | I, never, A>
-} = internal.fromPubSub
-
-/* #endregion */
-
-/* #region Running */
+export const empty: Fx<never, never, never> = core.empty
 
 /**
- * Run an Fx to completion with the provided Sink. The
- * Effect will resolve with the first Error of the Fx.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const run: {
-  <E, A, R2>(
-    sink: Sink.WithContext<R2, E, A>
-  ): <R>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, never, unknown>
-
-  <R, E, A, R2>(
-    fx: Fx<R, E, A>,
-    sink: Sink.WithContext<R2, E, A>
-  ): Effect.Effect<R | R2, never, unknown>
-} = dual(2, internalRun.run)
+export const never: Fx<never, never, never> = core.never
 
 /**
- * Observe an Fx with the provided success value handler. The
- * Effect will resolve with the first Error of the Fx.
- *
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const observe: {
-  <A, R2, E2>(
-    onSuccees: (a: A) => Effect.Effect<R2, E2, unknown>
-  ): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, E | E2, void>
-  <R, E, A, R2, E2>(
-    fx: Fx<R, E, A>,
-    onSuccees: (a: A) => Effect.Effect<R2, E2, unknown>
-  ): Effect.Effect<R | R2, E | E2, void>
-} = dual(2, core.observe)
+export const padWith: {
+  <B, C>(start: Iterable<B>, end: Iterable<C>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B | C>
+  <R, E, A, B, C>(fx: Fx<R, E, A>, start: Iterable<B>, end: Iterable<C>): Fx<R, E, A | B | C>
+} = dual(3, core.padWith)
 
 /**
- * Run an Fx to completion. The Effect will resolve with the first Error of the Fx.
- *
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const drain: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void> = core.drain
+export const prependAll: {
+  <B>(start: Iterable<B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>
+  <R, E, A, B>(fx: Fx<R, E, A>, start: Iterable<B>): Fx<R, E, A | B>
+} = dual(2, core.prependAll)
 
 /**
- * Reduce an Fx to a single value.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const reduce: {
-  <A, B>(seed: B, f: (acc: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, B>
-  <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<R, E, B>
-} = core.reduce
+export const appendAll: {
+  <C>(end: Iterable<C>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | C>
+  <R, E, A, C>(fx: Fx<R, E, A>, end: Iterable<C>): Fx<R, E, A | C>
+} = dual(2, core.appendAll)
 
 /**
- * Run an Fx to completion, collecting all emitted values into an Array.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const toArray: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, Array<A>> = core.toArray
+export const prepend: {
+  <B>(start: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>
+  <R, E, A, B>(fx: Fx<R, E, A>, start: B): Fx<R, E, A | B>
+} = dual(2, core.prepend)
 
 /**
- * Run an Fx to completion, collecting all emitted values into a ReadonlyArray.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const toReadonlyArray: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>> = core.toReadonlyArray
+export const append: {
+  <C>(end: C): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | C>
+  <R, E, A, C>(fx: Fx<R, E, A>, end: C): Fx<R, E, A | C>
+} = dual(2, core.append)
 
 /**
- * Run an Fx to completion, collecting all emitted values into a Chunk.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const toChunk: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>> = core.toChunk
+export const scan: {
+  <B, A>(seed: B, f: (b: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
+  <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (b: B, a: A) => B): Fx<R, E, B>
+} = dual(3, core.scan)
 
 /**
- * Consume an Fx and place its values into an Enqueue.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const toEnqueue: {
-  <A, B>(enqueue: Queue.Enqueue<A | B>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void>
-  <I, A, B>(enqueue: Context.Enqueue<I, A | B>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<I | R, E, void>
-  <R, E, A, B>(fx: Fx<R, E, A>, enqueue: Queue.Enqueue<A | B>): Effect.Effect<R, E, void>
-  <R, E, I, A, B>(fx: Fx<R, E, A>, enqueue: Context.Enqueue<I, A | B>): Effect.Effect<R, E, void>
-} = internal.toEnqueue
+export const flatMapWithStrategy: {
+  <A, R2, E2, B>(
+    f: (a: A) => Fx<R2, E2, B>,
+    strategy: FlattenStrategy,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
 
-/* #endregion */
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Fx<R2, E2, B>,
+    strategy: FlattenStrategy,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(4, core.flatMapWithStrategy)
 
-/* #region Combinators */
+const isDataFirstFx = (args: IArguments) => isFx(args[0])
 
 /**
- * Map over the success value of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const map: {
-  <A, B>(f: (a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
-  <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B>
-} = core.map
+export const flatMap: {
+  <A, R2, E2, B>(
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
 
-/**
- * Map over both failure and success values of an Fx.
- * @since 1.18.0
- * @category combinators
- */
-export const mapBoth: {
-  <E, E2, A, B>(
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => B }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R, E2, B>
-  <R, E, A, E2, B>(
+  <R, E, A, R2, E2, B>(
     fx: Fx<R, E, A>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => B }
-  ): Fx<R, E2, B>
-} = core.mapBoth
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.flatMap)
 
 /**
- * Filter the success value of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const filter: {
-  <A, B extends A>(f: (a: A) => a is B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
-  <A>(f: (a: A) => boolean): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A, B extends A>(fx: Fx<R, E, A>, f: (a: A) => a is B): Fx<R, E, B>
-  <R, E, A>(fx: Fx<R, E, A>, f: (a: A) => boolean): Fx<R, E, A>
-} = core.filter
+export const flatMapEffect: {
+  <A, R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
 
-/**
- * Filter and map the success value of an Fx.
- * @since 1.18.0
- * @category combinators
- */
-export const filterMap: {
-  <A, B>(f: (a: A) => Option.Option<B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
-  <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B>
-} = core.filterMap
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.flatMapEffect)
 
 /**
- * Unwrap Options by filtering any None values.
- * @since 1.18.0
- * @category combinators
- */
-export const compact: <R, E, A>(fx: Fx<R, E, Option.Option<A>>) => Fx<R, E, A> = core.compact
-/**
- * Map over the Cause  of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const mapErrorCause: {
-  <E, E2>(f: (a: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <R, E, A, E2>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => Cause.Cause<E2>): Fx<R, E2, A>
-} = core.mapErrorCause
+export const switchMap: {
+  <A, R2, E2, B>(
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
 
-/**
- * Map over the Error of an Fx.
- * @since 1.18.0
- * @category errors
- */
-export const mapError: {
-  <E, E2>(f: (a: E) => E2): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <R, E, A, E2>(fx: Fx<R, E, A>, f: (a: E) => E2): Fx<R, E2, A>
-} = core.mapError
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.switchMap)
 
 /**
- * Filter the Cause of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterErrorCause: {
-  <E, E2 extends E>(f: (a: Cause.Cause<E>) => a is Cause.Cause<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <E>(f: (a: Cause.Cause<E>) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, E2 extends E, A>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => a is Cause.Cause<E2>): Fx<R, E2, A>
-  <R, E, A>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => boolean): Fx<R, E, A>
-} = core.filterCause
+export const switchMapEffect: {
+  <A, R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.switchMapEffect)
 
 /**
- * Filter and map the Cause of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterMapCause: {
-  <E, E2>(f: (a: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <R, E, A, E2>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): Fx<R, E2, A>
-} = core.filterMapCause
+export const exhaustMap: {
+  <A, R2, E2, B>(
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.exhaustMap)
 
 /**
- * Filter the Error of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterError: {
-  <E, E2 extends E>(f: (a: E) => a is E2): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <E>(f: (a: E) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, E2 extends E, A>(fx: Fx<R, E, A>, f: (a: E) => a is E2): Fx<R, E2, A>
-  <R, E, A>(fx: Fx<R, E, A>, f: (a: E) => boolean): Fx<R, E, A>
-} = core.filterError
+export const exhaustMapEffect: {
+  <A, R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.exhaustMapEffect)
 
 /**
- * Filter and map the error of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterMapError: {
-  <E, E2>(f: (a: E) => Option.Option<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <R, E, A, E2>(fx: Fx<R, E, A>, f: (a: E) => Option.Option<E2>): Fx<R, E2, A>
-} = core.filterMapError
+export const exhaustMapLatest: {
+  <A, R2, E2, B>(
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.exhaustMapLatest)
 
 /**
- * Filter and map the error of an Fx using an Effect.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterMapErrorEffect: {
-  <E, R2, E2, B>(f: (e: E) => Effect.Effect<R2, E2, Option.Option<B>>): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2 | B, A>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, Option.Option<B>>): Fx<R | R2, E2 | B, A>
-} = core.filterMapErrorEffect
+export const exhaustMapLatestEffect: {
+  <A, R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.exhaustMapLatestEffect)
 
 /**
- * Map the success value of an Fx to another Fx, flattening the result
- * with the provided FlattenStrategy.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapWithStrategy: {
+export const flatMapConcurrently: {
   <A, R2, E2, B>(
-    f: (a: A) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
+    f: (a: A) => Fx<R2, E2, B>,
+    capacity: number,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
+
   <R, E, A, R2, E2, B>(
     fx: Fx<R, E, A>,
-    f: (a: A) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): Fx<R | R2, E | E2, B>
-} = dual(3, core.flatMapWithStrategy)
+    f: (a: A) => Fx<R2, E2, B>,
+    capacity: number,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.flatMapConcurrently)
 
 /**
- * Map the success value of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMap: {
-  <A, R2 = never, E2 = never, B = never>(
-    f: (a: A) => FxInput<R2, E2, B>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = core.switchMap
+export const flatMapConcurrentlyEffect: {
+  <A, R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    capacity: number,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+    capacity: number,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E | E2, B>
+} = dual(isDataFirstFx, core.flatMapConcurrentlyEffect)
 
 /**
- * Map the success value of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchLatest: {
-  <R, E, R2, E2, B>(fx: Fx<R, E, FxInput<R2, E2, B>>): Fx<R | R2, E | E2, B>
-} = core.switchMap((x) => x)
+export const concatMap: {
+  <A, R2, E2, B>(
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R | R2, E | E2, B>
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<Scope.Scope | R | R2, E | E2, B>
+} = dual(isDataFirstFx, core.concatMap)
 
 /**
- * Map the success value of an Fx to another Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMap: {
-  <A, R2 = never, E2 = never, B = never>(
-    f: (a: A) => FxInput<R2, E2, B>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = core.exhaustMap
+export const fromFxEffect: <R, E, R2, E2, B>(effect: Effect.Effect<R, E, Fx<R2, E2, B>>) => Fx<R | R2, E | E2, B> =
+  core.fromFxEffect
 
 /**
- * Flatten a nested Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaust: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A> = core.exhaust
+export const continueWith: {
+  <R2, E2, B>(f: () => Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: () => Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
+} = dual(2, core.continueWith)
 
 /**
- * Map the success value of an Fx to another Fx, prefering the first
- * until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapLatest: {
-  <A, R2 = never, E2 = never, B = never>(
-    f: (a: A) => FxInput<R2, E2, B>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = core.exhaustMapLatest
+export const orElseCause: {
+  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>): Fx<R | R2, E2, A | B>
+} = dual(2, core.orElseCause)
 
 /**
- * Flatten a nested Fx, prefering the first until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustLatest: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A> = core.exhaustLatest
+export const orElse: {
+  <E, R2, E2, B>(f: (error: E) => Fx<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (error: E) => Fx<R2, E2, B>): Fx<R | R2, E2, A | B>
+} = dual(2, core.orElse)
 
 /**
- * Map the success value of an Fx to another Fx with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMap: {
-  <A, R2 = never, E2 = never, B = never>(
-    f: (a: A) => FxInput<R2, E2, B>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = core.flatMap
+export const suspend: <R, E, A>(f: () => Fx<R, E, A>) => Fx<R, E, A> = core.suspend
 
 /**
- * Map the success value of an Fx to another Fx with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatten: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A> = core.flatten
+export const mergeWithStrategy: {
+  (strategy: MergeStrategy): <FX extends ReadonlyArray<Fx<any, any, any>>>(
+    fx: FX
+  ) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
+
+  <const FX extends ReadonlyArray<Fx<any, any, any>>>(
+    fx: FX,
+    stategy: MergeStrategy
+  ): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
+} = dual(2, core.mergeWithStrategy)
 
 /**
- * Map the success value of an Fx to another Fx with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapConcurrently: {
-  <A, R2 = never, E2 = never, B = never>(
-    f: (a: A) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): Fx<R | R2, E | E2, B>
-} = core.flatMapConcurrently
+export const merge: {
+  <R2, E2, B>(other: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
+} = dual(
+  2,
+  core.merge
+)
 
 /**
- * Map the success value of an Fx to another Fx one at a time.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const concatMap: {
-  <A, R2 = never, E2 = never, B = never>(
-    f: (a: A) => FxInput<R2, E2, B>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = core.concatMap
+export const mergeAll: <FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> = core.mergeAll
 
 /**
- * Skip and take a number of values from an Fx.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const slice: {
-  (skip: number, take: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, skip: number, take: number): Fx<R, E, A>
-} = core.slice
+export const mergeOrdered: <FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> = core.mergeOrdered
 
 /**
- * Take a number of values from an Fx.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const take: {
-  (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>
-} = core.take
+export const mergeOrderedConcurrently: <FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX,
+  concurrency: number
+) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> = core.mergeOrderedConcurrently
 
 /**
- * Drop a number of values from an Fx.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const drop: {
-  (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>
-} = core.drop
+export const mergeSwitch: <FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> = core.mergeSwitch
 
 /**
- * Take values from an Fx while the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
 export const takeWhile: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = core.takeWhile
+  <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
+  <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, B>
+  <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>
+} = dual(2, core.takeWhile)
 
 /**
- * Take values from an Fx until the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
 export const takeUntil: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = core.takeUntil
+  <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, Exclude<A, B>>
+  <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, Exclude<A, B>>
+  <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>
+} = dual(2, core.takeUntil)
 
 /**
- * Drop values from an Fx while the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
 export const dropWhile: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = core.dropWhile
+  <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, Exclude<A, B>>
+  <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, Exclude<A, B>>
+  <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>
+} = dual(2, core.dropWhile)
 
 /**
- * Drop values from an Fx until the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
 export const dropUntil: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = core.dropUntil
+  <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A | B>
+  <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, A | B>
+  <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>
+} = dual(2, core.dropUntil)
 
 /**
- * Drop values from an Fx after the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
 export const dropAfter: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = core.dropAfter
+  <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, Exclude<A, B>>
+  <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, Exclude<A, B>>
+  <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>
+} = dual(2, core.dropAfter)
 
 /**
- * Concatenate an Fx after the successful completion of another Fx
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const continueWith: {
-  <R2, E2, B>(f: () => Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: () => Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
-} = core.continueWith
+export const takeWhileEffect: {
+  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
+} = dual(2, core.takeWhileEffect)
 
 /**
- * Concatenate an Fx after the failure of another Fx
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const orElse: {
-  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, A>): Fx<R | R2, E2, A | B>
-} = core.recoverWith
+export const takeUntiEffect: {
+  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
+} = dual(2, core.takeUntilEffect)
 
 /**
- * Map the success value of an Fx to an Effect, doesn't fork any fibers like flatMap* etc.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const mapEffect: {
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = core.mapEffect
+export const dropWhileEffect: {
+  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
+} = dual(2, core.dropWhileEffect)
 
 /**
- * Perform an Effect for each value emitted by an Fx, not affecting the output of the Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const tap: {
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, A>
-} = core.tap
+export const dropUntilEffect: {
+  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
+} = dual(2, core.dropUntilEffect)
 
 /**
- * Filter the success value of an Fx with an Effect.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const filterEffect: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = core.filterEffect
+export const dropAfterEffect: {
+  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
+} = dual(2, core.dropAfterEffect)
 
 /**
- * Filter and map the success value of an Fx with an Effect.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const filterMapEffect: {
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): Fx<R | R2, E | E2, B>
-} = core.filterMapEffect
+export const during: {
+  <R2, E2, A, R3, E3, B>(
+    window: Fx<R2, E2, Fx<R3, E3, B>>
+  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, A>
+  <R, E, A, R2, E2, R3, E3, B>(
+    fx: Fx<R, E, A>,
+    window: Fx<R2, E2, Fx<R3, E3, B>>
+  ): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, A>
+} = dual(2, core.during)
 
 /**
- * Apply a function to the constructed Effect that represents the running Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
+ */
+export const since: {
+  <R2, E2, B>(window: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, A>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, window: Fx<R2, E2, B>): Fx<R | R2 | Scope.Scope, E | E2, A>
+} = dual(2, core.since)
+
+/**
+ * @since 1.20.0
+ */
+export const until: {
+  <R2, E2, B>(window: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, A>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, window: Fx<R2, E2, B>): Fx<R | R2 | Scope.Scope, E | E2, A>
+} = dual(2, core.until)
+
+/**
+ * @since 1.20.0
  */
 export const middleware: {
+  <R, R3, E, A>(
+    effect: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R3, never, unknown>,
+    sink?: ((sink: Sink.Sink<never, E, A>) => Sink.Sink<R, E, A>) | undefined
+  ): <E, A>(fx: Fx<R, E, A>) => Fx<R3, E, A>
+
+  <R, E, A, R3>(
+    fx: Fx<R, E, A>,
+    effect: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R3, never, unknown>,
+    sink?: ((sink: Sink.Sink<never, E, A>) => Sink.Sink<R, E, A>) | undefined
+  ): Fx<R3, E, A>
+} = dual(isDataFirstFx, core.middleware)
+
+/**
+ * @since 1.20.0
+ */
+export const onExit: {
+  <R2>(
+    f: (exit: Exit.Exit<never, unknown>) => Effect.Effect<R2, never, unknown>
+  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2, E, A>
+
   <R, E, A, R2>(
-    f: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>,
-    g?: (sink: Sink.Sink<E, A>) => Sink.Sink<E, A>
-  ): (fx: Fx<R, E, A>) => Fx<R2, E, A>
+    fx: Fx<R, E, A>,
+    f: (exit: Exit.Exit<never, unknown>) => Effect.Effect<R2, never, unknown>
+  ): Fx<R | R2, E, A>
+} = dual(2, core.onExit)
+
+/**
+ * @since 1.20.0
+ */
+export const onInterrupt: {
+  <R2>(
+    f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, unknown>
+  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2, E, A>
   <R, E, A, R2>(
     fx: Fx<R, E, A>,
-    f: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>,
-    g?: (sink: Sink.Sink<E, A>) => Sink.Sink<E, A>
-  ): Fx<R2, E, A>
-} = core.middleware
+    f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, unknown>
+  ): Fx<R | R2, E, A>
+} = dual(2, core.onInterrupt)
 
 /**
- * Accumulate a value over the success values of an Fx and atomically produce derived value.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const loop: {
-  <A, B, C>(seed: B, f: (acc: B, a: A) => readonly [C, B]): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, C>
-  <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<R, E, C>
-} = core.loop
+export const onError: {
+  <R2>(f: (cause: Cause.Cause<never>) => Effect.Effect<R2, never, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2, E, A>
+  <R, E, A, R2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<never>) => Effect.Effect<R2, never, unknown>): Fx<R | R2, E, A>
+} = dual(2, core.onError)
 
 /**
- * Emit values with their previously emitted values when possible.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const withPrevious: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, readonly [previous: Option.Option<A>, current: A]> = <
-  R,
-  E,
-  A
->(fx: Fx<R, E, A>): Fx<R, E, readonly [previous: Option.Option<A>, current: A]> =>
-  loop(
-    fx,
-    Option.none<A>(),
-    (previous, current) => [[previous, current] as const, Option.some(current)]
-  )
+export const scoped: <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, Scope.Scope>, E, A> = core.scoped
 
 /**
- * Accumulate a value over the success values of an Fx and atomically produce derived value
- * useing an Effect. A SynchronizedRef is utilized to ensure ordering of events.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const loopEffect: {
-  <B, A, R2, E2, C>(
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, C>
+export const annotateLogs: {
+  (key: string | Record<string, unknown>, value?: unknown): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, key: string | Record<string, unknown>, value?: unknown): Fx<R, E, A>
+} = dual(isDataFirstFx, core.annotateLogs)
 
-  <R, E, A, B, R2, E2, C>(
-    fx: Fx<R, E, A>,
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
-  ): Fx<R | R2, E | E2, C>
-} = core.loopEffect
+/**
+ * @since 1.20.0
+ */
+export const annotateSpans: {
+  (key: string | Record<string, unknown>, value?: unknown): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, key: string | Record<string, unknown>, value?: unknown): Fx<R, E, A>
+} = dual(isDataFirstFx, core.annotateSpans)
 
 /**
- * Prepends a value to the beginning of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const startWith: {
-  <B>(value: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>
-  <R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, A | B>
-} = core.startWith
+export const interruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = core.interruptible
 
 /**
- * Appends a value to the end of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const endWith: {
-  <B>(value: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>
-  <R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, A | B>
-} = core.endWith
+export const uninterruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = core.uninterruptible
 
 /**
- * Run a reducer over the success values of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const scan: {
-  <A, B>(seed: B, f: (acc: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
-  <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Fx<R, E, B>
-} = core.scan
+export const locally: {
+  <A>(self: FiberRef.FiberRef<A>, value: A): <R, E, B>(fx: Fx<R, E, B>) => Fx<R, E, B>
+  <R, E, B, A>(use: Fx<R, E, B>, self: FiberRef.FiberRef<A>, value: A): Fx<R, E, B>
+} = dual(3, core.locally)
 
 /**
- * Run an Effect-ful reducer over the success values of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const scanEffect: {
-  <A, B, R2, E2>(
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<R2, E2, B>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, B, R2, E2>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = core.scanEffect
+export const locallyWith: {
+  <A>(self: FiberRef.FiberRef<A>, f: (a: A) => A): <R, E, B>(fx: Fx<R, E, B>) => Fx<R, E, B>
+  <R, E, B, A>(use: Fx<R, E, B>, self: FiberRef.FiberRef<A>, f: (a: A) => A): Fx<R, E, B>
+} = dual(3, core.locallyWith)
 
 /**
- * Map the failures of an Fx to another Fx, flattening the result
- * with the provided FlattenStrategy.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapCauseWithStrategy: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): Fx<R | R2, E2, A | B>
-} = core.flatMapCauseWithStrategy
+export const withTracerTiming: {
+  (enabled: boolean): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, enabled: boolean): Fx<R, E, A>
+} = dual(2, core.withTracerTiming)
 
 /**
- * Map the failures of an Fx to another Fx, flattening the result
- * with the provided FlattenStrategy.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapErrorWithStrategy: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (error: E) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (error: E) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): Fx<R | R2, E2, A | B>
-} = core.flatMapErrorWithStrategy
+export const withConcurrency: {
+  (concurrency: number | "unbounded"): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, concurrency: number | "unbounded"): Fx<R, E, A>
+} = dual(2, core.withConcurrency)
 
 /**
- * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapCause: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E2, A | B>
-} = core.flatMapCause
+export const withConfigProvider: {
+  (configProvider: ConfigProvider.ConfigProvider): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, configProvider: ConfigProvider.ConfigProvider): Fx<R, E, A>
+} = dual(2, core.withConfigProvider)
 
 /**
- * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapError: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (error: E) => FxInput<R2, E2, B>
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (error: E) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E2, A | B>
-} = core.flatMapError
+export const withLogSpan: {
+  (span: string): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, span: string): Fx<R, E, A>
+} = dual(2, core.withLogSpan)
 
 /**
- * Map the failures of an Fx to another Fx with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapCauseConcurrently: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): Fx<R | R2, E2, A | B>
-} = core.flatMapCauseConcurrently
+export const withMaxOpsBeforeYield: {
+  (maxOps: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, maxOps: number): Fx<R, E, A>
+} = dual(2, core.withMaxOpsBeforeYield)
 
 /**
- * Map the failures of an Fx to another Fx with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapErrorConcurrently: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (error: E) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (error: E) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): Fx<R | R2, E2, A | B>
-} = core.flatMapErrorConcurrently
+export const withParentSpan: {
+  (parentSpan: Tracer.ParentSpan): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, parentSpan: Tracer.ParentSpan): Fx<R, E, A>
+} = dual(2, core.withParentSpan)
 
 /**
- * Map the failures of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMapCause: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E2, A | B>
-} = core.switchMapCause
+export const withRequestBatching: {
+  (requestBatching: boolean): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, requestBatching: boolean): Fx<R, E, A>
+} = dual(2, core.withRequestBatching)
 
 /**
- * Map the failures of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMapError: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (error: E) => FxInput<R2, E2, B>
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (error: E) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E2, A | B>
-} = core.switchMapError
+export const withRequestCache: {
+  (cache: Request.Cache): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, cache: Request.Cache): Fx<R, E, A>
+} = dual(2, core.withRequestCache)
 
 /**
- * Map the failures of an Fx to another Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapCause: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E2, A | B>
-} = core.exhaustMapCause
+export const withRequestCaching: {
+  (requestCaching: boolean): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, requestCaching: boolean): Fx<R, E, A>
+} = dual(2, core.withRequestCaching)
 
 /**
- * Map the failures of an Fx to another Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapError: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (error: E) => FxInput<R2, E2, B>
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (error: E) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E2, A | B>
-} = core.exhaustMapError
+export const withTracer: {
+  (tracer: Tracer.Tracer): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, tracer: Tracer.Tracer): Fx<R, E, A>
+} = dual(2, core.withTracer)
+
+/**
+ * @since 1.20.0
+ */
+export const acquireUseRelease: {
+  <A, R2, E2, B, R3, E3, C>(
+    use: (a: A) => Fx<R2, E2, B>,
+    release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, C>
+  ): <R, E>(acquire: Effect.Effect<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, B>
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    acquire: Effect.Effect<R, E, A>,
+    use: (a: A) => Fx<R2, E2, B>,
+    release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, C>
+  ): Fx<R | R2 | R3, E | E2 | E3, B>
+} = dual(3, core.acquireUseRelease)
 
 /**
- * Map the failures of an Fx to another Fx, prefering the first
- * until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapLatestCause: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E2, A | B>
-} = core.exhaustMapLatestCause
+export const withSpan: {
+  (name: string, options?: {
+    readonly attributes?: Record<string, unknown>
+    readonly links?: ReadonlyArray<Tracer.SpanLink>
+    readonly parent?: Tracer.ParentSpan
+    readonly root?: boolean
+    readonly context?: Ctx.Context<never>
+  }): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>
+
+  <R, E, A>(self: Fx<R, E, A>, name: string, options?: {
+    readonly attributes?: Record<string, unknown>
+    readonly links?: ReadonlyArray<Tracer.SpanLink>
+    readonly parent?: Tracer.ParentSpan
+    readonly root?: boolean
+    readonly context?: Ctx.Context<never>
+  }): Fx<R, E, A>
+} = dual(3, core.withSpan)
 
 /**
- * Map the failures of an Fx to another Fx,  prefering the first
- * until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapLatestError: {
-  <E, R2 = never, E2 = never, B = never>(
-    f: (error: E) => FxInput<R2, E2, B>
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>
-  <R, E, A, R2 = never, E2 = never, B = never>(
-    fx: Fx<R, E, A>,
-    f: (error: E) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E2, A | B>
-} = core.exhaustMapLatestError
+export const provideContext: {
+  <R2>(context: Ctx.Context<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>
+  <R, E, A, R2>(fx: Fx<R, E, A>, context: Ctx.Context<R2>): Fx<Exclude<R, R2>, E, A>
+} = dual(2, core.provideContext)
 
 /**
- * Map over the failures and successes of an Fx, flattening both using the same strategy.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchCauseWithStrategy: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly strategy: FlattenStrategy
-    }
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly strategy: FlattenStrategy
-    }
-  ): Fx<R | R2, E2 | E3, B | C>
-} = core.matchCauseWithStrategy
+export const provideLayer: {
+  <R2, E2, S>(layer: Layer.Layer<R2, E2, S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, S>, E | E2, A>
+  <R, E, A, R2, E2, S>(fx: Fx<R, E, A>, layer: Layer.Layer<R2, E2, S>): Fx<R2 | Exclude<R, S>, E | E2, A>
+} = dual(2, core.provideLayer)
 
 /**
- * Map over the failures and successes of an Fx, flattening both using the same strategy.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchErrorWithStrategy: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly strategy: FlattenStrategy
-    }
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly strategy: FlattenStrategy
-    }
-  ): Fx<R | R2, E2 | E3, B | C>
-} = core.matchErrorWithStrategy
+export const provideRuntime: {
+  <R2>(runtime: Runtime.Runtime<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>
+  <R, E, A, R2>(fx: Fx<R, E, A>, runtime: Runtime.Runtime<R2>): Fx<Exclude<R, R2>, E, A>
+} = dual(2, core.provideRuntime)
 
 /**
- * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchCause: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.matchCause
+export const provideService: {
+  <I, S>(service: Ctx.Tag<I, S>, instance: S): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, I>, E, A>
+  <R, E, A, I, S>(fx: Fx<R, E, A>, service: Ctx.Tag<I, S>, instance: S): Fx<Exclude<R, I>, E, A>
+} = dual(3, core.provideService)
 
 /**
- * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const match: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: { readonly onFailure: (error: E) => FxInput<R2, E2, B>; readonly onSuccess: (a: A) => FxInput<R3, E3, C> }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
+export const provideServiceEffect: {
+  <I, S, R2, E2>(
+    service: Ctx.Tag<I, S>,
+    instance: Effect.Effect<R2, E2, S>
+  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, I>, E | E2, A>
+  <R, E, A, I, S, R2, E2>(
     fx: Fx<R, E, A>,
-    options: { readonly onFailure: (error: E) => FxInput<R2, E2, B>; readonly onSuccess: (a: A) => FxInput<R3, E3, C> }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.match
+    service: Ctx.Tag<I, S>,
+    instance: Effect.Effect<R2, E2, S>
+  ): Fx<R2 | Exclude<R, I>, E | E2, A>
+} = dual(3, core.provideServiceEffect)
 
 /**
- * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchCauseConcurrently: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly concurrency: number
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
+export const provide: {
+  <R2>(context: Ctx.Context<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>
+  <R2>(runtime: Runtime.Runtime<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>
+  <R2, E2, S>(layer: Layer.Layer<R2, E2, S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, S>, E | E2, A>
+  <R2 = never, E2 = never, S = never>(
+    provide: Layer.Layer<R2, E2, S> | Ctx.Context<S> | Runtime.Runtime<S>
+  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, S>, E | E2, A>
+
+  <R, E, A, R2>(fx: Fx<R, E, A>, context: Ctx.Context<R2>): Fx<Exclude<R, R2>, E, A>
+  <R, E, A, R2>(fx: Fx<R, E, A>, runtime: Runtime.Runtime<R2>): Fx<Exclude<R, R2>, E, A>
+  <R, E, A, R2, E2, S>(fx: Fx<R, E, A>, layer: Layer.Layer<R2, E2, S>): Fx<R2 | Exclude<R, S>, E | E2, A>
+  <R, E, A, R2 = never, E2 = never, S = never>(
     fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly concurrency: number
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.matchCauseConcurrently
+    provide: Layer.Layer<R2, E2, S> | Ctx.Context<S> | Runtime.Runtime<S>
+  ): Fx<R2 | Exclude<R, S>, E | E2, A>
+} = dual(2, core.provide)
 
 /**
- * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchErrorConcurrently: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly concurrency: number
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly concurrency: number
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.matchErrorConcurrently
+export const share: {
+  <R2, E2, A>(subject: Subject.Subject<R2, E2, A>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E, A>
+  <R, E, A, R2>(fx: Fx<R, E, A>, subject: Subject.Subject<R2, E, A>): Fx<R | R2 | Scope.Scope, E, A>
+} = dual(2, coreShare.share)
 
 /**
- * Map over the failures and successes of an Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMatchCause: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.switchMatchCause
+export const multicast: <R, E, A>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R, E, A> = coreShare.multicast
 
 /**
- * Map over the failures and successes of an Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMatch: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: { readonly onFailure: (error: E) => FxInput<R2, E2, B>; readonly onSuccess: (a: A) => FxInput<R3, E3, C> }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: { readonly onFailure: (error: E) => FxInput<R2, E2, B>; readonly onSuccess: (a: A) => FxInput<R3, E3, C> }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.switchMatch
+export const hold: <R, E, A>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R, E, A> = coreShare.hold
 
 /**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMatchCause: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.exhaustMatchCause
+export const replay: {
+  (capacity: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, capacity: number): Fx<Scope.Scope | R, E, A>
+} = dual(2, coreShare.replay)
 
 /**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMatch: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: { readonly onFailure: (error: E) => FxInput<R2, E2, B>; readonly onSuccess: (a: A) => FxInput<R3, E3, C> }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: { readonly onFailure: (error: E) => FxInput<R2, E2, B>; readonly onSuccess: (a: A) => FxInput<R3, E3, C> }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.exhaustMatch
+export const mapCause: {
+  <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
+  <R, E, A, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Fx<R, E2, A>
+} = dual(2, core.mapCause)
 
 /**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and starting the latest Fx when the first completes
- * if they are not the same Fx.
- *
- * @since 1.18.0
- * @category flattening
- */
-export const exhaustLatestMatchCause: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.exhaustLatestMatchCause
+ * @since 1.20.0
+ */
+export const mapError: {
+  <E, E2>(f: (e: E) => E2): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
+  <R, E, A, E2>(fx: Fx<R, E, A>, f: (e: E) => E2): Fx<R, E2, A>
+} = dual(2, core.mapError)
 
 /**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and starting the latest Fx when the first completes
- * if they are not the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustLatestMatch: {
-  <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    options: { readonly onFailure: (error: E) => FxInput<R2, E2, B>; readonly onSuccess: (a: A) => FxInput<R3, E3, C> }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    fx: Fx<R, E, A>,
-    options: { readonly onFailure: (error: E) => FxInput<R2, E2, B>; readonly onSuccess: (a: A) => FxInput<R3, E3, C> }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = core.exhaustLatestMatch
+export const mapBoth: {
+  <E, E2, A, B>(f: (e: E) => E2, g: (a: A) => B): <R>(fx: Fx<R, E, A>) => Fx<R, E2, B>
+  <R, E, A, B, C>(fx: Fx<R, E, A>, f: (e: E) => B, g: (a: A) => C): Fx<R, B, C>
+} = dual(3, core.mapBoth)
 
 /**
- * Listen to the events of an Fx within the provided window. When the window Fx
- * emits the inner stream, the fx will begin allowing events to pass through,
- * and when the inner stream emits, the fx will be interrupted.
- *
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const during: {
-  <R2, E2, R3, E3>(
-    window: Fx<R2, E2, Fx<R3, E3, unknown>>
-  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, A>
-
-  <R, E, A, R2, E2, R3, E3>(
-    fx: Fx<R, E, A>,
-    window: Fx<R2, E2, Fx<R3, E3, unknown>>
-  ): Fx<R | R2 | R3, E | E2 | E3, A>
-} = core.during
+export const filterCause: {
+  <E>(f: (cause: Cause.Cause<E>) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => boolean): Fx<R, E, A>
+} = dual(2, core.filterCause)
 
 /**
- * Listen to the events of an Fx after the provided window emits.
- *
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const since: {
-  <R2, E2>(window: Fx<R2, E2, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, window: Fx<R2, E2, unknown>): Fx<R | R2, E | E2, A>
-} = core.since
+export const filterError: {
+  <E>(f: (e: E) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, f: (e: E) => boolean): Fx<R, E, A>
+} = dual(2, core.filterError)
 
 /**
- * Listen to the events of an Fx until the provided window emits.
- *
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const until: {
-  <R2, E2>(window: Fx<R2, E2, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, window: Fx<R2, E2, unknown>): Fx<R | R2, E | E2, A>
-} = core.until
+export const filterMapCause: {
+  <E, E2>(f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
+  <R, E, A, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): Fx<R, E2, A>
+} = dual(2, core.filterMapCause)
 
 /**
- * Provide the environment to an Fx.
- *
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export const provide: {
-  <R2, E2, S>(layer: Layer.Layer<R2, E2, S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, S>, E2 | E, A>
-  <R2>(runtime: Runtime.Runtime<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>
-  <R2>(context: Context.Context<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>
-  <R, E, A, R2, E2, S>(fx: Fx<R, E, A>, layer: Layer.Layer<R2, E2, S>): Fx<Exclude<R, S> | R2, E | E2, A>
-  <R, E, A, R2>(fx: Fx<R, E, A>, runtime: Runtime.Runtime<R2>): Fx<Exclude<R, R2>, E, A>
-  <R, E, A, R2>(fx: Fx<R, E, A>, context: Context.Context<R2>): Fx<Exclude<R, R2>, E, A>
-} = core.provide
+export const filterMapError: {
+  <E, E2>(f: (e: E) => Option.Option<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
+  <R, E, A, E2>(fx: Fx<R, E, A>, f: (e: E) => Option.Option<E2>): Fx<R, E2, A>
+} = dual(2, core.filterMapError)
 
 /**
- * Provide a service to an Fx using a Tag.
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export const provideService: {
-  <I, S>(tag: Context.Tag<I, S>, service: S): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, I>, E, A>
-  <R, E, A, I, S>(fx: Fx<R, E, A>, tag: Context.Tag<I, S>, service: S): Fx<Exclude<R, I>, E, A>
-} = core.provideService
+export const mapCauseEffect: {
+  <R2, E2, E3>(f: (cause: Cause.Cause<E2>) => Effect.Effect<R2, E3, Cause.Cause<E3>>): <R, E, A>(
+    fx: Fx<R, E, A>
+  ) => Fx<R | R2, E2 | E3, A>
+  <R, E, A, R2, E2, E3>(
+    fx: Fx<R, E, A>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Cause.Cause<E3>>
+  ): Fx<R | R2, E2 | E3, A>
+} = dual(2, core.mapCauseEffect)
 
 /**
- * Provide a service using an Effect to an Fx using a Tag.
- *
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export const provideServiceEffect: {
-  <I, S, R2, E2>(
-    tag: Context.Tag<I, S>,
-    service: Effect.Effect<R2, E2, S>
-  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, I>, E, A>
-  <R, E, A, I, S, R2, E2>(
-    fx: Fx<R, E, A>,
-    tag: Context.Tag<I, S>,
-    service: Effect.Effect<R2, E2, S>
-  ): Fx<R2 | Exclude<R, I>, E, A>
-} = core.provideServiceEffect
+export const mapErrorEffect: {
+  <R2, E2, E3>(f: (e: E2) => Effect.Effect<R2, E3, E3>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | E3, A>
+  <R, E, A, R2, E2, E3>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, E3>): Fx<R | R2, E2 | E3, A>
+} = dual(2, core.mapErrorEffect)
 
 /**
- * Skip repeated values, using the provided Equivalence to compare values.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const skipRepeatsWith: {
-  <A>(eq: Equivalence<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, eq: Equivalence<A>): Fx<R, E, A>
-} = core.skipRepeatsWith
+export const filterCauseEffect: {
+  <E, R2, E2>(f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, boolean>): <R, A>(
+    fx: Fx<R, E, A>
+  ) => Fx<R | R2, E2, A>
+  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E2, A>
+} = dual(2, core.filterCauseEffect)
 
 /**
- * Skip repeated values, using @effect/data/Equal for value comparison.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const skipRepeats: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = core.skipRepeats
+export const filterErrorEffect: {
+  <E, R2, E2>(f: (e: E) => Effect.Effect<R2, E2, boolean>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A>
+  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E2, A>
+} = dual(2, core.filterErrorEffect)
 
 /**
- * Sample the values of an Fx, or Effect, during the events of another Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const snapshot: {
-  <R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(
-    sampled: FxInput<R2, E2, B>,
-    f: (a: A, b: B) => Effect.Effect<R3, E3, C>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, C>
-  <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
+export const filterMapCauseEffect: {
+  <R2, E2, E3>(f: (cause: Cause.Cause<E2>) => Effect.Effect<R2, E2, Option.Option<Cause.Cause<E3>>>): <R, E, A>(
+    fx: Fx<R, E, A>
+  ) => Fx<R | R2, E2 | E3, A>
+  <R, E, A, R2, E2, E3>(
     fx: Fx<R, E, A>,
-    sampled: FxInput<R2, E2, B>,
-    f: (a: A, b: B) => Effect.Effect<R3, E3, C>
-  ): Fx<R | R2 | R3, E | E2 | E3, C>
-} = core.snapshot
+    f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Option.Option<Cause.Cause<E3>>>
+  ): Fx<R | R2, E2 | E3, A>
+} = dual(2, core.filterMapCauseEffect)
 
 /**
- * Share the output of an Fx, or Effect, with other Fx's using the behavior of the
- * provided Subject.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export const share: <R, E, A, R2>(fx: Fx<R, E, A>, subject: Subject<R2, E, A>) => Fx<R | R2, E, A> = Share.share
+export const filterMapErrorEffect: {
+  <E, R2, E2, E3>(
+    f: (e: E) => Effect.Effect<R2, E2, Option.Option<E3>>
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | E3, A>
+  <R, E, A, R2, E2, E3>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, Option.Option<E3>>): Fx<R | R2, E2 | E3, A>
+} = dual(2, core.filterMapErrorEffect)
 
 /**
- * Effeciently share an underlying stream with multiple subscribers.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export const multicast: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = Share.multicast
+export const loopCause: {
+  <B, E, C>(
+    seed: B,
+    f: (b: B, cause: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R, C, A>
+
+  <R, E, A, B, C>(
+    fx: Fx<R, E, A>,
+    seed: B,
+    f: (b: B, cause: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]
+  ): Fx<R, C, A>
+} = dual(3, core.loopCause)
 
 /**
- * Effeciently share an underlying stream with multiple subscribers, saving the most
- * recent event and emitting it to new subscribers.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export const hold: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = Share.hold
+export const loopError: {
+  <B, E, C>(seed: B, f: (b: B, e: E) => readonly [C, B]): <R, A>(fx: Fx<R, E, A>) => Fx<R, C, A>
+  <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, e: E) => readonly [C, B]): Fx<R, C, A>
+} = dual(3, core.loopError)
 
 /**
- * Effeciently share an underlying stream with multiple subscribers,
- * saving up to the most recent `n` events and emitting them to new subscribers.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export const replay: {
-  (capacity: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, capacity: number): Fx<R, E, A>
-} = Share.replay
+export const loopCauseEffect: {
+  <B, E, R2, E2, C>(
+    seed: B,
+    f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Cause.Cause<C>, B]>
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | C, A>
+  <R, E, A, R2, E2, B, C>(
+    fx: Fx<R, E, A>,
+    seed: B,
+    f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Cause.Cause<C>, B]>
+  ): Fx<R | R2, E2 | C, A>
+} = dual(3, core.loopCauseEffect)
 
 /**
- * Create an Fx which will wait a specified duration of time where no
- * events have occurred before emitting a value.
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const debounce: {
-  (delay: DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, delay: DurationInput): Fx<R, E, A>
-} = internal.debounce
+export const loopErrorEffect: {
+  <B, E, R2, E2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [C, B]>): <R, A>(
+    fx: Fx<R, E, A>
+  ) => Fx<R | R2, E2 | C, A>
+  <R, E, A, R2, E2, B, C>(
+    fx: Fx<R, E, A>,
+    seed: B,
+    f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [C, B]>
+  ): Fx<R | R2, E2 | C, A>
+} = dual(3, core.loopErrorEffect)
 
 /**
- * Create an Fx which will wait a specified duration of time before emitting
- * an event after the last event.
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const throttle: {
-  (delay: DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, delay: DurationInput): Fx<R, E, A>
-} = internal.throttle
+export const filterMapLoopCause: {
+  <B, E, R2, E2, C>(
+    seed: B,
+    f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Option.Option<Cause.Cause<C>>, B]>
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | C, A>
+  <R, E, A, B, C>(
+    fx: Fx<R, E, A>,
+    seed: B,
+    f: (b: B, cause: Cause.Cause<E>) => readonly [Option.Option<Cause.Cause<C>>, B]
+  ): Fx<R, C, A>
+} = dual(3, core.filterMapLoopCause)
 
 /**
- * Create an Fx which will wait a specified duration of time where no
- * events have occurred before emitting a value.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const delay: {
-  (delay: DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, delay: DurationInput): Fx<R, E, A>
-} = internal.delay
+export const filterMapLoopError: {
+  <B, E, R2, E2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>): <R, A>(
+    fx: Fx<R, E, A>
+  ) => Fx<R | R2, E2 | C, A>
+  <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, e: E) => readonly [Option.Option<C>, B]): Fx<R, C, A>
+} = dual(3, core.filterMapLoopError)
 
 /**
- * Run an Effect to produce an Fx to run.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromFxEffect: <R, E, R2, E2, B>(fxEffect: Effect.Effect<R, E, Fx<R2, E2, B>>) => Fx<R | R2, E | E2, B> =
-  internal.fromFxEffect
+export const filterMapLoopCauseEffect: {
+  <B, E, R2, E2, C>(
+    seed: B,
+    f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Option.Option<Cause.Cause<C>>, B]>
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | C, A>
+  <R, E, A, R2, E2, B, C>(
+    fx: Fx<R, E, A>,
+    seed: B,
+    f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Option.Option<Cause.Cause<C>>, B]>
+  ): Fx<R | R2, E2 | C, A>
+} = dual(3, core.filterMapLoopCauseEffect)
 
 /**
- * Extract the context from an EffectGen
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type EffectGenContext<T> = [T] extends [never] ? never
-  : [T] extends [Effect.EffectGen<infer R, any, any>] ? R
-  : never
+export const filterMapLoopErrorEffect: {
+  <B, E, R2, E2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>): <R, A>(
+    fx: Fx<R, E, A>
+  ) => Fx<R | R2, E2 | C, A>
+  <R, E, A, R2, E2, B, C>(
+    fx: Fx<R, E, A>,
+    seed: B,
+    f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>
+  ): Fx<R | R2, E2 | C, A>
+} = dual(3, core.filterMapLoopErrorEffect)
 
 /**
- * Extract the error from an EffectGen
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type EffectGenError<T> = [T] extends [never] ? never
-  : [T] extends [Effect.EffectGen<any, infer E, any>] ? E
-  : never
+export const flatMapCauseWithStrategy: {
+  <E, R2, E2, B>(
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    flattenStrategy: FlattenStrategy,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    flattenStrategy: FlattenStrategy,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.flatMapCauseWithStrategy)
 
 /**
- * Extract the success value from an EffectGen
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type EffectGenSuccess<T> = [T] extends [never] ? never
-  : [T] extends [Effect.EffectGen<any, any, infer A>] ? A
-  : never
+export const flatMapErrorWithStrategy: {
+  <E, R2, E2, B>(
+    f: (e: E) => Fx<R2, E2, B>,
+    flattenStrategy: FlattenStrategy,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (e: E) => Fx<R2, E2, B>,
+    flattenStrategy: FlattenStrategy,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.flatMapErrorWithStrategy)
 
 /**
- * Utilize Effect.gen to construct an Fx
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export function gen<Yield extends Effect.EffectGen<any, any, any>, R, E, A>(
-  f: (_: Effect.Adapter) => Generator<Yield, Fx<R, E, A>, any>
-): Fx<R | EffectGenContext<Yield>, E | EffectGenError<Yield>, A> {
-  return fromFxEffect(Effect.gen(f))
-}
+export const switchMapCause: {
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+
+  <E, R2, E2, B>(
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.switchMapCause)
 
 /**
- * Utilize Effect.gen to construct an Fx
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export function genScoped<Yield extends Effect.EffectGen<any, any, any>, R, E, A>(
-  f: (_: Effect.Adapter) => Generator<Yield, Fx<R, E, A>, any>
-): Fx<Exclude<R | EffectGenContext<Yield>, Scope.Scope>, E | EffectGenError<Yield>, A> {
-  return scoped(fromFxEffect(Effect.gen(f)))
-}
+export const switchMapError: {
+  <E, R2, E2, B>(
+    f: (e: E) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (e: E) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.switchMapError)
 
 /**
- * Run an Effect when an Fx exits
- * @since 1.18.0
- * @category lifecycles
+ * @since 1.20.0
  */
-export const onExit: {
-  <R2>(
-    f: (exit: Exit.Exit<never, unknown>) => Effect.Effect<R2, never, unknown>
-  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E, A>
-  <R, E, A, R2>(
+export const flatMapCause: {
+  <E, R2, E2, B>(
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+
+  <R, E, A, R2, E2, B>(
     fx: Fx<R, E, A>,
-    f: (exit: Exit.Exit<never, unknown>) => Effect.Effect<R2, never, unknown>
-  ): Fx<R | R2, E, A>
-} = internal.onExit
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.flatMapCause)
 
 /**
- * Run an Effect when an Fx is interrupted
- * @since 1.18.0
- * @category lifecycles
+ * @since 1.20.0
  */
-export const onInterrupt: {
-  <R2>(
-    f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, unknown>
-  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E, A>
-  <R, E, A, R2>(
+export const flatMapError: {
+  <E, R2, E2, B>(
+    f: (e: E) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+
+  <R, E, A, R2, E2, B>(
     fx: Fx<R, E, A>,
-    f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, unknown>
-  ): Fx<R | R2, E, A>
-} = internal.onInterrupt
+    f: (e: E) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.flatMapError)
 
 /**
- * Run an Effect when an Fx ends with an error
- * @since 1.18.0
- * @category lifecycles
+ * @since 1.20.0
  */
-export const onError: {
-  <R2>(
-    f: (cause: Cause.Cause<never>) => Effect.Effect<R2, never, unknown>
-  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E, A>
-  <R, E, A, R2>(
+export const flatMapCauseConcurrently: {
+  <E, R2, E2, B>(
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    concurrency: number,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+  <R, E, A, R2, E2, B>(
     fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<never>) => Effect.Effect<R2, never, unknown>
-  ): Fx<R | R2, E, A>
-} = internal.onError
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    concurrency: number,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.flatMapCauseConcurrently)
 
 /**
- * Provide a Scope to an Fx
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export const scoped: <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, Scope.Scope>, E, A> = internal.scoped
+export const flatMapErrorConcurrently: {
+  <E, R2, E2, B>(
+    f: (e: E) => Fx<R2, E2, B>,
+    concurrency: number,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (e: E) => Fx<R2, E2, B>,
+    concurrency: number,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.flatMapErrorConcurrently)
 
 /**
- * Annotate the logs of an Fx
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const annotateLogs: {
-  (key: string, value: unknown): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  (values: Record<string, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, key: string, value: unknown): Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, values: Record<string, unknown>): Fx<R, E, A>
-} = internal.annotateLogs
+export const exhaustMapCause: {
+  <E, R2, E2, B>(
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.exhaustMapCause)
 
 /**
- * Annotate the spans of an Fx
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const annotateSpans: {
-  (key: string, value: unknown): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  (values: Record<string, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, key: string, value: unknown): Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, values: Record<string, unknown>): Fx<R, E, A>
-} = internal.annotateSpans
+export const exhaustMapError: {
+  <E, R2, E2, B>(
+    f: (e: E) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (e: E) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.exhaustMapError)
 
 /**
- * Create an Fx which will succeed with Option.None
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const succeedNone: <A = never>() => Fx<never, never, Option.Option<A>> = internal.succeedNone
+export const exhaustMapLatestCause: {
+  <E, R2, E2, B>(
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.exhaustMapLatestCause)
 
 /**
- * Create an Fx which will succeed with Option.Some
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const succeedSome: <A>(value: A) => Fx<never, never, Option.Option<A>> = internal.succeedSome
+export const exhaustMapLatestError: {
+  <E, R2, E2, B>(
+    f: (e: E) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>
+
+  <R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (e: E) => Fx<R2, E2, B>,
+    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+  ): Fx<R | R2 | Scope.Scope, E2, A | B>
+} = dual(isDataFirstFx, core.exhaustMapLatestError)
 
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
+ * @since 1.20.0
  */
-export const Do: Fx<never, never, {}> = internal.Do
+export type MatchCauseOptions<E, A, R2, E2, B, R3, E3, C> = {
+  readonly onFailure: (cause: Cause.Cause<E>) => Fx<R2, E2, B>
+  readonly onSuccess: (a: A) => Fx<R3, E3, C>
+  readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+}
 
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
- */
-export const bind: {
-  <N extends string, A extends object, R2, E2, B>(
-    name: Exclude<N, keyof A>,
-    f: (a: A) => Fx<R2, E2, B>
-  ): <R1, E1>(self: Fx<R1, E1, A>) => Fx<R2 | R1, E2 | E1, { [K in N | keyof A]: K extends keyof A ? A[K] : B }>
-  <R1, E1, A1 extends object, N extends string, R2, E2, B>(
-    self: Fx<R1, E1, A1>,
-    name: Exclude<N, keyof A1>,
-    f: (a: A1) => Fx<R2, E2, B>
-  ): Fx<R1 | R2, E1 | E2, { [K in N | keyof A1]: K extends keyof A1 ? A1[K] : B }>
-} = internal.bind
-
-/**
- * Do simulation
- * @since 1.18.0
- * @category Do
- */
-export const bindTo: {
-  <N extends string>(name: N): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, { [K in N]: A }>
-  <R, E, A, N extends string>(self: Fx<R, E, A>, name: N): Fx<R, E, { [K_1 in N]: A }>
-} = internal.bindTo
-
-const let_: {
-  <N extends string, A extends object, B>(
-    name: Exclude<N, keyof A>,
-    f: (a: A) => B
-  ): <R1, E1>(self: Fx<R1, E1, A>) => Fx<R1, E1, { [K in N | keyof A]: K extends keyof A ? A[K] : B }>
-  <R1, E1, A1 extends object, N extends string, B>(
-    self: Fx<R1, E1, A1>,
-    name: Exclude<N, keyof A1>,
-    f: (a: A1) => B
-  ): Fx<R1, E1, { [K in N | keyof A1]: K extends keyof A1 ? A1[K] : B }>
-} = internal.let
-
-export {
-  /**
-   * Do simulation
-   * @since 1.18.0
-   * @category Do
-   */
-  let_ as let
+ * @since 1.20.0
+ */
+export type MatchErrorOptions<E, A, R2, E2, B, R3, E3, C> = {
+  readonly onFailure: (e: E) => Fx<R2, E2, B>
+  readonly onSuccess: (a: A) => Fx<R3, E3, C>
+  readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
 }
 
 /**
- * Ensure a finalizer runs on Fx ext.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const ensuring: {
-  <R2>(finalizer: Effect.Effect<R2, never, unknown>): <R, E, A>(self: Fx<R, E, A>) => Fx<R2 | R, E, A>
-  <R, E, A, R2>(self: Fx<R, E, A>, finalizer: Effect.Effect<R2, never, unknown>): Fx<R | R2, E, A>
-} = internal.ensuring
+export const matchCauseWithStrategy: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    flattenStrategy: FlattenStrategy,
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+} = dual(3, core.matchCauseWithStrategy)
 
 /**
- * Capture the errors and success values as Exit
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const exit: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Exit.Exit<E, A>> = internal.exit
+export const matchErrorWithStrategy: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    { executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    flattenStrategy: FlattenStrategy,
+    { executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>
+} = dual(3, core.matchErrorWithStrategy)
 
 /**
- * Capture the errors and success values as Either
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const either: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Either.Either<E, A>> = internal.either
+export const matchCause: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>
+} = dual(2, core.matchCause)
 
 /**
- * Run an Fx until finding a value which satisfies the predicate.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const findFirst: {
-  <A, R2, E2>(
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R2 | R, E2 | E, Option.Option<A>>
-  <R, E, A, R2, E2>(
+export const matchError: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+  <R, E, A, R2, E2, B, R3, E3, C>(
     fx: Fx<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Effect.Effect<R | R2, E | E2, Option.Option<A>>
-} = internal.findFirst
+    opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+} = dual(2, core.matchError)
 
 /**
- * Grab the first value emitted by an Fx
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const first: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, Option.Option<A>> = findFirst(
-  constant(Effect.succeed(true))
-)
+export const matchCauseConcurrently: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    concurrency: number,
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    concurrency: number,
+    opts: core.MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+} = dual(3, core.matchCauseConcurrently)
 
 /**
- * Transform success values into failures and failures into successes.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const flip: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, A, E> = internal.flip
+export const matchErrorConcurrently: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    concurrency: number,
+    opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    concurrency: number,
+    opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>
+} = dual(3, core.matchErrorConcurrently)
 
 /**
- * Lift a nullable value into an Fx
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromNullable: <A>(value: void | A | null | undefined) => Fx<never, never, NonNullable<A>> =
-  internal.fromNullable
-
-const if_: {
-  <R2, E2, B, R3, E3, C>(
-    onTrue: Fx<R2, E2, B>,
-    onFalse: Fx<R3, E3, C>
-  ): {
-    <R, E>(bool: Fx<R, E, boolean>): Fx<R2 | R3 | R, E2 | E3 | E, B | C>
-    (bool: boolean): Fx<R2 | R3, E2 | E3, B | C>
-  }
-  <R, E, R2, E2, B, R3, E3, C>(
-    bool: Fx<R, E, boolean>,
-    onTrue: Fx<R2, E2, B>,
-    onFalse: Fx<R3, E3, C>
-  ): Fx<R | R2 | R3, E | E2 | E3, B | C>
-  <R2, E2, B, R3, E3, C>(
-    bool: boolean,
-    onTrue: Fx<R2, E2, B>,
-    onFalse: Fx<R3, E3, C>
-  ): Fx<R2 | R3, E2 | E3, B | C>
-} = internal.if
+export const switchMatchCause: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
 
-export {
-  /**
-   * Logical if/else using Fx.
-   * @since 1.18.0
-   * @category combinators
-   */
-  if_ as if
-}
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>
+} = dual(2, core.switchMatchCause)
 
 /**
- * Logical if/else using static values.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const when: {
-  <B, C>(
-    onTrue: B,
-    onFalse: C
-  ): { <R, E>(bool: Fx<R, E, boolean>): Fx<R, E, B | C>; (bool: boolean): Fx<never, never, B | C> }
-  <R, E, B, C>(bool: Fx<R, E, boolean>, onTrue: B, onFalse: C): Fx<R, E, B | C>
-  <B, C>(bool: boolean, onTrue: B, onFalse: C): Fx<never, never, B | C>
-} = internal.when
+export const switchMatchError: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+} = dual(2, core.switchMatchError)
 
 /**
- * Mark an Fx as interruptible
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const interruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = internal.interruptible
+export const exhaustMatchCause: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
 
-/**
- * Mark an Fx as uninterruptible
- * @since 1.18.0
- * @category combinators
- */
-export const uninterruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = internal.uninterruptible
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>
+} = dual(2, core.exhaustMatchCause)
 
 /**
- * Locally set the value of a FiberRef
- * @since 1.18.0
- * @category FiberRef
+ * @since 1.20.0
  */
-export const locally: {
-  <A>(self: FiberRef<A>, value: A): <R, E, B>(use: Fx<R, E, B>) => Fx<R, E, B>
-  <R, E, B, A>(use: Fx<R, E, B>, self: FiberRef<A>, value: A): Fx<R, E, B>
-} = internal.locally
+export const exhaustMatchError: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+} = dual(2, core.exhaustMatchError)
 
 /**
- * Locally set the value of a FiberRef by updating the current value
- * @since 1.18.0
- * @category FiberRef
+ * @since 1.20.0
  */
-export const locallyWith: {
-  <A>(self: FiberRef<A>, f: (a: A) => A): <R, E, B>(use: Fx<R, E, B>) => Fx<R, E, B>
-  <R, E, B, A>(use: Fx<R, E, B>, self: FiberRef<A>, f: (a: A) => A): Fx<R, E, B>
-} = internal.locallyWith
+export const exhaustMatchLatestCause: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>
+} = dual(2, core.exhaustMatchLatestCause)
 
 /**
- * Enable/disable tracer timing for an Fx
- * @since 1.18.0
- * @category tracing
+ * @since 1.20.0
  */
-export const withTracerTiming: {
-  (enabled: boolean): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, enabled: boolean): Fx<R, E, A>
-} = internal.withTracerTiming
+export const exhaustMatchLatestError: {
+  <E, A, R2, E2, B, R3, E3, C>(
+    opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>
+} = dual(2, core.exhaustMatchLatestError)
 
 /**
- * Configure the concurreny limit of Fibers running within an Fx
- * @since 1.18.0
- * @category concurrency
+ * @since 1.20.0
  */
-export const withConcurrency: {
-  (concurrency: number | "unbounded"): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, concurrency: number | "unbounded"): Fx<R, E, A>
-} = internal.withConcurrency
+export const exit: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Exit.Exit<E, A>> = core.exit
 
 /**
- * Add a span to your log messages
- * @since 1.18.0
- * @category logging
+ * @since 1.20.0
  */
-export const withLogSpan: {
-  (span: string): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, span: string): Fx<R, E, A>
-} = internal.withLogSpan
+export const either: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Either.Either<E, A>> = core.either
 
 /**
- * Configure the maximum number of operations to run before yielding to the runtime
- * @since 1.18.0
- * @category concurrency
+ * @since 1.20.0
  */
-export const withMaxOpsBeforeYield: {
-  (maxOps: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, maxOps: number): Fx<R, E, A>
-} = internal.withMaxOpsBeforeYield
+export const tuple: <const FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, { readonly [K in keyof FX]: Fx.Success<FX[K]> }> = core.tuple
 
 /**
- * Set the parent Span of an Fx
- * @since 1.18.0
- * @category tracing
+ * @since 1.20.0
  */
-export const withParentSpan: {
-  (parentSpan: Tracer.ParentSpan): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, parentSpan: Tracer.ParentSpan): Fx<R, E, A>
-} = internal.withParentSpan
+export const struct: <const FX extends Readonly<Record<string, Fx<any, any, any>>>>(
+  fx: FX
+) => Fx<Fx.Context<FX[string]>, Fx.Error<FX[string]>, { readonly [K in keyof FX]: Fx.Success<FX[K]> }> = core.struct
 
 /**
- * Enable/disable request batching within an Fx
- * @since 1.18.0
- * @category batching
+ * @since 1.20.0
  */
-export const withRequestBatching: {
-  (requestBatching: boolean): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, requestBatching: boolean): Fx<R, E, A>
-} = internal.withRequestBatching
+export const all: {
+  <const FX extends ReadonlyArray<Fx<any, any, any>>>(
+    fx: FX
+  ): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, { readonly [K in keyof FX]: Fx.Success<FX[K]> }>
+  <const FX extends Readonly<Record<string, Fx<any, any, any>>>>(
+    fx: FX
+  ): Fx<Fx.Context<FX[string]>, Fx.Error<FX[string]>, { readonly [K in keyof FX]: Fx.Success<FX[K]> }>
+} = core.all
 
 /**
- * Set the request cache Effects running within an Fx
- * @since 1.18.0
- * @category batching
+ * @since 1.20.0
  */
-export const withRequestCache: {
-  (cache: Request.Cache): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, cache: Request.Cache): Fx<R, E, A>
-} = internal.withRequestCache
+export const toEnqueue: {
+  <R2 = never, A = never>(
+    queue: Ctx.Enqueue<R2, A> | Queue.Enqueue<A>
+  ): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, E, void>
+  <R, E, A, R2 = never>(fx: Fx<R, E, A>, queue: Ctx.Enqueue<R2, A> | Queue.Enqueue<A>): Effect.Effect<R | R2, E, void>
+} = dual(2, core.toEnqueue)
 
 /**
- * Enable/disable request caching within an Fx
- * @since 1.18.0
- * @category batching
+ * @since 1.20.0
  */
-export const withRequestCaching: {
-  (requestCaching: boolean): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, requestCaching: boolean): Fx<R, E, A>
-} = internal.withRequestCaching
+export const debounce: {
+  (delay: Duration.DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | Scope.Scope, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A>
+} = dual(2, core.debounce)
 
 /**
- * Configure the scheduler to use within an Fx
- * @since 1.18.0
- * @category concurrency
+ * @since 1.20.0
  */
-export const withScheduler: {
-  (scheduler: Scheduler): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, scheduler: Scheduler): Fx<R, E, A>
-} = internal.withScheduler
+export const throttle: {
+  (delay: Duration.DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | Scope.Scope, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A>
+} = dual(2, core.throttle)
 
 /**
- * Set the span of an Fx
- * @since 1.18.0
- * @category tracing
- */
-export const withSpan: {
-  (
-    name: string,
-    options?: {
-      readonly attributes?: Record<string, unknown>
-      readonly links?: ReadonlyArray<Tracer.SpanLink>
-      readonly parent?: Tracer.ParentSpan
-      readonly root?: boolean
-      readonly context?: Context.Context<never>
-    }
-  ): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(
-    self: Fx<R, E, A>,
-    name: string,
-    options?: {
-      readonly attributes?: Record<string, unknown>
-      readonly links?: ReadonlyArray<Tracer.SpanLink>
-      readonly parent?: Tracer.ParentSpan
-      readonly root?: boolean
-      readonly context?: Context.Context<never>
-    }
-  ): Fx<R, E, A>
-} = internal.withSpan
-
-/**
- * Set the tracer used within an Fx
- * @since 1.18.0
- * @category tracing
+ * @since 1.20.0
  */
-export const withTracer: {
-  (tracer: Tracer.Tracer): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, tracer: Tracer.Tracer): Fx<R, E, A>
-} = internal.withTracer
+export const throttleLatest: {
+  (delay: Duration.DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | Scope.Scope, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A>
+} = dual(2, core.throttleLatest)
 
 /**
- * Partition an Fx into two Fx's based on a either-returning function.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const partitionMap: {
-  <A, B, C>(f: (a: A) => Either.Either<B, C>): <R, E>(self: Fx<R, E, A>) => readonly [Fx<R, E, B>, Fx<R, E, C>]
-  <R, E, A, B, C>(self: Fx<R, E, A>, f: (a: A) => Either.Either<B, C>): readonly [Fx<R, E, B>, Fx<R, E, C>]
-} = internal.partitionMap
+export interface KeyedOptions<A, B, R2, E2, C> {
+  readonly getKey: (a: A) => B
+  readonly onValue: (ref: RefSubject<never, never, A>, key: B) => Fx<R2, E2, C>
+  readonly debounce?: Duration.DurationInput
+}
 
 /**
- * Convert a list of keyed values into persistent workflows for given each key of the list
- * even when the list has been re-ordered.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
 export const keyed: {
-  <A, B, R2, E2, C>(
-    getKey: (a: A) => B,
-    f: (
-      ref: RefSubject<never, never, A>,
-      key: B
-    ) => FxInput<R2, E2, C>
+  <A, B extends PropertyKey, R2, E2, C>(
+    options: KeyedOptions<A, B, R2, E2, C>
   ): <R, E>(fx: Fx<R, E, ReadonlyArray<A>>) => Fx<R | R2, E | E2, ReadonlyArray<C>>
 
-  <R, E, A, B, R2, E2, C>(
+  <R, E, A, B extends PropertyKey, R2, E2, C>(
     fx: Fx<R, E, ReadonlyArray<A>>,
-    getKey: (a: A) => B,
-    f: (
-      ref: RefSubject<never, never, A>,
-      key: B
-    ) => FxInput<R2, E2, C>
+    options: KeyedOptions<A, B, R2, E2, C>
   ): Fx<R | R2, E | E2, ReadonlyArray<C>>
-} = dual(3, internalKeyed.keyed)
+} = dual(2, coreKeyed.keyed)
 
 /**
- * Map an Fx of values into workflows similar to Fx.switchMap, but
- * instead of providing the value directly, it is exposed as a RefSubject to
- * allow creating a persistent workflows similar to Fx.keyed but for a single value.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
+ */
+export interface WithKeyOptions<A, B, R2, E2, C> {
+  readonly getKey: (a: A) => B
+  readonly onValue: (ref: RefSubject<never, never, A>, key: B) => Fx<R2, E2, C>
+}
+
+/**
+ * @since 1.20.0
  */
 export const withKey: {
-  <A, B, R2, E2, C>(
-    getKey: (a: A) => B,
-    f: (
-      ref: RefSubject<never, never, A>,
-      key: B
-    ) => FxInput<R2, E2, C>
+  <A, B extends PropertyKey, R2, E2, C>(
+    options: WithKeyOptions<A, B, R2, E2, C>
   ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, C>
 
-  <R, E, A, B, R2, E2, C>(
+  <R, E, A, B extends PropertyKey, R2, E2, C>(
     fx: Fx<R, E, A>,
-    getKey: (a: A) => B,
-    f: (
-      ref: RefSubject<never, never, A>,
-      key: B
-    ) => FxInput<R2, E2, C>
+    options: WithKeyOptions<A, B, R2, E2, C>
   ): Fx<R | R2, E | E2, C>
-} = dual(3, internalWithKey.withKey)
+} = dual(2, coreWithKey.withKey)
 
 const getTag = (a: { readonly _tag: string }): string => a._tag
 
@@ -2480,25 +2046,25 @@ const getTag = (a: { readonly _tag: string }): string => a._tag
  * that allow listening to changes of values with the same tag using the same
  * Fx.
  *
- * @since 1.18.0
+ * @since 1.20.0
  * @category combinators
  */
 export const matchTags: {
   <A extends { readonly _tag: string }, Matchers extends DefaultMatchersFrom<A>>(
     matchers: Matchers
   ): <R, E>(fx: Fx<R, E, A>) => Fx<
-    R | Fx.Context<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>,
-    E | Fx.Error<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>,
-    Fx.Success<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>
+    R | Fx.Context<ReturnType<Matchers[keyof Matchers]>>,
+    E | Fx.Error<ReturnType<Matchers[keyof Matchers]>>,
+    Fx.Success<ReturnType<Matchers[keyof Matchers]>>
   >
 
   <R, E, A extends { readonly _tag: string }, Matchers extends DefaultMatchersFrom<A>>(
     fx: Fx<R, E, A>,
     matchers: Matchers
   ): Fx<
-    R | Fx.Context<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>,
-    E | Fx.Error<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>,
-    Fx.Success<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>
+    R | Fx.Context<ReturnType<Matchers[keyof Matchers]>>,
+    E | Fx.Error<ReturnType<Matchers[keyof Matchers]>>,
+    Fx.Success<ReturnType<Matchers[keyof Matchers]>>
   >
 } = dual(
   2,
@@ -2506,62 +2072,47 @@ export const matchTags: {
     fx: Fx<R, E, A>,
     matchers: Matchers
   ): Fx<
-    R | Fx.Context<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>,
-    E | Fx.Error<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>,
-    Fx.Success<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>
+    R | Fx.Context<ReturnType<Matchers[keyof Matchers]>>,
+    E | Fx.Error<ReturnType<Matchers[keyof Matchers]>>,
+    Fx.Success<ReturnType<Matchers[keyof Matchers]>>
   > {
-    return withKey(fx, getTag, (ref, tag: A["_tag"]) => matchers[tag](ref as any))
+    return withKey(fx, {
+      getKey: getTag,
+      onValue: (ref, tag: A["_tag"]) => matchers[tag](ref as any)
+    })
   }
 )
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export type DefaultMatchersFrom<A extends { readonly _tag: string }> = {
   readonly [Tag in A["_tag"]]: (
     value: RefSubject<never, never, Extract<A, { readonly _tag: Tag }>>
-  ) => FxInput<any, any, any>
+  ) => Fx<any, any, any>
 }
 
 /**
- * @since 1.18.0
- */
-export const drainLayer: <FXS extends ReadonlyArray<Fx<any, never, any>>>(...fxs: FXS) => Layer.Layer<
-  Exclude<Fx.Context<FXS[number]>, Scope.Scope>,
-  never,
-  never
-> = internal.drainLayer
-
-/* #endregion */
-
-/**
- * @since 1.18.0
- */
-export function isFx<R = unknown, E = unknown, A = unknown>(u: unknown): u is Fx<R, E, A> {
-  return typeof u === "object" && u !== null && TypeId in u
-}
-
-/**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const matchOption: {
   <A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    onNone: () => FxInput<R2, E2, B>,
-    onSome: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>
-  ): <R, E>(fx: Fx<R, E, Option.Option<A>>) => Fx<R | R2, E | E2, B | C>
+    onNone: () => Fx<R2, E2, B>,
+    onSome: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>
+  ): <R, E>(fx: Fx<R, E, Option.Option<A>>) => Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>
 
   <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
     fx: Fx<R, E, Option.Option<A>>,
-    onNone: () => FxInput<R2, E2, B>,
-    onSome: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>
-  ): Fx<R | R2, E | E2, B | C>
+    onNone: () => Fx<R2, E2, B>,
+    onSome: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>
 } = dual(
   3,
   function matchOption<R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
     fx: Fx<R, E, Option.Option<A>>,
-    onNone: () => FxInput<R2, E2, B>,
-    onSome: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>
-  ): Fx<R | R2, E | E2, B | C> {
+    onNone: () => Fx<R2, E2, B>,
+    onSome: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C> {
     return matchTags(fx, {
       None: onNone,
       Some: (some) => onSome(transform(some, (s) => s.value, (value) => Option.some(value) as Option.Some<A>))
@@ -2570,48 +2121,48 @@ export const matchOption: {
 )
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const getOrElse: {
   <A, R2 = never, E2 = never, B = never>(
-    orElse: () => FxInput<R2, E2, B>
-  ): <R, E>(fx: Fx<R, E, Option.Option<A>>) => Fx<R | R2, E | E2, A | B>
+    orElse: () => Fx<R2, E2, B>
+  ): <R, E>(fx: Fx<R, E, Option.Option<A>>) => Fx<R | R2 | Scope.Scope, E | E2, A | B>
 
   <R, E, A, R2 = never, E2 = never, B = never>(
     fx: Fx<R, E, Option.Option<A>>,
-    orElse: () => FxInput<R2, E2, B>
-  ): Fx<R | R2, E | E2, A | B>
+    orElse: () => Fx<R2, E2, B>
+  ): Fx<R | R2 | Scope.Scope, E | E2, A | B>
 } = dual(
   2,
   function getOrElse<R, E, A, R2 = never, E2 = never, B = never>(
     fx: Fx<R, E, Option.Option<A>>,
-    orElse: () => FxInput<R2, E2, B>
-  ): Fx<R | R2, E | E2, A | B> {
+    orElse: () => Fx<R2, E2, B>
+  ): Fx<R | R2 | Scope.Scope, E | E2, A | B> {
     return matchOption(fx, orElse, identity)
   }
 )
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const matchEither: {
   <E1, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
-    onLeft: (e: RefSubject<never, never, E1>) => FxInput<R2, E2, B>,
-    onRight: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>
-  ): <R, E>(fx: Fx<R, E, Either.Either<E1, A>>) => Fx<R | R2, E | E2, B | C>
+    onLeft: (e: RefSubject<never, never, E1>) => Fx<R2, E2, B>,
+    onRight: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>
+  ): <R, E>(fx: Fx<R, E, Either.Either<E1, A>>) => Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>
 
   <R, E, E1, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
     fx: Fx<R, E, Either.Either<E1, A>>,
-    onLeft: (e: RefSubject<never, never, E1>) => FxInput<R2, E2, B>,
-    onRight: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>
-  ): Fx<R | R2, E | E2, B | C>
+    onLeft: (e: RefSubject<never, never, E1>) => Fx<R2, E2, B>,
+    onRight: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>
 } = dual(
   3,
   function matchEither<R, E, E1, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(
     fx: Fx<R, E, Either.Either<E1, A>>,
-    onLeft: (e: RefSubject<never, never, E1>) => FxInput<R2, E2, B>,
-    onRight: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>
-  ): Fx<R | R2, E | E2, B | C> {
+    onLeft: (e: RefSubject<never, never, E1>) => Fx<R2, E2, B>,
+    onRight: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>
+  ): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C> {
     return matchTags(fx, {
       Left: (left) => onLeft(transform(left, (a) => a.left, (a) => Either.left(a) as Either.Left<E1, A>)),
       Right: (right) => onRight(transform(right, (s) => s.right, (value) => Either.right(value) as Either.Right<E1, A>))
@@ -2620,26 +2171,49 @@ export const matchEither: {
 )
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
+ */
+export const at: {
+  (duration: Duration.DurationInput): <A>(value: A) => Fx<never, never, A>
+  <A>(value: A, duration: Duration.DurationInput): Fx<never, never, A>
+} = dual(
+  2,
+  <A>(value: A, duration: Duration.DurationInput): Fx<never, never, A> =>
+    fromEffect(Effect.delay(Effect.succeed(value), duration))
+)
+
+/**
+ * @since 1.20.0
+ */
+export function drainLayer<FXS extends ReadonlyArray<Fx<any, never, any>>>(...fxs: FXS): Layer.Layer<
+  Exclude<Fx.Context<FXS[number]>, Scope.Scope>,
+  never,
+  never
+> {
+  return Layer.scopedDiscard(Effect.forkWithErrorHandler(core.drain(core.mergeAll(fxs)), Effect.logError))
+}
+
+/**
+ * @since 1.20.0
  */
 export const fork = <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>> =>
   Effect.fork(drain(fx))
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const forkScoped = <R, E, A>(
   fx: Fx<R, E, A>
 ): Effect.Effect<R | Scope.Scope, never, Fiber.RuntimeFiber<E, void>> => Effect.forkScoped(drain(fx))
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const forkDaemon = <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>> =>
   Effect.forkDaemon(drain(fx))
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const forkIn: {
   (scope: Scope.Scope): <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>>
@@ -2650,19 +2224,279 @@ export const forkIn: {
 ): Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>> => Effect.forkIn(drain(fx), scope))
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
+ */
+export const fromAsyncIterable: <A>(iterable: AsyncIterable<A>) => Fx<never, never, A> = core.fromAsyncIterable
+
+/**
+ * @since 1.20.0
+ */
+export const partitionMap: {
+  <A, B, C>(
+    f: (a: A) => Either.Either<B, C>
+  ): <R, E>(fx: Fx<R, E, A>) => readonly [Fx<Scope.Scope | R, E, B>, Fx<Scope.Scope | R, E, C>]
+  <R, E, A, B, C>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Either.Either<B, C>
+  ): readonly [Fx<Scope.Scope | R, E, B>, Fx<Scope.Scope | R, E, C>]
+} = dual(2, function partitionMap<R, E, A, B, C>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Either.Either<B, C>
+): readonly [Fx<R | Scope.Scope, E, B>, Fx<R | Scope.Scope, E, C>] {
+  const source = coreShare.multicast(core.map(fx, f))
+
+  return [
+    core.filterMap(source, Either.getLeft),
+    core.filterMap(source, Either.getRight)
+  ]
+})
+
+/**
+ * @since 1.20.0
+ */
+export const gen: <Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+  f: (_: Effect.Adapter) => Generator<Y, FX, any>
+) => Fx<
+  Effect.Effect.Context<Y["value"]> | Fx.Context<FX>,
+  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
+  Fx.Success<FX>
+> = core.gen
+
+/**
+ * @since 1.20.0
+ */
+export const genScoped: <Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+  f: (_: Effect.Adapter) => Generator<Y, FX, any>
+) => Fx<
+  Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>,
+  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
+  Fx.Success<FX>
+> = core.genScoped
+
+/**
+ * @since 1.20.0
+ */
+export const findFirst: {
+  <A, B extends A>(refinement: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, B>
+  <A>(predicate: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A, B extends A>(fx: Fx<R, E, A>, refinement: Predicate.Refinement<A, B>): Effect.Effect<R, E, B>
+  <R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Effect.Effect<R, E, A>
+} = dual(2, core.findFirst)
+
+/**
+ * @since 1.20.0
+ */
+export const first: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, A> = core.first
+
+/**
+ * @since 1.20.0
+ */
+export const mergeFirst: {
+  <R2, E2, B>(that: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, that: Fx<R2, E2, B>): Fx<R | R2, E | E2, A>
+} = dual(2, core.mergeFirst)
+
+/**
+ * @since 1.20.0
  */
 export const mergeRace: {
-  <R2, E2, B>(other: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2 | E, B | A>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
-} = internal.mergeRace
+  <R2, E2, B>(that: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, that: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
+} = dual(2, core.mergeRace)
+
+/**
+ * @since 1.20.0
+ */
+export const raceAll: <const FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> = core.raceAll
+
+/**
+ * @since 1.20.0
+ */
+export const race: {
+  <R2, E2, B>(that: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, that: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
+} = dual(2, core.race)
+
+/**
+ * @since 1.20.0
+ */
+export const snapshot: {
+  <R, E, B, A, C>(sampled: Fx<R, E, B>, g: (a: A, b: B) => C): <R2, E2>(fx: Fx<R2, E2, A>) => Fx<R | R2, E | E2, C>
+  <R, E, A, R2, E2, B, C>(fx: Fx<R, E, A>, sampled: Fx<R2, E2, B>, f: (a: A, b: B) => C): Fx<R | R2, E | E2, C>
+} = dual(3, core.snapshot)
+
+/**
+ * @since 1.20.0
+ */
+export const sample: {
+  <R, E, B>(sampled: Fx<R, E, B>): <R2, E2, A>(fx: Fx<R2, E2, A>) => Fx<R | R2, E | E2, B>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, sampled: Fx<R2, E2, B>): Fx<R | R2, E | E2, B>
+} = dual(2, core.sample)
+
+/**
+ * @since 1.20.0
+ */
+export const snapshotEffect: {
+  <R2, E2, B, A, R3, E3, C>(sampled: Fx<R2, E2, B>, g: (a: A, b: B) => Effect.Effect<R3, E3, C>): <R, E>(
+    fx: Fx<R, E, A>
+  ) => Fx<R | R2 | R3, E | E2 | E3, C>
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    sampled: Fx<R2, E2, B>,
+    f: (a: A, b: B) => Effect.Effect<R3, E3, C>
+  ): Fx<R | R2 | R3, E | E2 | E3, C>
+} = dual(3, core.snapshotEffect)
+
+const if_: {
+  <R2, E2, B, R3, E3, C>(options: { readonly onTrue: Fx<R2, E2, B>; readonly onFalse: Fx<R3, E3, C> }): <R, E>(
+    bool: Fx<R, E, boolean>
+  ) => Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>
+  <R, E, R2, E2, B, R3, E3, C>(
+    bool: Fx<R, E, boolean>,
+    options: { readonly onTrue: Fx<R2, E2, B>; readonly onFalse: Fx<R3, E3, C> }
+  ): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>
+} = dual(2, core.if)
+
+export {
+  /**
+   * @since 1.20.0
+   */
+  if_ as if
+}
+
+/**
+ * @since 1.20.0
+ */
+export const when: {
+  <B, C>(
+    options: { readonly onTrue: B; readonly onFalse: C }
+  ): <R, E>(bool: Fx<R, E, boolean>) => Fx<R | Scope.Scope, E, B | C>
+  <R, E, B, C>(
+    bool: Fx<R, E, boolean>,
+    options: { readonly onTrue: B; readonly onFalse: C }
+  ): Fx<R | Scope.Scope, E, B | C>
+} = dual(2, core.when)
+
+/**
+ * @since 1.20.0
+ */
+export const withEmitter = <E, A, R = never>(
+  f: (emitter: Emitter.Emitter<E, A>) => Effect.Effect<R, E, unknown>
+): Fx<R | Scope.Scope, E, A> => core.make<R | Scope.Scope, E, A>((sink) => Emitter.withEmitter(sink, f))
 
 /**
+ * Create an Fx which will wait a specified duration of time where no
+ * events have occurred before emitting a value.
  * @since 1.18.0
  */
-export abstract class FxEffectBase<R, E, A, R2, E2, B> extends internalProtos.FxEffectBase<R, E, A, R2, E2, B>
-  implements Fx<R, E, A>, Effect.Effect<R2, E2, B>
-{
-  protected abstract toFx(): Fx<R, E, A>
-  protected abstract toEffect(): Effect.Effect<R2, E2, B>
+export const delay: {
+  (delay: DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | Scope.Scope, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, delay: DurationInput): Fx<R | Scope.Scope, E, A>
+} = dual(2, function<R, E, A>(fx: Fx<R, E, A>, delay: DurationInput): Fx<R | Scope.Scope, E, A> {
+  return core.flatMap(fx, (a) => core.fromEffect(Effect.delay(Effect.succeed(a), delay)))
+})
+
+/**
+ * @since 1.20.0
+ */
+export const ensuring: {
+  <R2>(finalizer: Effect.Effect<R2, never, unknown>): <R, E, A>(self: Fx<R, E, A>) => Fx<R | R2, E, A>
+  <R, E, A, R2>(self: Fx<R, E, A>, finalizer: Effect.Effect<R2, never, unknown>): Fx<R | R2, E, A>
+} = dual(2, function<R, E, A, R2>(
+  self: Fx<R, E, A>,
+  finalizer: Effect.Effect<R2, never, unknown>
+): Fx<R | R2, E, A> {
+  return core.middleware(self, (effect) => Effect.ensuring(effect, finalizer))
+})
+
+/**
+ * @since 1.20.0
+ */
+export const flip = <R, E, A>(fx: Fx<R, E, A>): Fx<R, A, E> =>
+  core.make<R, A, E>((sink) =>
+    fx.run(Sink.make(
+      (cause) =>
+        Either.match(Cause.failureOrCause(cause), {
+          onLeft: (e) => sink.onSuccess(e),
+          onRight: (c) => sink.onFailure(c)
+        }),
+      (a) => sink.onFailure(Cause.fail(a))
+    ))
+  )
+
+/**
+ * @since 1.20.0
+ */
+export const fromNullable = <A>(value: A | null | undefined | void): Fx<never, never, NonNullable<A>> => {
+  if (value === null || value === undefined) {
+    return core.empty
+  } else {
+    return core.succeed(value)
+  }
+}
+
+/**
+ * @since 1.20.0
+ */
+export function fromDequeue<A>(dequeue: Queue.Dequeue<A>): Fx<never, never, A>
+export function fromDequeue<I, A>(dequeue: Ctx.Dequeue<I, A>): Fx<I, never, A>
+export function fromDequeue<I, A>(dequeue: Ctx.Dequeue<I, A> | Queue.Dequeue<A>): Fx<I, never, A> {
+  return core.make((sink) =>
+    Effect.repeatWhileEffect(
+      Effect.matchCauseEffect(dequeue.take, sink),
+      () => dequeueIsActive(dequeue)
+    )
+  )
+}
+
+/**
+ * @internal
+ */
+export function dequeueIsActive<I, A>(
+  dequeue: Ctx.Dequeue<I, A> | Queue.Dequeue<A>
+): Effect.Effect<I, never, boolean> {
+  if (Queue.DequeueTypeId in dequeue) {
+    return Effect.sync(() => dequeue.isActive())
+  } else {
+    return dequeue.isActive
+  }
+}
+
+/**
+ * @since 1.20.0
+ */
+export function fromPubSub<A>(pubSub: PubSub.PubSub<A>): Fx<Scope.Scope, never, A>
+export function fromPubSub<I, A>(pubSub: Ctx.PubSub<I, A>): Fx<I | Scope.Scope, never, A>
+export function fromPubSub<I, A>(pubSub: Ctx.PubSub<I, A> | PubSub.PubSub<A>): Fx<I | Scope.Scope, never, A> {
+  return core.acquireUseRelease(
+    pubSub.subscribe,
+    (q) => fromDequeue(q),
+    (d) => d.shutdown
+  )
+}
+
+/**
+ * @since 1.20.0
+ */
+export abstract class FxEffectBase<R, E, A, R2, E2, B> extends protos.FxEffectBase<R, E, A, R2, E2, B> {
+  private _fx: Fx<R, E, A> | undefined
+
+  /**
+   * @since 1.20.0
+   */
+  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<R | R3, never, void> {
+    return (this._fx ||= this.toFx()).run(sink)
+  }
+
+  /**
+   * @since 1.20.0
+   */
+  abstract toFx(): Fx<R, E, A>
+
+  /**
+   * @since 1.20.0
+   */
+  abstract toEffect(): Effect.Effect<R2, E2, B>
 }