effect 3.12.11 → 3.13.0

package/src/internal/core-effect.ts

@@ -26,7 +26,7 @@ import type * as Random from "../Random.js"
 import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
-import type { NoInfer } from "../Types.js"
+import type * as Types from "../Types.js"
 import type { Unify } from "../Unify.js"
 import { internalCall } from "../Utils.js"
 import * as internalCause from "./cause.js"
@@ -175,17 +175,17 @@ export const catchAllDefect = dual<
 /* @internal */
 export const catchSomeCause: {
   <E, A2, E2, R2>(
-    f: (cause: Cause.Cause<NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A, E | E2, R2 | R>
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    f: (cause: Cause.Cause<NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
   ): Effect.Effect<A2 | A, E | E2, R2 | R>
 } = dual(
   2,
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    f: (cause: Cause.Cause<NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
   ): Effect.Effect<A2 | A, E | E2, R2 | R> =>
     core.matchCauseEffect(self, {
       onFailure: (cause): Effect.Effect<A2, E | E2, R2> => {
@@ -376,14 +376,14 @@ export const Do: Effect.Effect<{}> = core.succeed({})
 export const bind: {
   <N extends string, A extends object, B, E2, R2>(
     name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+    f: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
   ): <E1, R1>(
     self: Effect.Effect<A, E1, R1>
   ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E1, R2 | R1>
   <A extends object, N extends string, E1, R1, B, E2, R2>(
     self: Effect.Effect<A, E1, R1>,
     name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+    f: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
   ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E1 | E2, R1 | R2>
 } = doNotation.bind<Effect.EffectTypeLambda>(core.map, core.flatMap)
 
@@ -397,21 +397,21 @@ export const bindTo: {
 export const let_: {
   <N extends string, A extends object, B>(
     name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => B
+    f: (a: Types.NoInfer<A>) => B
   ): <E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
   <A extends object, N extends string, E, R, B>(
     self: Effect.Effect<A, E, R>,
     name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => B
+    f: (a: Types.NoInfer<A>) => B
   ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
 } = doNotation.let_<Effect.EffectTypeLambda>(core.map)
 
 /* @internal */
 export const dropUntil: {
   <A, E, R>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
@@ -447,7 +447,7 @@ export const dropUntil: {
 /* @internal */
 export const dropWhile: {
   <A, E, R>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
@@ -506,12 +506,12 @@ export const filterMap = dual<
 /* @internal */
 export const filterOrDie: {
   <A, B extends A>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
-    orDieWith: (a: NoInfer<A>) => unknown
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    orDieWith: (a: Types.NoInfer<A>) => unknown
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
   <A>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orDieWith: (a: NoInfer<A>) => unknown
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orDieWith: (a: Types.NoInfer<A>) => unknown
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
@@ -535,11 +535,11 @@ export const filterOrDie: {
 /* @internal */
 export const filterOrDieMessage: {
   <A, B extends A>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
     message: string
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
   <A>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
     message: string
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <A, E, R, B extends A>(
@@ -557,12 +557,12 @@ export const filterOrDieMessage: {
 /* @internal */
 export const filterOrElse: {
   <A, B extends A, C, E2, R2>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
-    orElse: (a: NoInfer<A>) => Effect.Effect<C, E2, R2>
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    orElse: (a: Types.NoInfer<A>) => Effect.Effect<C, E2, R2>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
   <A, B, E2, R2>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orElse: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orElse: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | B, E2 | E, R2 | R>
   <A, E, R, B extends A, C, E2, R2>(
     self: Effect.Effect<A, E, R>,
@@ -588,12 +588,12 @@ export const filterOrElse: {
 export const liftPredicate = dual<
   {
     <A, B extends A, E>(
-      refinement: Predicate.Refinement<NoInfer<A>, B>,
-      orFailWith: (a: NoInfer<A>) => E
+      refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+      orFailWith: (a: Types.NoInfer<A>) => E
     ): (a: A) => Effect.Effect<B, E>
     <A, E>(
-      predicate: Predicate.Predicate<NoInfer<A>>,
-      orFailWith: (a: NoInfer<A>) => E
+      predicate: Predicate.Predicate<Types.NoInfer<A>>,
+      orFailWith: (a: Types.NoInfer<A>) => E
     ): (a: A) => Effect.Effect<A, E>
   },
   {
@@ -604,34 +604,34 @@ export const liftPredicate = dual<
     ): Effect.Effect<B, E>
     <A, E>(
       self: A,
-      predicate: Predicate.Predicate<NoInfer<A>>,
-      orFailWith: (a: NoInfer<A>) => E
+      predicate: Predicate.Predicate<Types.NoInfer<A>>,
+      orFailWith: (a: Types.NoInfer<A>) => E
     ): Effect.Effect<A, E>
   }
 >(
   3,
   <A, E>(
     self: A,
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => E
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orFailWith: (a: Types.NoInfer<A>) => E
   ): Effect.Effect<A, E> => core.suspend(() => predicate(self) ? core.succeed(self) : core.fail(orFailWith(self)))
 )
 
 /* @internal */
 export const filterOrFail: {
   <A, B extends A, E2>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
-    orFailWith: (a: NoInfer<A>) => E2
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    orFailWith: (a: Types.NoInfer<A>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2 | E, R>
   <A, E2>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => E2
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orFailWith: (a: Types.NoInfer<A>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2 | E, R>
   <A, B extends A>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementException | E, R>
   <A>(
-    predicate: Predicate.Predicate<NoInfer<A>>
+    predicate: Predicate.Predicate<Types.NoInfer<A>>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Cause.NoSuchElementException | E, R>
   <A, E, R, B extends A, E2>(
     self: Effect.Effect<A, E, R>,
@@ -666,17 +666,17 @@ export const filterOrFail: {
 /* @internal */
 export const findFirst: {
   <A, E, R>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Option.Option<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Option.Option<A>, E, R>
 } = dual(
   2,
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Option.Option<A>, E, R> =>
     core.suspend(() => {
       const iterator = elements[Symbol.iterator]()
@@ -1195,25 +1195,25 @@ export const promise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): E
 
 /* @internal */
 export const provideService = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    service: Context.Tag.Service<T>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>>,
-  <A, E, R, T extends Context.Tag<any, any>>(
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, I>>,
+  <A, E, R, I, S>(
     self: Effect.Effect<A, E, R>,
-    tag: T,
-    service: Context.Tag.Service<T>
-  ) => Effect.Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>>
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ) => Effect.Effect<A, E, Exclude<R, I>>
 >(
   3,
-  <A, E, R, T extends Context.Tag<any, any>>(
+  <A, E, R, I, S>(
     self: Effect.Effect<A, E, R>,
-    tag: T,
-    service: Context.Tag.Service<T>
-  ): Effect.Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>> =>
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ): Effect.Effect<A, E, Exclude<R, I>> =>
     core.contextWithEffect((env) =>
       core.provideContext(
-        self as Effect.Effect<A, E, Context.Tag.Identifier<T> | Exclude<R, Context.Tag.Identifier<T>>>,
+        self as Effect.Effect<A, E, I | Exclude<R, I>>,
         Context.add(env, tag, service)
       )
     )
@@ -1221,21 +1221,21 @@ export const provideService = dual<
 
 /* @internal */
 export const provideServiceEffect = dual<
-  <T extends Context.Tag<any, any>, E1, R1>(
-    tag: T,
-    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>,
-  <A, E, R, T extends Context.Tag<any, any>, E1, R1>(
+  <I, S, E1, R1>(
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<Types.NoInfer<S>, E1, R1>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E1, R1 | Exclude<R, I>>,
+  <A, E, R, I, S, E1, R1>(
     self: Effect.Effect<A, E, R>,
-    tag: T,
-    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-  ) => Effect.Effect<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>
->(3, <A, E, R, T extends Context.Tag<any, any>, E1, R1>(
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<Types.NoInfer<S>, E1, R1>
+  ) => Effect.Effect<A, E | E1, R1 | Exclude<R, I>>
+>(3, <A, E, R, I, S, E1, R1>(
   self: Effect.Effect<A, E, R>,
-  tag: T,
-  effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
+  tag: Context.Tag<I, S>,
+  effect: Effect.Effect<Types.NoInfer<S>, E1, R1>
 ) =>
-  core.contextWithEffect((env: Context.Context<R1 | Exclude<R, Context.Tag.Identifier<T>>>) =>
+  core.contextWithEffect((env: Context.Context<R1 | Exclude<R, I>>) =>
     core.flatMap(
       effect,
       (service) => core.provideContext(self, pipe(env, Context.add(tag, service)) as Context.Context<R | R1>)
@@ -1426,17 +1426,17 @@ export const labelMetrics = dual<
 /* @internal */
 export const takeUntil: {
   <A, R, E>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Array<A>, E, R>
 } = dual(
   2,
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Array<A>, E, R> =>
     core.suspend(() => {
       const iterator = elements[Symbol.iterator]()
@@ -1462,15 +1462,15 @@ export const takeUntil: {
 /* @internal */
 export const takeWhile = dual<
   <A, E, R>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ) => (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>,
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ) => Effect.Effect<Array<A>, E, R>
 >(
   2,
-  <A, E, R>(elements: Iterable<A>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>) =>
+  <A, E, R>(elements: Iterable<A>, predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>) =>
     core.suspend(() => {
       const iterator = elements[Symbol.iterator]()
       const builder: Array<A> = []
@@ -1499,8 +1499,8 @@ export const takeWhile = dual<
 export const tapBoth = dual<
   <E, X, E2, R2, A, X1, E3, R3>(
     options: {
-      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<X, E2, R2>
-      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<X1, E3, R3>
+      readonly onFailure: (e: Types.NoInfer<E>) => Effect.Effect<X, E2, R2>
+      readonly onSuccess: (a: Types.NoInfer<A>) => Effect.Effect<X1, E3, R3>
     }
   ) => <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2 | E3, R | R2 | R3>,
   <A, E, R, X, E2, R2, X1, E3, R3>(
@@ -1545,7 +1545,7 @@ export const tapDefect = dual<
 /* @internal */
 export const tapError = dual<
   <E, X, E2, R2>(
-    f: (e: NoInfer<E>) => Effect.Effect<X, E2, R2>
+    f: (e: Types.NoInfer<E>) => Effect.Effect<X, E2, R2>
   ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>,
   <A, E, R, X, E2, R2>(
     self: Effect.Effect<A, E, R>,
@@ -1587,7 +1587,7 @@ export const tapErrorTag = dual<
 /* @internal */
 export const tapErrorCause = dual<
   <E, X, E2, R2>(
-    f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<X, E2, R2>
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Effect.Effect<X, E2, R2>
   ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>,
   <A, E, R, X, E2, R2>(
     self: Effect.Effect<A, E, R>,
@@ -1768,26 +1768,26 @@ export const updateFiberRefs = (
 
 /* @internal */
 export const updateService = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Context.Tag.Identifier<T>>,
-  <A, E, R, T extends Context.Tag<any, any>>(
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    f: (service: Types.NoInfer<S>) => Types.NoInfer<S>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | I>,
+  <A, E, R, I, S>(
     self: Effect.Effect<A, E, R>,
-    tag: T,
-    f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ) => Effect.Effect<A, E, R | Context.Tag.Identifier<T>>
->(3, <A, E, R, T extends Context.Tag<any, any>>(
+    tag: Context.Tag<I, S>,
+    f: (service: Types.NoInfer<S>) => Types.NoInfer<S>
+  ) => Effect.Effect<A, E, R | I>
+>(3, <A, E, R, I, S>(
   self: Effect.Effect<A, E, R>,
-  tag: T,
-  f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>
+  tag: Context.Tag<I, S>,
+  f: (service: Types.NoInfer<S>) => Types.NoInfer<S>
 ) =>
   core.mapInputContext(self, (context) =>
     Context.add(
       context,
       tag,
       f(Context.unsafeGet(context, tag))
-    )) as Effect.Effect<A, E, R | Context.Tag.Identifier<T>>)
+    )) as Effect.Effect<A, E, R | I>)
 
 /* @internal */
 export const when = dual<

package/src/internal/core.ts

@@ -1421,6 +1421,24 @@ export const gen: typeof Effect.gen = function() {
   return fromIterator(() => f(pipe))
 }
 
+/** @internal */
+export const fnUntraced: Effect.fn.Gen = (body: Function, ...pipeables: Array<any>) =>
+  Object.defineProperty(
+    pipeables.length === 0
+      ? function(this: any, ...args: Array<any>) {
+        return fromIterator(() => body.apply(this, args))
+      }
+      : function(this: any, ...args: Array<any>) {
+        let effect = fromIterator(() => body.apply(this, args))
+        for (const x of pipeables) {
+          effect = x(effect, ...args)
+        }
+        return effect
+      },
+    "length",
+    { value: body.length, configurable: true }
+  )
+
 /* @internal */
 export const withConcurrency = dual<
   (concurrency: number | "unbounded") => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
@@ -3040,6 +3058,68 @@ export const mapInputContext = dual<
   f: (context: Context.Context<R2>) => Context.Context<R>
 ) => contextWithEffect((context: Context.Context<R2>) => provideContext(self, f(context))))
 
+// -----------------------------------------------------------------------------
+// Filtering
+// -----------------------------------------------------------------------------
+
+/** @internal */
+export const filterEffectOrElse: {
+  <A, E2, R2, A2, E3, R3>(
+    options: {
+      readonly predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
+      readonly orElse: (a: NoInfer<A>) => Effect.Effect<A2, E3, R3>
+    }
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E | E2 | E3, R | R2 | R3>
+  <A, E, R, E2, R2, A2, E3, R3>(
+    self: Effect.Effect<A, E, R>,
+    options: {
+      readonly predicate: (a: A) => Effect.Effect<boolean, E2, R2>
+      readonly orElse: (a: A) => Effect.Effect<A2, E3, R3>
+    }
+  ): Effect.Effect<A | A2, E | E2 | E3, R | R2 | R3>
+} = dual(2, <A, E, R, E2, R2, A2, E3, R3>(
+  self: Effect.Effect<A, E, R>,
+  options: {
+    readonly predicate: (a: A) => Effect.Effect<boolean, E2, R2>
+    readonly orElse: (a: A) => Effect.Effect<A2, E3, R3>
+  }
+): Effect.Effect<A | A2, E | E2 | E3, R | R2 | R3> =>
+  flatMap(
+    self,
+    (a) =>
+      flatMap(
+        options.predicate(a),
+        (pass): Effect.Effect<A | A2, E3, R3> => pass ? succeed(a) : options.orElse(a)
+      )
+  ))
+
+/** @internal */
+export const filterEffectOrFail: {
+  <A, E2, R2, E3>(
+    options: {
+      readonly predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
+      readonly orFailWith: (a: NoInfer<A>) => E3
+    }
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2 | E3, R | R2>
+  <A, E, R, E2, R2, E3>(
+    self: Effect.Effect<A, E, R>,
+    options: {
+      readonly predicate: (a: A) => Effect.Effect<boolean, E2, R2>
+      readonly orFailWith: (a: A) => E3
+    }
+  ): Effect.Effect<A, E | E2 | E3, R | R2>
+} = dual(2, <A, E, R, E2, R2, E3>(
+  self: Effect.Effect<A, E, R>,
+  options: {
+    readonly predicate: (a: A) => Effect.Effect<boolean, E2, R2>
+    readonly orFailWith: (a: A) => E3
+  }
+): Effect.Effect<A, E | E2 | E3, R | R2> =>
+  filterEffectOrElse(self, {
+    predicate: options.predicate,
+    orElse: (a) => fail(options.orFailWith(a))
+  }))
+
 // -----------------------------------------------------------------------------
 // Tracing
 // -----------------------------------------------------------------------------

package/src/internal/dateTime.ts

@@ -306,6 +306,9 @@ export const unsafeNow: LazyArg<DateTime.Utc> = () => makeUtc(Date.now())
 // time zones
 // =============================================================================
 
+/** @internal */
+export const toUtc = (self: DateTime.DateTime): DateTime.Utc => makeUtc(self.epochMillis)
+
 /** @internal */
 export const setZone: {
   (zone: DateTime.TimeZone, options?: {

package/src/internal/differ.ts

@@ -7,6 +7,7 @@ import * as Dual from "../Function.js"
 import { constant, identity } from "../Function.js"
 import type { HashMap } from "../HashMap.js"
 import type { HashSet } from "../HashSet.js"
+import { pipeArguments } from "../Pipeable.js"
 import * as ChunkPatch from "./differ/chunkPatch.js"
 import * as ContextPatch from "./differ/contextPatch.js"
 import * as HashMapPatch from "./differ/hashMapPatch.js"
@@ -22,6 +23,9 @@ export const DifferProto = {
   [DifferTypeId]: {
     _P: identity,
     _V: identity
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
   }
 }
 

package/src/internal/effect/circular.ts

@@ -371,10 +371,11 @@ export const forkIn = dual<
               core.void :
               core.asVoid(core.interruptFiber(fiber))
           )
-        scopeImpl.state.finalizers.add(finalizer)
+        const key = {}
+        scopeImpl.state.finalizers.set(key, finalizer)
         fiber.addObserver(() => {
           if (scopeImpl.state._tag === "Closed") return
-          scopeImpl.state.finalizers.delete(finalizer)
+          scopeImpl.state.finalizers.delete(key)
         })
       } else {
         fiber.unsafeInterruptAsFork(parent.id())

package/src/internal/fiberRuntime.ts

@@ -1631,6 +1631,30 @@ export const annotateLogsScoped: {
   )
 }
 
+/** @internal */
+export const whenLogLevel = dual<
+  (
+    level: LogLevel.LogLevel | LogLevel.Literal
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, R>,
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+    level: LogLevel.LogLevel | LogLevel.Literal
+  ) => Effect.Effect<Option.Option<A>, E, R>
+>(2, (effect, level) => {
+  const requiredLogLevel = typeof level === "string" ? LogLevel.fromLiteral(level) : level
+
+  return core.withFiberRuntime((fiberState) => {
+    const minimumLogLevel = fiberState.getFiberRef(currentMinimumLogLevel)
+
+    // Imitate the behaviour of `FiberRuntime.log`
+    if (LogLevel.greaterThan(minimumLogLevel, requiredLogLevel)) {
+      return core.succeed(Option.none())
+    }
+
+    return core.map(effect, Option.some)
+  })
+})
+
 // circular with Effect
 
 /* @internal */
@@ -3211,7 +3235,7 @@ export const scope: Effect.Effect<Scope.Scope, never, Scope.Scope> = scopeTag
 export interface ScopeImpl extends Scope.CloseableScope {
   state: {
     readonly _tag: "Open"
-    readonly finalizers: Set<Scope.Scope.Finalizer>
+    readonly finalizers: Map<{}, Scope.Scope.Finalizer>
   } | {
     readonly _tag: "Closed"
     readonly exit: Exit.Exit<unknown, unknown>
@@ -3220,7 +3244,7 @@ export interface ScopeImpl extends Scope.CloseableScope {
 
 const scopeUnsafeAddFinalizer = (scope: ScopeImpl, fin: Scope.Scope.Finalizer): void => {
   if (scope.state._tag === "Open") {
-    scope.state.finalizers.add(fin)
+    scope.state.finalizers.set({}, fin)
   }
 }
 
@@ -3237,12 +3261,13 @@ const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
         newScope.state = this.state
         return newScope
       }
+      const key = {}
       const fin = (exit: Exit.Exit<unknown, unknown>) => newScope.close(exit)
-      this.state.finalizers.add(fin)
+      this.state.finalizers.set(key, fin)
       scopeUnsafeAddFinalizer(newScope, (_) =>
         core.sync(() => {
           if (this.state._tag === "Open") {
-            this.state.finalizers.delete(fin)
+            this.state.finalizers.delete(key)
           }
         }))
       return newScope
@@ -3297,7 +3322,7 @@ const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
       if (this.state._tag === "Closed") {
         return fin(this.state.exit)
       }
-      this.state.finalizers.add(fin)
+      this.state.finalizers.set({}, fin)
       return core.void
     })
   }
@@ -3308,7 +3333,7 @@ const scopeUnsafeMake = (
 ): ScopeImpl => {
   const scope = Object.create(ScopeImplProto)
   scope.strategy = strategy
-  scope.state = { _tag: "Open", finalizers: new Set() }
+  scope.state = { _tag: "Open", finalizers: new Map() }
   return scope
 }
 

package/src/internal/hashMap.ts

@@ -539,3 +539,19 @@ export const findFirst: {
     return Option.none()
   }
 )
+
+/** @internal */
+export const some: {
+  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean): (self: HM.HashMap<K, A>) => boolean
+  <K, A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => boolean): boolean
+} = Dual.dual(
+  2,
+  <K, A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => boolean): boolean => {
+    for (const ka of self) {
+      if (predicate(ka[1], ka[0])) {
+        return true
+      }
+    }
+    return false
+  }
+)

package/src/internal/keyedPool.ts

@@ -174,7 +174,7 @@ const makeImpl = <K, A, E, R>(
           }
         })
       const activePools: Effect.Effect<Array<Pool.Pool<A, E>>> = core.suspend(() =>
-        core.forEachSequential(Array.from(HashMap.values(MutableRef.get(map))), (value) => {
+        core.forEachSequential(HashMap.toValues(MutableRef.get(map)), (value) => {
           switch (value._tag) {
             case "Complete": {
               return core.succeed(value.pool)