effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/Channel.ts

@@ -60,10 +60,11 @@
 import * as Arr from "./Array.ts"
 import * as Cause from "./Cause.ts"
 import * as Chunk from "./Chunk.ts"
+import * as Context from "./Context.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"
@@ -71,7 +72,7 @@ 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"
@@ -85,14 +86,23 @@ 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"
 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`.
@@ -190,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> = {
@@ -2082,7 +2092,7 @@ const mapEffectConcurrent = <
       const queue = yield* Queue.bounded<OutElem2, OutErr | EX | Cause.Done<OutDone>>(0)
       yield* Scope.addFinalizer(forkedScope, Queue.shutdown(queue))
 
-      const runFork = Effect.runForkWith(yield* Effect.services<RX>())
+      const runFork = Effect.runForkWith(yield* Effect.context<RX>())
       const trackFiber = Fiber.runIn(forkedScope)
 
       if (options.unordered) {
@@ -3564,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.
@@ -3625,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>,
-    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>(
+    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>,
-  filter: Filter.OrPredicate<OutElem, Result>
-): Channel<Filter.Pass<OutElem, Result>, 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<Filter.Pass<OutElem, Result>, OutErr, OutDone> {
+        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.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.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<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)
         })
     )
   ))
@@ -3652,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
@@ -3796,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.
@@ -3873,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)
@@ -3896,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
@@ -3921,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
@@ -3929,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.
@@ -4449,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
+          }
+        )
+      })
     })
   ))
 
@@ -4757,7 +4900,6 @@ export const catchCauseIf: {
    */
   <
     OutErr,
-    Result extends Filter.ResultOrBool<Cause.Cause<any>>,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -4766,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,
@@ -4780,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,
@@ -4802,7 +4941,6 @@ export const catchCauseIf: {
     InErr,
     InDone,
     Env,
-    Result extends Filter.ResultOrBool<Cause.Cause<any>>,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -4812,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: 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: 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,
@@ -4834,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,
@@ -4844,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,
@@ -4864,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)
     }
   ))
 
@@ -4951,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 {
   /**
@@ -5101,7 +5362,6 @@ export const catchIf: {
    */
   <
     OutErr,
-    Result extends Filter.ResultOrBool,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -5110,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
   ): <
@@ -5197,7 +5457,6 @@ export const catchIf: {
     InErr,
     InDone,
     Env,
-    Result extends Filter.ResultOrBool,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -5206,7 +5465,7 @@ export const catchIf: {
     InDone1,
     Env1,
     OutElem2 = never,
-    OutErr2 = Filter.Fail<OutErr, Result>,
+    OutErr2 = OutErr,
     OutDone2 = never,
     InElem2 = unknown,
     InErr2 = unknown,
@@ -5214,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<
@@ -5238,7 +5497,6 @@ export const catchIf: {
   InErr,
   InDone,
   Env,
-  Result extends Filter.ResultOrBool,
   OutElem1,
   OutErr1,
   OutDone1,
@@ -5247,7 +5505,7 @@ export const catchIf: {
   InDone1,
   Env1,
   OutElem2 = never,
-  OutErr2 = Filter.Fail<OutErr, Result>,
+  OutErr2 = OutErr,
   OutDone2 = never,
   InElem2 = unknown,
   InErr2 = unknown,
@@ -5255,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<
@@ -5282,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)
     }
   ))
 
@@ -5528,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
   ): <
@@ -5615,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<
@@ -5660,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<
@@ -5690,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
     }
@@ -5716,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,
@@ -5731,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>(
@@ -5797,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,
@@ -5813,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<
@@ -5862,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") &&
@@ -5872,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
   })
@@ -6024,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)
 
 /**
@@ -6114,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>]
@@ -6133,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) {
@@ -6169,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>]
@@ -6187,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)
@@ -7077,6 +7503,29 @@ export const mergeEffect: {
   ) as any)
 
 /**
+ * Splits upstream string chunks into lines, recognizing `\n`, `\r\n`, and
+ * standalone `\r` as line terminators. The behavior matches
+ * `String.linesIterator` regardless of how the input is chunked.
+ *
+ * A line terminator at the very end of the stream does **not** produce a
+ * trailing empty line (consistent with `String.linesIterator`). Conversely,
+ * if the stream ends without a terminator the final partial line is still
+ * emitted.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Stream } from "effect"
+ *
+ * Effect.runPromise(Effect.gen(function*() {
+ *   const result = yield* Stream.runCollect(
+ *     Stream.splitLines(Stream.make("hel", "lo\r\nwor", "ld\n"))
+ *   )
+ *   console.log(result)
+ *   // [ 'hello', 'world' ]
+ * }))
+ * ```
+ *
  * @since 2.0.0
  * @category String manipulation
  */
@@ -7090,11 +7539,30 @@ export const splitLines = <Err, Done>(): Channel<
 > =>
   fromTransform((upstream, _scope) =>
     Effect.sync(() => {
+      // Accumulates text that has not yet been terminated by a line break.
+      // Content is carried across chunks until a terminator is found.
       let stringBuilder = ""
+      // Set when a chunk ends with \r so the next chunk can check whether
+      // the following character is \n (completing a \r\n pair) or not
+      // (standalone \r, which is itself a line terminator).
       let midCRLF = false
+      // Remembers the upstream Done value after the first time the upstream
+      // signals completion, so subsequent pulls return Done immediately
+      // without pulling upstream again.
+      let done = Option.none<Done>()
 
-      const splitLinesArray = (chunk: Arr.NonEmptyReadonlyArray<string>): Arr.NonEmptyReadonlyArray<string> | null => {
+      function splitLinesArray(chunk: Arr.NonEmptyReadonlyArray<string>): Arr.NonEmptyReadonlyArray<string> | null {
         const chunkBuilder: Array<string> = []
+
+        function pushLine(segment: string): void {
+          if (stringBuilder.length === 0) {
+            chunkBuilder.push(segment)
+          } else {
+            chunkBuilder.push(stringBuilder + segment)
+            stringBuilder = ""
+          }
+        }
+
         for (let i = 0; i < chunk.length; i++) {
           const str = chunk[i]
           if (str.length !== 0) {
@@ -7103,23 +7571,17 @@ export const splitLines = <Err, Done>(): Channel<
             let indexOfLF = str.indexOf("\n")
             if (midCRLF) {
               if (indexOfLF === 0) {
-                chunkBuilder.push(stringBuilder)
-                stringBuilder = ""
+                pushLine("")
                 from = 1
                 indexOfLF = str.indexOf("\n", from)
               } else {
-                stringBuilder = stringBuilder + "\r"
+                pushLine("")
               }
               midCRLF = false
             }
             while (indexOfCR !== -1 || indexOfLF !== -1) {
               if (indexOfCR === -1 || (indexOfLF !== -1 && indexOfLF < indexOfCR)) {
-                if (stringBuilder.length === 0) {
-                  chunkBuilder.push(str.substring(from, indexOfLF))
-                } else {
-                  chunkBuilder.push(stringBuilder + str.substring(from, indexOfLF))
-                  stringBuilder = ""
-                }
+                pushLine(str.substring(from, indexOfLF))
                 from = indexOfLF + 1
                 indexOfLF = str.indexOf("\n", from)
               } else {
@@ -7127,40 +7589,45 @@ export const splitLines = <Err, Done>(): Channel<
                   midCRLF = true
                   indexOfCR = -1
                 } else {
-                  if (indexOfLF === indexOfCR + 1) {
-                    if (stringBuilder.length === 0) {
-                      chunkBuilder.push(str.substring(from, indexOfCR))
-                    } else {
-                      stringBuilder = stringBuilder + str.substring(from, indexOfCR)
-                      chunkBuilder.push(stringBuilder)
-                      stringBuilder = ""
-                    }
-                    from = indexOfCR + 2
-                    indexOfCR = str.indexOf("\r", from)
-                    indexOfLF = str.indexOf("\n", from)
-                  } else {
-                    indexOfCR = str.indexOf("\r", indexOfCR + 1)
-                  }
+                  pushLine(str.substring(from, indexOfCR))
+                  from = indexOfCR + (indexOfLF === indexOfCR + 1 ? 2 : 1)
+                  indexOfCR = str.indexOf("\r", from)
+                  indexOfLF = str.indexOf("\n", from)
                 }
               }
             }
-            if (midCRLF) {
-              stringBuilder = stringBuilder + str.substring(from, str.length - 1)
-            } else {
-              stringBuilder = stringBuilder + str.substring(from, str.length)
-            }
+            stringBuilder = stringBuilder + str.substring(from, str.length - (midCRLF ? 1 : 0))
           }
         }
         return Arr.isReadonlyArrayNonEmpty(chunkBuilder) ? chunkBuilder : null
       }
 
-      return Effect.flatMap(
-        upstream,
-        function loop(chunk): Pull.Pull<Arr.NonEmptyReadonlyArray<string>, Err, Done> {
-          const lines = splitLinesArray(chunk)
-          return lines !== null ? Effect.succeed(lines) : Effect.flatMap(upstream, loop)
+      const pullOrFlush: Pull.Pull<Arr.NonEmptyReadonlyArray<string>, Err, Done> = Effect.suspend(() => {
+        if (done._tag === "Some") {
+          return Cause.done(done.value)
         }
-      )
+        return Pull.matchEffect(upstream, {
+          onSuccess: loop,
+          onFailure: Effect.failCause,
+          onDone: (leftover) => {
+            done = Option.some(leftover)
+            if (stringBuilder.length > 0 || midCRLF) {
+              const last = stringBuilder
+              stringBuilder = ""
+              midCRLF = false
+              return Effect.succeed([last] as Arr.NonEmptyReadonlyArray<string>)
+            }
+            return Cause.done(leftover)
+          }
+        })
+      })
+
+      function loop(chunk: Arr.NonEmptyReadonlyArray<string>): Pull.Pull<Arr.NonEmptyReadonlyArray<string>, Err, Done> {
+        const lines = splitLinesArray(chunk)
+        return lines !== null ? Effect.succeed(lines) : pullOrFlush
+      }
+
+      return pullOrFlush
     })
   )
 
@@ -7172,7 +7639,7 @@ export const decodeText = <Err, Done>(encoding?: string, options?: TextDecoderOp
   Arr.NonEmptyReadonlyArray<string>,
   Err,
   Done,
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   Err,
   Done
 > =>
@@ -7188,7 +7655,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>,
@@ -7198,7 +7665,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)))
     })
   )
 
@@ -8151,35 +8618,35 @@ const runWith = <
  * @since 2.0.0
  * @category Services
  */
-export const servicesWith = <Env, OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>(
-  f: (services: ServiceMap.ServiceMap<Env>) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>
+export const contextWith = <Env, OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>(
+  f: (context: Context.Context<Env>) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>
 ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env | Env2> =>
   fromTransform((upstream, scope) =>
-    Effect.servicesWith((services: ServiceMap.ServiceMap<Env>) => toTransform(f(services))(upstream, scope))
+    Effect.contextWith((context: Context.Context<Env>) => toTransform(f(context))(upstream, scope))
   )
 
 /**
- * Provides a layer or service map to the channel, removing the corresponding
+ * Provides a layer or context to the channel, removing the corresponding
  * service requirements. Use `options.local` to build the layer every time; by
  * default, layers are shared between provide calls.
  *
  * @since 4.0.0
  * @category Services
  */
-export const provideServices: {
+export const provideContext: {
   /**
-   * Provides a layer or service map to the channel, removing the corresponding
+   * Provides a layer or context to the channel, removing the corresponding
    * service requirements. Use `options.local` to build the layer every time; by
    * default, layers are shared between provide calls.
    *
    * @since 4.0.0
    * @category Services
    */
-  <R2>(services: ServiceMap.ServiceMap<R2>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <R2>(context: Context.Context<R2>): <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, R2>>
   /**
-   * Provides a layer or service map to the channel, removing the corresponding
+   * Provides a layer or context to the channel, removing the corresponding
    * service requirements. Use `options.local` to build the layer every time; by
    * default, layers are shared between provide calls.
    *
@@ -8188,16 +8655,16 @@ export const provideServices: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    services: ServiceMap.ServiceMap<R2>
+    context: Context.Context<R2>
   ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, R2>>
 } = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  services: ServiceMap.ServiceMap<R2>
+  context: Context.Context<R2>
 ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, R2>> =>
   fromTransform((upstream, scope) =>
     Effect.map(
-      Effect.provideServices(toTransform(self)(upstream, scope), services),
-      Effect.provideServices(services)
+      Effect.provideContext(toTransform(self)(upstream, scope), context),
+      Effect.provideContext(context)
     )
   ))
 
@@ -8210,7 +8677,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: Context.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>>
   /**
@@ -8219,12 +8686,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: Context.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: Context.Key<I, S>,
   service: NoInfer<S>
 ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>> =>
   fromTransform((upstream, scope) =>
@@ -8243,7 +8710,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: Context.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>
   /**
@@ -8252,12 +8719,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: Context.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: Context.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) =>
@@ -8277,7 +8744,7 @@ export const provide: {
    * @category Services
    */
   <A, E = never, R = never>(
-    layer: Layer.Layer<A, E, R> | ServiceMap.ServiceMap<A>,
+    layer: Layer.Layer<A, E, R> | Context.Context<A>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
@@ -8290,27 +8757,27 @@ export const provide: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, A, E = never, R = never>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    layer: Layer.Layer<A, E, R> | ServiceMap.ServiceMap<A>,
+    layer: Layer.Layer<A, E, R> | Context.Context<A>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
   ): Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Exclude<Env, A> | R>
 } = dual((args) => isChannel(args[0]), <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, A, E = never, R = never>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  layer: Layer.Layer<A, E, R> | ServiceMap.ServiceMap<A>,
+  layer: Layer.Layer<A, E, R> | Context.Context<A>,
   options?: {
     readonly local?: boolean | undefined
   } | undefined
 ): Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Exclude<Env, A> | R> =>
-  ServiceMap.isServiceMap(layer) ? provideServices(self, layer) : fromTransform((upstream, scope) =>
+  Context.isContext(layer) ? provideContext(self, layer) : fromTransform((upstream, scope) =>
     Effect.flatMap(
       options?.local
         ? Layer.buildWithMemoMap(layer, Layer.makeMemoMapUnsafe(), scope)
         : Layer.buildWithScope(layer, scope),
-      (services) =>
+      (context) =>
         Effect.map(
-          Effect.provideServices(toTransform(self)(upstream, scope), services),
-          Effect.provideServices(services)
+          Effect.provideContext(toTransform(self)(upstream, scope), context),
+          Effect.provideContext(context)
         )
     )
   ))
@@ -8319,12 +8786,12 @@ export const provide: {
  * @since 2.0.0
  * @category Services
  */
-export const updateServices: {
+export const updateContext: {
   /**
    * @since 2.0.0
    * @category Services
    */
-  <Env, R2>(f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<Env>): <OutElem, OutErr, OutDone, InElem, InErr, InDone>(
+  <Env, R2>(f: (context: Context.Context<R2>) => Context.Context<Env>): <OutElem, OutErr, OutDone, InElem, InErr, InDone>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2>
   /**
@@ -8333,16 +8800,16 @@ export const updateServices: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<Env>
+    f: (context: Context.Context<R2>) => Context.Context<Env>
   ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2>
 } = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
   self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<Env>
+  f: (context: Context.Context<R2>) => Context.Context<Env>
 ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2> =>
   fromTransform((upstream, scope) =>
-    Effect.servicesWith((services) => {
-      const toProvide = f(services)
-      return toTransform(provideServices(self, toProvide))(upstream, scope)
+    Effect.contextWith((context) => {
+      const toProvide = f(context)
+      return toTransform(provideContext(self, toProvide))(upstream, scope)
     })
   ))
 
@@ -8355,7 +8822,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: Context.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>
   /**
@@ -8364,19 +8831,19 @@ 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: Context.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: Context.Key<I, S>,
   f: (service: NoInfer<S>) => S
 ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I> =>
-  updateServices(self, (services) =>
-    ServiceMap.add(
-      services,
+  updateContext(self, (context) =>
+    Context.add(
+      context,
       service,
-      f(ServiceMap.get(services, service))
+      f(Context.get(context, service))
     )))
 
 /**
@@ -9088,11 +9555,11 @@ export const toPull: <OutElem, OutErr, OutDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>
   ) {
     const semaphore = Semaphore.makeUnsafe(1)
-    const context = yield* Effect.services<Env | Scope.Scope>()
-    const scope = ServiceMap.get(context, Scope.Scope)
+    const context = yield* Effect.context<Env | Scope.Scope>()
+    const scope = Context.get(context, Scope.Scope)
     const pull = yield* toTransform(self)(Cause.done(), scope)
     return pull.pipe(
-      Effect.provideServices(context),
+      Effect.provideContext(context),
       semaphore.withPermits(1)
     )
   },