effect 4.0.0-beta.4 → 4.0.0-beta.41

package/src/Channel.ts

@@ -63,14 +63,15 @@ import * as Chunk from "./Chunk.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
-import * as Filter from "./Filter.ts"
+import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constant, constTrue, constVoid, dual, identity as identity_ } from "./Function.ts"
 import { ClockRef, endSpan } from "./internal/effect.ts"
 import { addSpanStackTrace } from "./internal/tracer.ts"
 import * as Iterable from "./Iterable.ts"
+import * as Latch from "./Latch.ts"
 import * as Layer from "./Layer.ts"
-import type { LogLevel } from "./LogLevel.ts"
+import type { Severity } from "./LogLevel.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
@@ -83,6 +84,7 @@ import { TracerTimingEnabled } from "./References.ts"
 import * as Result from "./Result.ts"
 import * as Schedule from "./Schedule.ts"
 import * as Scope from "./Scope.ts"
+import * as Semaphore from "./Semaphore.ts"
 import * as ServiceMap from "./ServiceMap.ts"
 import * as String from "./String.ts"
 import * as Take from "./Take.ts"
@@ -90,7 +92,17 @@ import { ParentSpan, type SpanOptions } from "./Tracer.ts"
 import type * as Types from "./Types.ts"
 import type * as Unify from "./Unify.ts"
 
-const TypeId = "~effect/Channel"
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export type TypeId = "~effect/Channel"
+
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export const TypeId: TypeId = "~effect/Channel"
 
 /**
  * Tests if a value is a `Channel`.
@@ -188,8 +200,8 @@ export interface ChannelUnify<A extends { [Unify.typeSymbol]?: any }> extends Ef
  * @category models
  * @since 2.0.0
  */
-export interface ChannelUnifyIgnore extends Effect.EffectUnifyIgnore {
-  Channel?: true
+export interface ChannelUnifyIgnore {
+  Effect?: true
 }
 
 type TagsWithReason<E> = {
@@ -2084,7 +2096,7 @@ const mapEffectConcurrent = <
       const trackFiber = Fiber.runIn(forkedScope)
 
       if (options.unordered) {
-        const semaphore = Effect.makeSemaphoreUnsafe(concurrencyN)
+        const semaphore = Semaphore.makeUnsafe(concurrencyN)
         const release = constant(semaphore.release(1))
         const handle = Effect.matchCauseEffect({
           onFailure: (cause: Cause.Cause<EX>) => Effect.flatMap(Queue.failCause(queue, cause), release),
@@ -3562,9 +3574,9 @@ export const filter: {
    * @since 2.0.0
    * @category Filtering
    */
-  <OutElem, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<OutElem, Result>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <OutElem>(predicate: Predicate.Predicate<OutElem>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
-  ) => Channel<Filter.Pass<OutElem, Result>, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
   /**
    * Filters the output elements of a channel using a predicate function.
    * Elements that don't match the predicate are discarded.
@@ -3623,24 +3635,59 @@ export const filter: {
    * @since 2.0.0
    * @category Filtering
    */
-  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, Result extends Filter.ResultOrBool>(
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    predicate: Predicate.Predicate<OutElem>
+  ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  predicate: Predicate.Predicate<OutElem>
+): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env> =>
+  fromTransform((upstream, scope) =>
+    Effect.map(
+      toTransform(self)(upstream, scope),
+      (pull) =>
+        Effect.flatMap(pull, function loop(elem): Pull.Pull<OutElem, OutErr, OutDone> {
+          return predicate(elem)
+            ? Effect.succeed(elem)
+            : Effect.flatMap(pull, loop)
+        })
+    )
+  ))
+
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMap: {
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, B, X>(filter: Filter.Filter<OutElem, B, X>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<B, OutErr, OutDone, InElem, InErr, InDone, Env>
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    filter: Filter.OrPredicate<OutElem, Result>
-  ): Channel<Filter.Pass<OutElem, Result>, OutErr, OutDone, InElem, InErr, InDone, Env>
-} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, Result extends Filter.ResultOrBool>(
+    filter: Filter.Filter<OutElem, B, X>
+  ): Channel<B, OutErr, OutDone, InElem, InErr, InDone, Env>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter: Filter.OrPredicate<OutElem, Result>
-): Channel<Filter.Pass<OutElem, Result>, OutErr, OutDone, InElem, InErr, InDone, Env> =>
+  filter: Filter.Filter<OutElem, B, X>
+): Channel<B, OutErr, OutDone, InElem, InErr, InDone, Env> =>
   fromTransform((upstream, scope) =>
     Effect.map(
       toTransform(self)(upstream, scope),
       (pull) =>
-        Effect.flatMap(pull, function loop(elem): Pull.Pull<Filter.Pass<OutElem, Result>, OutErr, OutDone> {
+        Effect.flatMap(pull, function loop(elem): Pull.Pull<B, OutErr, OutDone> {
           const result = filter(elem)
-          if (result === true) return Effect.succeed(elem as Filter.Pass<OutElem, Result>)
-          else if (result === false) return Effect.flatMap(pull, loop)
-          else if (Result.isSuccess(result)) return Effect.succeed(result.success)
-          return Effect.flatMap(pull, loop)
+          return Result.isFailure(result)
+            ? Effect.flatMap(pull, loop)
+            : Effect.succeed(result.success)
         })
     )
   ))
@@ -3650,6 +3697,46 @@ export const filter: {
  * @category Filtering
  */
 export const filterEffect: {
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, E, R>(predicate: (a: OutElem) => Effect.Effect<boolean, E, R>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, E, R>(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    predicate: (a: OutElem) => Effect.Effect<boolean, E, R>
+  ): Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, E, R>(
+  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  predicate: (a: OutElem) => Effect.Effect<boolean, E, R>
+): Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Env | R> =>
+  fromTransform((upstream, scope) =>
+    Effect.map(
+      toTransform(self)(upstream, scope),
+      (pull) =>
+        Effect.flatMap(pull, function loop(elem): Pull.Pull<OutElem, OutErr | E, OutDone, R> {
+          return Effect.flatMap(
+            predicate(elem),
+            (passes) =>
+              passes
+                ? Effect.succeed(elem)
+                : Effect.flatMap(pull, loop)
+          )
+        })
+    )
+  ))
+
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapEffect: {
   /**
    * @since 4.0.0
    * @category Filtering
@@ -3794,9 +3881,9 @@ export const filterArray: {
    * @since 4.0.0
    * @category Filtering
    */
-  <OutElem, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<Types.NoInfer<OutElem>, Result>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <OutElem>(predicate: Predicate.Predicate<Types.NoInfer<OutElem>>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
-  ) => Channel<Arr.NonEmptyReadonlyArray<Filter.Pass<OutElem, Result>>, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
   /**
    * Filters arrays of elements emitted by a channel, applying the filter
    * to each element within the arrays and only emitting non-empty filtered arrays.
@@ -3871,19 +3958,24 @@ export const filterArray: {
    * @since 4.0.0
    * @category Filtering
    */
-  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, Result extends Filter.ResultOrBool>(
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    filter: Filter.OrPredicate<Types.NoInfer<OutElem>, Result>
-  ): Channel<Arr.NonEmptyReadonlyArray<Filter.Pass<OutElem, Result>>, OutErr, OutDone, InElem, InErr, InDone, Env>
-} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, Result extends Filter.ResultOrBool>(
+    predicate: Predicate.Predicate<Types.NoInfer<OutElem>>
+  ): Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
   self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter: Filter.OrPredicate<Types.NoInfer<OutElem>, Result>
-): Channel<Arr.NonEmptyReadonlyArray<Filter.Pass<OutElem, Result>>, OutErr, OutDone, InElem, InErr, InDone, Env> =>
+  predicate: Predicate.Predicate<Types.NoInfer<OutElem>>
+): Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env> =>
   transformPull(self, (pull) =>
     Effect.succeed(Effect.flatMap(
       pull,
-      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<any>, OutErr, OutDone> {
-        const [, passes] = Arr.partition(arr, filter as any)
+      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone> {
+        const passes: Array<OutElem> = []
+        for (let i = 0; i < arr.length; i++) {
+          if (predicate(arr[i] as Types.NoInfer<OutElem>)) {
+            passes.push(arr[i])
+          }
+        }
         return Arr.isReadonlyArrayNonEmpty(passes)
           ? Effect.succeed(passes)
           : Effect.flatMap(pull, loop)
@@ -3894,23 +3986,57 @@ export const filterArray: {
  * @since 4.0.0
  * @category Filtering
  */
-export const filterArrayEffect: {
+export const filterMapArray: {
   /**
    * @since 4.0.0
    * @category Filtering
    */
-  <OutElem, E, R>(
-    predicate: (a: Types.NoInfer<OutElem>, index: number) => Effect.Effect<boolean, E, R>
-  ): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <OutElem, B, X>(filter: Filter.Filter<Types.NoInfer<OutElem>, B, X>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
-  ) => Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
+  ) => Channel<Arr.NonEmptyReadonlyArray<B>, OutErr, OutDone, InElem, InErr, InDone, Env>
   /**
    * @since 4.0.0
    * @category Filtering
    */
-  <OutElem, B, X, EX, RX>(filter: Filter.FilterEffect<OutElem, B, X, EX, RX>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X>(
+    self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    filter: Filter.Filter<OutElem, B, X>
+  ): Channel<Arr.NonEmptyReadonlyArray<B>, OutErr, OutDone, InElem, InErr, InDone, Env>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X>(
+  self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  filter: Filter.Filter<OutElem, B, X>
+): Channel<Arr.NonEmptyReadonlyArray<B>, OutErr, OutDone, InElem, InErr, InDone, Env> =>
+  transformPull(self, (pull) =>
+    Effect.succeed(Effect.flatMap(
+      pull,
+      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<B>, OutErr, OutDone> {
+        const passes: Array<B> = []
+        for (let i = 0; i < arr.length; i++) {
+          const result = filter(arr[i])
+          if (Result.isSuccess(result)) {
+            passes.push(result.success)
+          }
+        }
+        return Arr.isReadonlyArrayNonEmpty(passes)
+          ? Effect.succeed(passes)
+          : Effect.flatMap(pull, loop)
+      }
+    ))))
+
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterArrayEffect: {
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, E, R>(
+    predicate: (a: Types.NoInfer<OutElem>, index: number) => Effect.Effect<boolean, E, R>
+  ): <OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
-  ) => Channel<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, InElem, InErr, InDone, Env | RX>
+  ) => Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
   /**
    * @since 4.0.0
    * @category Filtering
@@ -3919,6 +4045,32 @@ export const filterArrayEffect: {
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
     predicate: (a: Types.NoInfer<OutElem>, index: number) => Effect.Effect<boolean, E, R>
   ): Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, E, R>(
+  self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  predicate: (a: Types.NoInfer<OutElem>, index: number) => Effect.Effect<boolean, E, R>
+): Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, InElem, InErr, InDone, Env | R> =>
+  transformPull(self, (pull) => {
+    const f = Effect.flatMap(pull, (arr) => Effect.filter(arr, predicate))
+    return Effect.succeed(Effect.flatMap(
+      f,
+      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, R> {
+        return Arr.isReadonlyArrayNonEmpty(arr) ? Effect.succeed(arr) : Effect.flatMap(f, loop)
+      }
+    ))
+  }))
+
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapArrayEffect: {
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, B, X, EX, RX>(filter: Filter.FilterEffect<Types.NoInfer<OutElem>, B, X, EX, RX>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+    self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, InElem, InErr, InDone, Env | RX>
   /**
    * @since 4.0.0
    * @category Filtering
@@ -3927,32 +4079,23 @@ export const filterArrayEffect: {
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
     filter: Filter.FilterEffect<OutElem, B, X, EX, RX>
   ): Channel<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, InElem, InErr, InDone, Env | RX>
-} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X, EX, RX>(
   self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter:
-    | Filter.FilterEffect<OutElem, any, any, any, any>
-    | ((a: OutElem, index: number) => Effect.Effect<boolean, any, any>)
-): Channel<Arr.NonEmptyReadonlyArray<any>, any, OutDone, InElem, InErr, InDone, any> => {
-  if (filter.length > 1) {
-    // effectful boolean predicate: (a, index) => Effect<boolean>
-    const predicate = filter as (a: OutElem, index: number) => Effect.Effect<boolean, any, any>
-    return transformPull(self, (pull) => {
-      const f = Effect.flatMap(pull, (arr) => Effect.filter(arr, predicate))
-      return Effect.succeed(Effect.flatMap(
-        f,
-        function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<any>, any, OutDone, any> {
-          return Arr.isReadonlyArrayNonEmpty(arr) ? Effect.succeed(arr) : Effect.flatMap(f, loop)
-        }
-      ))
-    })
-  }
-  // FilterEffect: (a) => Effect<pass|fail>
-  return filterEffect(self, (arr) =>
-    Effect.map(
-      Effect.filter(arr, filter as any),
-      (passes) => Arr.isReadonlyArrayNonEmpty(passes) ? Result.succeed(passes) : Result.fail(undefined)
-    ))
-})
+  filter: Filter.FilterEffect<OutElem, B, X, EX, RX>
+): Channel<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, InElem, InErr, InDone, Env | RX> =>
+  transformPull(self, (pull) =>
+    Effect.succeed(Effect.flatMap(
+      pull,
+      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, RX> {
+        return Effect.flatMap(
+          Effect.filterMapEffect(arr, filter as any),
+          (passes) =>
+            Arr.isReadonlyArrayNonEmpty(passes)
+              ? Effect.succeed(passes as Arr.NonEmptyReadonlyArray<B>)
+              : Effect.flatMap(pull, loop)
+        )
+      }
+    ))))
 
 /**
  * Statefully maps over a channel with an accumulator, where each element can produce multiple output values.
@@ -4447,17 +4590,19 @@ export const scanEffect: {
     Effect.map(toTransform(self)(upstream, scope), (pull) => {
       let state = initial
       let isFirst = true
-      if (isFirst) {
-        isFirst = false
-        return Effect.succeed(state)
-      }
-      return Effect.map(
-        Effect.flatMap(pull, (a) => f(state, a)),
-        (newState) => {
-          state = newState
-          return state
+      return Effect.suspend(() => {
+        if (isFirst) {
+          isFirst = false
+          return Effect.succeed(state)
         }
-      )
+        return Effect.map(
+          Effect.flatMap(pull, (a) => f(state, a)),
+          (newState) => {
+            state = newState
+            return state
+          }
+        )
+      })
     })
   ))
 
@@ -4755,7 +4900,6 @@ export const catchCauseIf: {
    */
   <
     OutErr,
-    Result extends Filter.ResultOrBool<Cause.Cause<any>>,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -4764,11 +4908,8 @@ export const catchCauseIf: {
     InDone1,
     Env1
   >(
-    filter: Filter.OrPredicate<Cause.Cause<OutErr>, Result>,
-    f: (
-      failure: Filter.Pass<Cause.Cause<OutErr>, Result>,
-      cause: Cause.Cause<OutErr>
-    ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+    predicate: Predicate.Predicate<Cause.Cause<OutErr>>,
+    f: (cause: Cause.Cause<OutErr>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
   ): <
     OutElem,
     OutDone,
@@ -4778,7 +4919,7 @@ export const catchCauseIf: {
     Env
   >(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<
     OutElem | OutElem1,
-    Cause.Cause.Error<Filter.Fail<Cause.Cause<OutErr>, Result>> | OutErr1,
+    OutErr | OutErr1,
     OutDone | OutDone1,
     InElem & InElem1,
     InErr & InErr1,
@@ -4800,7 +4941,6 @@ export const catchCauseIf: {
     InErr,
     InDone,
     Env,
-    Result extends Filter.ResultOrBool<Cause.Cause<any>>,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -4810,14 +4950,137 @@ export const catchCauseIf: {
     Env1
   >(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    filter: Filter.OrPredicate<Cause.Cause<OutErr>, Result>,
+    predicate: Predicate.Predicate<Cause.Cause<OutErr>>,
+    f: (cause: Cause.Cause<OutErr>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+  ): Channel<
+    OutElem | OutElem1,
+    OutErr | OutErr1,
+    OutDone | OutDone1,
+    InElem & InElem1,
+    InErr & InErr1,
+    InDone & InDone1,
+    Env | Env1
+  >
+} = dual(3, <
+  OutElem,
+  OutErr,
+  OutDone,
+  InElem,
+  InErr,
+  InDone,
+  Env,
+  OutElem1,
+  OutErr1,
+  OutDone1,
+  InElem1,
+  InErr1,
+  InDone1,
+  Env1
+>(
+  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  predicate: Predicate.Predicate<Cause.Cause<OutErr>>,
+  f: (cause: Cause.Cause<OutErr>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+): Channel<
+  OutElem | OutElem1,
+  OutErr | OutErr1,
+  OutDone | OutDone1,
+  InElem & InElem1,
+  InErr & InErr1,
+  InDone & InDone1,
+  Env | Env1
+> =>
+  catchCause(
+    self,
+    (
+      cause
+    ): Channel<
+      OutElem1,
+      OutErr | OutErr1,
+      OutDone1,
+      InElem1,
+      InErr1,
+      InDone1,
+      Env1
+    > => {
+      return predicate(cause)
+        ? f(cause)
+        : failCause(cause as any)
+    }
+  ))
+
+/**
+ * @since 4.0.0
+ * @category Error handling
+ */
+export const catchCauseFilter: {
+  /**
+   * @since 4.0.0
+   * @category Error handling
+   */
+  <
+    OutErr,
+    EB,
+    X extends Cause.Cause<any>,
+    OutElem1,
+    OutErr1,
+    OutDone1,
+    InElem1,
+    InErr1,
+    InDone1,
+    Env1
+  >(
+    filter: Filter.Filter<Cause.Cause<OutErr>, EB, X>,
     f: (
-      failure: Filter.Pass<Cause.Cause<OutErr>, Result>,
+      failure: EB,
+      cause: Cause.Cause<OutErr>
+    ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+  ): <
+    OutElem,
+    OutDone,
+    InElem,
+    InErr,
+    InDone,
+    Env
+  >(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<
+    OutElem | OutElem1,
+    Cause.Cause.Error<X> | OutErr1,
+    OutDone | OutDone1,
+    InElem & InElem1,
+    InErr & InErr1,
+    InDone & InDone1,
+    Env | Env1
+  >
+  /**
+   * @since 4.0.0
+   * @category Error handling
+   */
+  <
+    OutElem,
+    OutErr,
+    OutDone,
+    InElem,
+    InErr,
+    InDone,
+    Env,
+    EB,
+    X extends Cause.Cause<any>,
+    OutElem1,
+    OutErr1,
+    OutDone1,
+    InElem1,
+    InErr1,
+    InDone1,
+    Env1
+  >(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    filter: Filter.Filter<Cause.Cause<OutErr>, EB, X>,
+    f: (
+      failure: EB,
       cause: Cause.Cause<OutErr>
     ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
   ): Channel<
     OutElem | OutElem1,
-    Cause.Cause.Error<Filter.Fail<Cause.Cause<OutErr>, Result>> | OutErr1,
+    Cause.Cause.Error<X> | OutErr1,
     OutDone | OutDone1,
     InElem & InElem1,
     InErr & InErr1,
@@ -4832,7 +5095,8 @@ export const catchCauseIf: {
   InErr,
   InDone,
   Env,
-  Result extends Filter.ResultOrBool<Cause.Cause<any>>,
+  EB,
+  X extends Cause.Cause<any>,
   OutElem1,
   OutErr1,
   OutDone1,
@@ -4842,14 +5106,14 @@ export const catchCauseIf: {
   Env1
 >(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter: Filter.OrPredicate<Cause.Cause<OutErr>, Result>,
+  filter: Filter.Filter<Cause.Cause<OutErr>, EB, X>,
   f: (
-    failure: Filter.Pass<Cause.Cause<OutErr>, Result>,
+    failure: EB,
     cause: Cause.Cause<OutErr>
   ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
 ): Channel<
   OutElem | OutElem1,
-  Cause.Cause.Error<Filter.Fail<Cause.Cause<OutErr>, Result>> | OutErr1,
+  Cause.Cause.Error<X> | OutErr1,
   OutDone | OutDone1,
   InElem & InElem1,
   InErr & InErr1,
@@ -4862,18 +5126,17 @@ export const catchCauseIf: {
       cause
     ): Channel<
       OutElem1,
-      Cause.Cause.Error<Filter.Fail<Cause.Cause<OutErr>, Result>> | OutErr1,
+      Cause.Cause.Error<X> | OutErr1,
       OutDone1,
       InElem1,
       InErr1,
       InDone1,
       Env1
     > => {
-      const eb = filter(cause)
-      if (eb === true) return f(cause as any, cause)
-      else if (eb === false) return failCause(cause as any)
-      else if (Result.isSuccess(eb)) return f(eb.success as any, cause)
-      return failCause(eb.failure)
+      const result = filter(cause)
+      return Result.isFailure(result)
+        ? failCause(result.failure)
+        : f(result.success, cause)
     }
   ))
 
@@ -4949,7 +5212,7 @@ const catch_: {
   InErr & InErr1,
   InDone & InDone1,
   Env | Env1
-> => catchCauseIf(self, Cause.findError as any, (e: any) => f(e)) as any)
+> => catchCauseFilter(self, Cause.findError, (e) => f(e)))
 
 export {
   /**
@@ -5099,7 +5362,6 @@ export const catchIf: {
    */
   <
     OutErr,
-    Result extends Filter.ResultOrBool,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -5108,18 +5370,18 @@ export const catchIf: {
     InDone1,
     Env1,
     OutElem2 = never,
-    OutErr2 = Filter.Fail<OutErr, Result>,
+    OutErr2 = OutErr,
     OutDone2 = never,
     InElem2 = unknown,
     InErr2 = unknown,
     InDone2 = unknown,
     Env2 = never
   >(
-    filter: Filter.OrPredicate<OutErr, Result>,
-    f: (failure: Filter.Pass<OutErr, Result>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+    predicate: Predicate.Predicate<OutErr>,
+    f: (failure: OutErr) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     orElse?:
       | ((
-        failure: Filter.Fail<OutErr, Result>
+        failure: OutErr
       ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
       | undefined
   ): <
@@ -5195,7 +5457,6 @@ export const catchIf: {
     InErr,
     InDone,
     Env,
-    Result extends Filter.ResultOrBool,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -5204,7 +5465,7 @@ export const catchIf: {
     InDone1,
     Env1,
     OutElem2 = never,
-    OutErr2 = Filter.Fail<OutErr, Result>,
+    OutErr2 = OutErr,
     OutDone2 = never,
     InElem2 = unknown,
     InErr2 = unknown,
@@ -5212,11 +5473,11 @@ export const catchIf: {
     Env2 = never
   >(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    filter: Filter.OrPredicate<OutErr, Result>,
-    f: (failure: Filter.Pass<OutErr, Result>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+    predicate: Predicate.Predicate<OutErr>,
+    f: (failure: OutErr) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     orElse?:
       | ((
-        failure: Filter.Fail<OutErr, Result>
+        failure: OutErr
       ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
       | undefined
   ): Channel<
@@ -5236,7 +5497,6 @@ export const catchIf: {
   InErr,
   InDone,
   Env,
-  Result extends Filter.ResultOrBool,
   OutElem1,
   OutErr1,
   OutDone1,
@@ -5245,7 +5505,7 @@ export const catchIf: {
   InDone1,
   Env1,
   OutElem2 = never,
-  OutErr2 = Filter.Fail<OutErr, Result>,
+  OutErr2 = OutErr,
   OutDone2 = never,
   InElem2 = unknown,
   InErr2 = unknown,
@@ -5253,11 +5513,11 @@ export const catchIf: {
   Env2 = never
 >(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter: Filter.OrPredicate<OutErr, Result>,
-  f: (failure: Filter.Pass<OutErr, Result>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+  predicate: Predicate.Predicate<OutErr>,
+  f: (failure: OutErr) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
   orElse?:
     | ((
-      failure: Filter.Fail<OutErr, Result>
+      failure: OutErr
     ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
     | undefined
 ): Channel<
@@ -5280,12 +5540,170 @@ export const catchIf: {
       InDone1 & InDone2,
       Env1 | Env2
     > => {
-      const eb = Filter.apply(filter as any, err)
-      return !Result.isFailure(eb)
-        ? f(eb.success as any)
+      return predicate(err)
+        ? f(err)
         : orElse
-        ? orElse(eb.failure as any)
-        : fail(eb.failure as any) as any
+        ? orElse(err)
+        : fail(err as any) as any
+    }
+  ))
+
+/**
+ * @since 4.0.0
+ * @category Error handling
+ */
+export const catchFilter: {
+  /**
+   * @since 4.0.0
+   * @category Error handling
+   */
+  <
+    OutErr,
+    EB,
+    X,
+    OutElem1,
+    OutErr1,
+    OutDone1,
+    InElem1,
+    InErr1,
+    InDone1,
+    Env1,
+    OutElem2 = never,
+    OutErr2 = X,
+    OutDone2 = never,
+    InElem2 = unknown,
+    InErr2 = unknown,
+    InDone2 = unknown,
+    Env2 = never
+  >(
+    filter: Filter.Filter<OutErr, EB, X>,
+    f: (failure: EB) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+    orElse?:
+      | ((
+        failure: X
+      ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
+      | undefined
+  ): <
+    OutElem,
+    OutDone,
+    InElem,
+    InErr,
+    InDone,
+    Env
+  >(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<
+    OutElem | OutElem1 | OutElem2,
+    OutErr1 | OutErr2,
+    OutDone | OutDone1 | OutDone2,
+    InElem & InElem1 & InElem2,
+    InErr & InErr1 & InErr2,
+    InDone & InDone1 & InDone2,
+    Env | Env1 | Env2
+  >
+  /**
+   * @since 4.0.0
+   * @category Error handling
+   */
+  <
+    OutElem,
+    OutErr,
+    OutDone,
+    InElem,
+    InErr,
+    InDone,
+    Env,
+    EB,
+    X,
+    OutElem1,
+    OutErr1,
+    OutDone1,
+    InElem1,
+    InErr1,
+    InDone1,
+    Env1,
+    OutElem2 = never,
+    OutErr2 = X,
+    OutDone2 = never,
+    InElem2 = unknown,
+    InErr2 = unknown,
+    InDone2 = unknown,
+    Env2 = never
+  >(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    filter: Filter.Filter<OutErr, EB, X>,
+    f: (failure: EB) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+    orElse?:
+      | ((
+        failure: X
+      ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
+      | undefined
+  ): Channel<
+    OutElem | OutElem1 | OutElem2,
+    OutErr1 | OutErr2,
+    OutDone | OutDone1 | OutDone2,
+    InElem & InElem1 & InElem2,
+    InErr & InErr1 & InErr2,
+    InDone & InDone1 & InDone2,
+    Env | Env1 | Env2
+  >
+} = dual((args) => isChannel(args[0]), <
+  OutElem,
+  OutErr,
+  OutDone,
+  InElem,
+  InErr,
+  InDone,
+  Env,
+  EB,
+  X,
+  OutElem1,
+  OutErr1,
+  OutDone1,
+  InElem1,
+  InErr1,
+  InDone1,
+  Env1,
+  OutElem2 = never,
+  OutErr2 = X,
+  OutDone2 = never,
+  InElem2 = unknown,
+  InErr2 = unknown,
+  InDone2 = unknown,
+  Env2 = never
+>(
+  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  filter: Filter.Filter<OutErr, EB, X>,
+  f: (failure: EB) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+  orElse?:
+    | ((
+      failure: X
+    ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
+    | undefined
+): Channel<
+  OutElem | OutElem1 | OutElem2,
+  OutErr1 | OutErr2,
+  OutDone | OutDone1 | OutDone2,
+  InElem & InElem1 & InElem2,
+  InErr & InErr1 & InErr2,
+  InDone & InDone1 & InDone2,
+  Env | Env1 | Env2
+> =>
+  catch_(
+    self,
+    (err): Channel<
+      OutElem1 | OutElem2,
+      OutErr1 | OutErr2,
+      OutDone1 | OutDone2,
+      InElem1 & InElem2,
+      InErr1 & InErr2,
+      InDone1 & InDone2,
+      Env1 | Env2
+    > => {
+      const result = filter(err)
+      return Result.isFailure(result)
+        ? orElse
+          ? orElse(result.failure)
+          : fail(result.failure as any) as any
+        : f(result.success)
     }
   ))
 
@@ -5526,11 +5944,13 @@ export const catchReason: {
     errorTag: K,
     reasonTag: RK,
     f: (
-      reason: Types.ExtractReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
+      reason: Types.ExtractReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>,
+      error: Types.NarrowReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
     ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     orElse?:
       | ((
-        reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
+        reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>,
+        error: Types.OmitReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
       ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
       | undefined
   ): <
@@ -5613,11 +6033,13 @@ export const catchReason: {
     errorTag: K,
     reasonTag: RK,
     f: (
-      reason: Types.ExtractReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
+      reason: Types.ExtractReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>,
+      error: Types.NarrowReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
     ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     orElse?:
       | ((
-        reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
+        reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>,
+        error: Types.OmitReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
       ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
       | undefined
   ): Channel<
@@ -5658,11 +6080,13 @@ export const catchReason: {
   errorTag: K,
   reasonTag: RK,
   f: (
-    reason: Types.ExtractReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
+    reason: Types.ExtractReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>,
+    error: Types.NarrowReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
   ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
   orElse?:
     | ((
-      reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
+      reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>,
+      error: Types.OmitReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
     ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
     | undefined
 ): Channel<
@@ -5688,9 +6112,9 @@ export const catchReason: {
       if (isTagged(error, errorTag) && hasProperty(error, "reason")) {
         const reason = error.reason as Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
         if (isTagged(reason, reasonTag)) {
-          return f(reason as any)
+          return f(reason as any, error as any)
         }
-        return orElse ? orElse(reason) as any : fail(error) as any
+        return orElse ? orElse(reason, error as any) as any : fail(error) as any
       }
       return fail(error) as any
     }
@@ -5714,7 +6138,8 @@ export const catchReasons: {
     OutErr,
     Cases extends {
       [RK in Types.ReasonTags<Types.ExtractTag<Types.NoInfer<OutErr>, K>>]+?: (
-        reason: Types.ExtractReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
+        reason: Types.ExtractReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>,
+        error: Types.NarrowReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, RK>
       ) => Channel<any, any, any, any, any, any, any>
     },
     OutElem2 = Types.unassigned,
@@ -5729,7 +6154,8 @@ export const catchReasons: {
     cases: Cases,
     orElse?:
       | ((
-        reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, Extract<keyof Cases, string>>
+        reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, Extract<keyof Cases, string>>,
+        error: Types.OmitReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, Extract<keyof Cases, string>>
       ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
       | undefined
   ): <OutElem, OutDone, InElem, InErr, InDone, Env>(
@@ -5795,7 +6221,8 @@ export const catchReasons: {
     K extends Types.Tags<OutErr>,
     Cases extends {
       [RK in Types.ReasonTags<Types.ExtractTag<OutErr, K>>]+?: (
-        reason: Types.ExtractReason<Types.ExtractTag<OutErr, K>, RK>
+        reason: Types.ExtractReason<Types.ExtractTag<OutErr, K>, RK>,
+        error: Types.NarrowReason<Types.ExtractTag<OutErr, K>, RK>
       ) => Channel<any, any, any, any, any, any, any>
     },
     OutElem2 = Types.unassigned,
@@ -5811,7 +6238,8 @@ export const catchReasons: {
     cases: Cases,
     orElse?:
       | ((
-        reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, Extract<keyof Cases, string>>
+        reason: Types.ExcludeReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, Extract<keyof Cases, string>>,
+        error: Types.OmitReason<Types.ExtractTag<Types.NoInfer<OutErr>, K>, Extract<keyof Cases, string>>
       ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
       | undefined
   ): Channel<
@@ -5860,7 +6288,7 @@ export const catchReasons: {
   >
 } = dual((args) => isChannel(args[0]), (self, errorTag, cases, orElse) => {
   let keys: Set<string>
-  return catch_(self, (error: any) => {
+  return catch_(self, (error) => {
     if (
       isTagged(error, errorTag) &&
       hasProperty(error, "reason") &&
@@ -5870,9 +6298,9 @@ export const catchReasons: {
       const reason = error.reason as { readonly _tag: string }
       keys ??= new Set(Object.keys(cases))
       if (keys.has(reason._tag)) {
-        return (cases as any)[reason._tag](reason as any)
+        return (cases as any)[reason._tag](reason as any, error)
       }
-      return orElse ? orElse(reason) as any : fail(error) as any
+      return orElse ? orElse(reason, error) as any : fail(error) as any
     }
     return fail(error) as any
   })
@@ -6022,11 +6450,11 @@ export const unwrapReason: {
   InDone,
   Env
 > =>
-  catchIf(
+  catchFilter(
     self,
-    (error: any) =>
+    (error) =>
       isTagged(error, errorTag) && hasProperty(error, "reason") ? Result.succeed(error.reason) : Result.fail(error),
-    fail as any
+    fail
   ) as any)
 
 /**
@@ -6112,14 +6540,14 @@ export const orDie = <
  */
 export const ignore: <
   Arg extends Channel<any, any, any, any, any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   }
 >(
   selfOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 ) => [Arg] extends
   [Channel<infer OutElem, infer _OutErr, infer OutDone, infer InElem, infer InErr, infer InDone, infer Env>]
@@ -6131,7 +6559,7 @@ export const ignore: <
     <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
       self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
       options?: {
-        readonly log?: boolean | LogLevel | undefined
+        readonly log?: boolean | Severity | undefined
       } | undefined
     ): Channel<OutElem, never, OutDone | void, InElem, InErr, InDone, Env> => {
       if (!options?.log) {
@@ -6167,14 +6595,14 @@ const ignoreCause_ = <
  */
 export const ignoreCause: <
   Arg extends Channel<any, any, any, any, any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   }
 >(
   selfOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 ) => [Arg] extends
   [Channel<infer OutElem, infer _OutErr, infer OutDone, infer InElem, infer InErr, infer InDone, infer Env>]
@@ -6185,7 +6613,7 @@ export const ignoreCause: <
     (args) => isChannel(args[0]),
     <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
       self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-      options?: { readonly log?: boolean | LogLevel | undefined } | undefined
+      options?: { readonly log?: boolean | Severity | undefined } | undefined
     ): Channel<OutElem, never, OutDone | void, InElem, InErr, InDone, Env> => {
       if (!options?.log) return ignoreCause_(self)
       const logEffect = Effect.logWithLevel(options.log === true ? undefined : options.log)
@@ -6631,8 +7059,8 @@ export const mergeAll: {
         const concurrencyN = concurrency === "unbounded"
           ? Number.MAX_SAFE_INTEGER
           : Math.max(1, concurrency)
-        const semaphore = switch_ ? undefined : Effect.makeSemaphoreUnsafe(concurrencyN)
-        const doneLatch = yield* Effect.makeLatch(true)
+        const semaphore = switch_ ? undefined : Semaphore.makeUnsafe(concurrencyN)
+        const doneLatch = yield* Latch.make(true)
         const fibers = new Set<Fiber.Fiber<any, any>>()
 
         const queue = yield* Queue.bounded</**
@@ -7170,7 +7598,7 @@ export const decodeText = <Err, Done>(encoding?: string, options?: TextDecoderOp
   Arr.NonEmptyReadonlyArray<string>,
   Err,
   Done,
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   Err,
   Done
 > =>
@@ -7186,7 +7614,7 @@ export const decodeText = <Err, Done>(encoding?: string, options?: TextDecoderOp
  * @category String manipulation
  */
 export const encodeText = <Err, Done>(): Channel<
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   Err,
   Done,
   Arr.NonEmptyReadonlyArray<string>,
@@ -7196,7 +7624,7 @@ export const encodeText = <Err, Done>(): Channel<
   fromTransform((upstream, _scope) =>
     Effect.sync(() => {
       const encoder = new TextEncoder()
-      return Effect.map(upstream, Arr.map((line) => encoder.encode(line) as Uint8Array<ArrayBuffer>))
+      return Effect.map(upstream, Arr.map((line) => encoder.encode(line)))
     })
   )
 
@@ -8208,7 +8636,7 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, service: NoInfer<S>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <I, S>(key: ServiceMap.Key<I, S>, service: NoInfer<S>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
   ) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>>
   /**
@@ -8217,12 +8645,12 @@ export const provideService: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     service: NoInfer<S>
   ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>>
 } = dual(3, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  key: ServiceMap.Service<I, S>,
+  key: ServiceMap.Key<I, S>,
   service: NoInfer<S>
 ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>> =>
   fromTransform((upstream, scope) =>
@@ -8241,7 +8669,7 @@ export const provideServiceEffect: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S, ES, RS>(key: ServiceMap.Service<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <I, S, ES, RS>(key: ServiceMap.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
   ) => Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS>
   /**
@@ -8250,12 +8678,12 @@ export const provideServiceEffect: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S, ES, RS>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     service: Effect.Effect<NoInfer<S>, ES, RS>
   ): Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS>
 } = dual(3, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S, ES, RS>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  key: ServiceMap.Service<I, S>,
+  key: ServiceMap.Key<I, S>,
   service: Effect.Effect<NoInfer<S>, ES, RS>
 ): Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS> =>
   fromTransform((upstream, scope) =>
@@ -8353,7 +8781,7 @@ export const updateService: {
    * @since 2.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, f: (service: NoInfer<S>) => S): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <I, S>(key: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I>
   /**
@@ -8362,12 +8790,12 @@ export const updateService: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    service: ServiceMap.Service<I, S>,
+    service: ServiceMap.Key<I, S>,
     f: (service: NoInfer<S>) => S
   ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I>
 } = dual(3, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
   self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  service: ServiceMap.Service<I, S>,
+  service: ServiceMap.Key<I, S>,
   f: (service: NoInfer<S>) => S
 ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I> =>
   updateServices(self, (services) =>
@@ -9085,7 +9513,7 @@ export const toPull: <OutElem, OutErr, OutDone, Env>(
   function*<OutElem, OutErr, OutDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>
   ) {
-    const semaphore = Effect.makeSemaphoreUnsafe(1)
+    const semaphore = Semaphore.makeUnsafe(1)
     const context = yield* Effect.services<Env | Scope.Scope>()
     const scope = ServiceMap.get(context, Scope.Scope)
     const pull = yield* toTransform(self)(Cause.done(), scope)