effect 2.0.0-next.55 → 2.0.0-next.57

package/src/internal/stm/tPubSub.ts

@@ -20,16 +20,19 @@ const TPubSubSymbolKey = "effect/TPubSub"
 /** @internal */
 export const TPubSubTypeId: TPubSub.TPubSubTypeId = Symbol.for(TPubSubSymbolKey) as TPubSub.TPubSubTypeId
 
+const AbsentValue = Symbol.for("effect/TPubSub/AbsentValue")
+type AbsentValue = typeof AbsentValue
+
 /** @internal */
-export interface Node<A> {
-  readonly head: A
+export interface Node<in out A> {
+  readonly head: A | AbsentValue
   readonly subscribers: number
   readonly tail: TRef.TRef<Node<A> | undefined>
 }
 
 /** @internal */
 export const makeNode = <A>(
-  head: A,
+  head: A | AbsentValue,
   subscribers: number,
   tail: TRef.TRef<Node<A> | undefined>
 ): Node<A> => ({
@@ -39,8 +42,10 @@ export const makeNode = <A>(
 })
 
 /** @internal */
-class TPubSubImpl<A> implements TPubSub.TPubSub<A> {
-  readonly [TPubSubTypeId]: TPubSub.TPubSubTypeId = TPubSubTypeId
+class TPubSubImpl<in out A> implements TPubSub.TPubSub<A> {
+  readonly [TPubSubTypeId] = {
+    _A: (_: any) => _
+  }
   readonly [tQueue.TEnqueueTypeId] = tQueue.tEnqueueVariance
   constructor(
     readonly pubsubSize: TRef.TRef<number>,
@@ -122,9 +127,9 @@ class TPubSubImpl<A> implements TPubSub.TPubSub<A> {
               }
               const head = node.head
               const tail = node.tail
-              if (head !== undefined) {
-                const updatedNode = makeNode(void 0, node.subscribers, node.tail as any)
-                tRef.unsafeSet<Node<A | undefined> | undefined>(
+              if (head !== AbsentValue) {
+                const updatedNode = makeNode<A>(AbsentValue, node.subscribers, node.tail as any)
+                tRef.unsafeSet<Node<A> | undefined>(
                   currentPublisherHead as any,
                   updatedNode as any,
                   runtime.journal
@@ -171,14 +176,14 @@ class TPubSubImpl<A> implements TPubSub.TPubSub<A> {
 }
 
 /** @internal */
-class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
+class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
   readonly [TPubSubTypeId]: TPubSub.TPubSubTypeId = TPubSubTypeId
   readonly [tQueue.TDequeueTypeId] = tQueue.tDequeueVariance
   constructor(
     readonly pubsubSize: TRef.TRef<number>,
     readonly publisherHead: TRef.TRef<TRef.TRef<Node<A> | undefined>>,
     readonly requestedCapacity: number,
-    readonly subscriberHead: TRef.TRef<TRef.TRef<Node<A | undefined> | undefined> | undefined>,
+    readonly subscriberHead: TRef.TRef<TRef.TRef<Node<A> | undefined> | undefined>,
     readonly subscriberCount: TRef.TRef<number>,
     readonly subscribers: TRef.TRef<HashSet.HashSet<TRef.TRef<TRef.TRef<Node<A>> | undefined>>>
   ) {}
@@ -209,8 +214,8 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         loop = false
       } else {
         const head = node.head
-        const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-        if (head !== undefined) {
+        const tail: TRef.TRef<Node<A> | undefined> = node.tail
+        if (head !== AbsentValue) {
           size = size + 1
           if (size >= Number.MAX_SAFE_INTEGER) {
             loop = false
@@ -231,7 +236,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
     if (currentSubscriberHead === undefined) {
       return core.interruptAs(runtime.fiberId)
     }
-    let value: A | undefined = undefined
+    let value: A | AbsentValue = AbsentValue
     let loop = true
     while (loop) {
       const node = tRef.unsafeGet(currentSubscriberHead, runtime.journal)
@@ -239,15 +244,15 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         return core.retry
       }
       const head = node.head
-      const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-      if (head !== undefined) {
+      const tail: TRef.TRef<Node<A> | undefined> = node.tail
+      if (head !== AbsentValue) {
         value = head
         loop = false
       } else {
         currentSubscriberHead = tail
       }
     }
-    return core.succeed(value!)
+    return core.succeed(value as A)
   })
 
   peekOption: STM.STM<never, never, Option.Option<A>> = core.withSTMRuntime((runtime) => {
@@ -264,8 +269,8 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         loop = false
       } else {
         const head = node.head
-        const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-        if (head !== undefined) {
+        const tail: TRef.TRef<Node<A> | undefined> = node.tail
+        if (head !== AbsentValue) {
           value = Option.some(head)
           loop = false
         } else {
@@ -279,7 +284,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
   shutdown: STM.STM<never, never, void> = core.effect<never, void>((journal) => {
     let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, journal)
     if (currentSubscriberHead !== undefined) {
-      tRef.unsafeSet<TRef.TRef<Node<A | undefined> | undefined> | undefined>(this.subscriberHead, void 0, journal)
+      tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(this.subscriberHead, void 0, journal)
       let loop = true
       while (loop) {
         const node = tRef.unsafeGet(currentSubscriberHead, journal)
@@ -287,18 +292,18 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
           loop = false
         } else {
           const head = node.head
-          const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-          if (head !== undefined) {
+          const tail: TRef.TRef<Node<A> | undefined> = node.tail
+          if (head !== AbsentValue) {
             const subscribers = node.subscribers
             if (subscribers === 1) {
               const size = tRef.unsafeGet(this.pubsubSize, journal)
-              const updatedNode = makeNode(undefined, 0, tail)
-              tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, journal)
+              const updatedNode = makeNode<A>(AbsentValue, 0, tail)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, journal)
               tRef.unsafeSet(this.publisherHead, tail as any, journal)
               tRef.unsafeSet(this.pubsubSize, size - 1, journal)
             } else {
               const updatedNode = makeNode(head, subscribers - 1, tail)
-              tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, journal)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, journal)
             }
           }
           currentSubscriberHead = tail
@@ -322,7 +327,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
     if (currentSubscriberHead === undefined) {
       return core.interruptAs(runtime.fiberId)
     }
-    let value: A | undefined = undefined
+    let value: A | AbsentValue = AbsentValue
     let loop = true
     while (loop) {
       const node = tRef.unsafeGet(currentSubscriberHead, runtime.journal)
@@ -330,20 +335,20 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         return core.retry
       }
       const head = node.head
-      const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-      if (head !== undefined) {
+      const tail: TRef.TRef<Node<A> | undefined> = node.tail
+      if (head !== AbsentValue) {
         const subscribers = node.subscribers
         if (subscribers === 1) {
           const size = tRef.unsafeGet(this.pubsubSize, runtime.journal)
-          const updatedNode = makeNode(void 0, 0, tail)
-          tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+          const updatedNode = makeNode<A>(AbsentValue, 0, tail)
+          tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
           tRef.unsafeSet(this.publisherHead, tail as any, runtime.journal)
           tRef.unsafeSet(this.pubsubSize, size - 1, runtime.journal)
         } else {
           const updatedNode = makeNode(head, subscribers - 1, tail)
-          tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+          tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
         }
-        tRef.unsafeSet<TRef.TRef<Node<A | undefined> | undefined> | undefined>(
+        tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(
           this.subscriberHead,
           tail,
           runtime.journal
@@ -354,7 +359,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         currentSubscriberHead = tail
       }
     }
-    return core.succeed(value!)
+    return core.succeed(value as A)
   })
 
   takeAll: STM.STM<never, never, Array<A>> = this.takeUpTo(Number.POSITIVE_INFINITY)
@@ -373,18 +378,18 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
           n = max
         } else {
           const head = node.head
-          const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-          if (head !== undefined) {
+          const tail: TRef.TRef<Node<A> | undefined> = node.tail
+          if (head !== AbsentValue) {
             const subscribers = node.subscribers
             if (subscribers === 1) {
               const size = tRef.unsafeGet(this.pubsubSize, runtime.journal)
-              const updatedNode = makeNode(void 0, 0, tail)
-              tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+              const updatedNode = makeNode<A>(AbsentValue, 0, tail)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
               tRef.unsafeSet(this.publisherHead, tail as any, runtime.journal)
               tRef.unsafeSet(this.pubsubSize, size - 1, runtime.journal)
             } else {
               const updatedNode = makeNode(head, subscribers - 1, tail)
-              tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
             }
             builder.push(head)
             n = n + 1
@@ -392,7 +397,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
           currentSubscriberHead = tail
         }
       }
-      tRef.unsafeSet<TRef.TRef<Node<A | undefined> | undefined> | undefined>(
+      tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(
         this.subscriberHead,
         currentSubscriberHead,
         runtime.journal

package/src/internal/stm/tQueue.ts

@@ -73,15 +73,17 @@ export const Sliding: TQueueStrategy = {
 
 /** @internal */
 export const tDequeueVariance = {
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 
 /** @internal */
 export const tEnqueueVariance = {
+  /* c8 ignore next */
   _In: (_: unknown) => _
 }
 
-class TQueueImpl<A> implements TQueue.TQueue<A> {
+class TQueueImpl<in out A> implements TQueue.TQueue<A> {
   readonly [TDequeueTypeId] = tDequeueVariance
   readonly [TEnqueueTypeId] = tEnqueueVariance
   constructor(
@@ -140,10 +142,10 @@ class TQueueImpl<A> implements TQueue.TQueue<A> {
           return core.succeed(false)
         }
         case OpCodes.OP_SLIDING_STRATEGY: {
-          const dequeued = queue.shift()
-          if (dequeued === undefined) {
+          if (queue.length === 0) {
             return core.succeed(true)
           }
+          queue.shift()
           queue.push(value)
           tRef.unsafeSet(this.ref, queue, runtime.journal)
           return core.succeed(true)
@@ -188,11 +190,10 @@ class TQueueImpl<A> implements TQueue.TQueue<A> {
     if (queue === undefined) {
       return core.interruptAs(runtime.fiberId)
     }
-    const head = queue[0]
-    if (head === undefined) {
+    if (queue.length === 0) {
       return core.retry
     }
-    return core.succeed(head)
+    return core.succeed(queue[0])
   })
 
   peekOption: STM.STM<never, never, Option.Option<A>> = core.withSTMRuntime((runtime) => {
@@ -208,10 +209,10 @@ class TQueueImpl<A> implements TQueue.TQueue<A> {
     if (queue === undefined) {
       return core.interruptAs(runtime.fiberId)
     }
-    const dequeued = queue.shift()
-    if (dequeued === undefined) {
+    if (queue.length === 0) {
       return core.retry
     }
+    const dequeued = queue.shift()!
     tRef.unsafeSet(this.ref, queue, runtime.journal)
     return core.succeed(dequeued)
   })

package/src/internal/stm/tReentrantLock.ts

@@ -44,11 +44,11 @@ export interface LockState {
   /**
    * Computes the number of read locks held by the specified fiber id.
    */
-  readonly readLocksHeld: (fiberId: FiberId.FiberId) => number
+  readLocksHeld(fiberId: FiberId.FiberId): number
   /**
    * Computes the number of write locks held by the specified fiber id.
    */
-  readonly writeLocksHeld: (fiberId: FiberId.FiberId) => number
+  writeLocksHeld(fiberId: FiberId.FiberId): number
 }
 
 /**

package/src/internal/stm/tRef.ts

@@ -16,13 +16,13 @@ export const TRefTypeId: TRef.TRefTypeId = Symbol.for(
   TRefSymbolKey
 ) as TRef.TRefTypeId
 
-/** @internal */
 const tRefVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 
 /** @internal */
-export class TRefImpl<A> implements TRef.TRef<A> {
+export class TRefImpl<in out A> implements TRef.TRef<A> {
   readonly [TRefTypeId] = tRefVariance
   /** @internal */
   todos: Map<TxnId.TxnId, Journal.Todo>

package/src/internal/stm/tSemaphore.ts

@@ -36,7 +36,7 @@ export const acquireN = dual<
 >(2, (self, n) =>
   core.withSTMRuntime((driver) => {
     if (n < 0) {
-      throw Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.acquireN`)
+      throw new Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.acquireN`)
     }
     const value = tRef.unsafeGet(self.permits, driver.journal)
     if (value < n) {
@@ -59,7 +59,7 @@ export const releaseN = dual<
 >(2, (self, n) =>
   core.withSTMRuntime((driver) => {
     if (n < 0) {
-      throw Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.releaseN`)
+      throw new Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.releaseN`)
     }
     const current = tRef.unsafeGet(self.permits, driver.journal)
     return STM.succeed(tRef.unsafeSet(self.permits, current + n, driver.journal))

package/src/internal/stm/tSet.ts

@@ -18,13 +18,13 @@ export const TSetTypeId: TSet.TSetTypeId = Symbol.for(
   TSetSymbolKey
 ) as TSet.TSetTypeId
 
-/** @internal */
 const tSetVariance = {
-  _A: (_: never) => _
+  /* c8 ignore next */
+  _A: (_: any) => _
 }
 
 /** @internal */
-class TSetImpl<A> implements TSet.TSet<A> {
+class TSetImpl<in out A> implements TSet.TSet<A> {
   readonly [TSetTypeId] = tSetVariance
   constructor(readonly tMap: TMap.TMap<A, void>) {}
 }

package/src/internal/stream/debounceState.ts

@@ -28,13 +28,13 @@ export interface NotStarted {
 }
 
 /** @internal */
-export interface Previous<A> {
+export interface Previous<out A> {
   readonly _tag: OP_PREVIOUS
   readonly fiber: Fiber.Fiber<never, Chunk.Chunk<A>>
 }
 
 /** @internal */
-export interface Current<E, A> {
+export interface Current<out E, out A> {
   readonly _tag: OP_CURRENT
   readonly fiber: Fiber.Fiber<E, HandoffSignal.HandoffSignal<E, A>>
 }

package/src/internal/stream/handoff.ts

@@ -17,7 +17,7 @@ export type HandoffTypeId = typeof HandoffTypeId
  *
  * @internal
  */
-export interface Handoff<A> extends Handoff.Variance<A> {
+export interface Handoff<in out A> extends Handoff.Variance<A> {
   readonly ref: Ref.Ref<Handoff.State<A>>
 }
 
@@ -36,7 +36,7 @@ export type OP_HANDOFF_STATE_FULL = typeof OP_HANDOFF_STATE_FULL
 /** @internal */
 export declare namespace Handoff {
   /** @internal */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [HandoffTypeId]: {
       readonly _A: (_: A) => A
     }
@@ -52,7 +52,7 @@ export declare namespace Handoff {
   }
 
   /** @internal */
-  export interface Full<A> {
+  export interface Full<out A> {
     readonly _tag: OP_HANDOFF_STATE_FULL
     readonly value: A
     readonly notifyProducer: Deferred.Deferred<never, void>
@@ -89,8 +89,8 @@ const handoffStateMatch = <A, Z>(
   }
 }
 
-/** @internal */
 const handoffVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 

package/src/internal/stream/handoffSignal.ts

@@ -23,13 +23,13 @@ export const OP_END = "End" as const
 /** @internal */
 export type OP_END = typeof OP_END
 
-export interface Emit<A> {
+export interface Emit<out A> {
   readonly _tag: OP_EMIT
   readonly elements: Chunk.Chunk<A>
 }
 
 /** @internal */
-export interface Halt<E> {
+export interface Halt<out E> {
   readonly _tag: OP_HALT
   readonly cause: Cause.Cause<E>
 }

package/src/internal/stream/pull.ts

@@ -7,7 +7,7 @@ import type * as Take from "../../Take.js"
 import * as take from "../take.js"
 
 /** @internal */
-export interface Pull<R, E, A> extends Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>> {}
+export interface Pull<out R, out E, out A> extends Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>> {}
 
 /** @internal */
 export const emit = <A>(value: A): Effect.Effect<never, never, Chunk.Chunk<A>> => Effect.succeed(Chunk.of(value))

package/src/internal/stream.ts

@@ -65,7 +65,7 @@ const streamVariance = {
 }
 
 /** @internal */
-export class StreamImpl<R, E, A> implements Stream.Stream<R, E, A> {
+export class StreamImpl<out R, out E, out A> implements Stream.Stream<R, E, A> {
   readonly [StreamTypeId] = streamVariance
   constructor(
     readonly channel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>
@@ -604,7 +604,7 @@ export const asyncOption = <R, E, A>(
 
 /** @internal */
 export const asyncScoped = <R, E, A>(
-  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R, E, unknown>,
+  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R | Scope.Scope, E, unknown>,
   outputBuffer = 16
 ): Stream.Stream<Exclude<R, Scope.Scope>, E, A> =>
   pipe(
@@ -2352,16 +2352,15 @@ export const failCauseSync = <E>(evaluate: LazyArg<Cause.Cause<E>>): Stream.Stre
   fromEffect(Effect.failCauseSync(evaluate))
 
 /** @internal */
-export const filter = dual<
-  {
-    <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, B>
-    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>
-  },
-  {
-    <R, E, A, B extends A>(self: Stream.Stream<R, E, A>, refinement: Refinement<A, B>): Stream.Stream<R, E, B>
-    <R, E, A, X extends A>(self: Stream.Stream<R, E, A>, predicate: Predicate<X>): Stream.Stream<R, E, A>
-  }
->(2, <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>) => mapChunks(self, Chunk.filter(predicate)))
+export const filter: {
+  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, B>
+  <A, B extends A>(predicate: Predicate<B>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>
+  <R, E, A, B extends A>(self: Stream.Stream<R, E, A>, refinement: Refinement<A, B>): Stream.Stream<R, E, B>
+  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>): Stream.Stream<R, E, A>
+} = dual(
+  2,
+  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>) => mapChunks(self, Chunk.filter(predicate))
+)
 
 /** @internal */
 export const filterEffect = dual<
@@ -3176,7 +3175,7 @@ export const groupAdjacentBy = dual<
             if (!Equal.equals(key, updatedKey)) {
               const previousChunk = tuple[1]
               const additionalChunk = Chunk.unsafeFromArray(Array.from(chunk).slice(from, until))
-              const group = Chunk.appendAllNonEmpty(previousChunk, additionalChunk)
+              const group = Chunk.appendAll(previousChunk, additionalChunk)
               builder.push([key, group])
               key = updatedKey
               from = until
@@ -3698,17 +3697,26 @@ export const mapAccumEffect = dual<
 /** @internal */
 export const mapBoth = dual<
   <E, E2, A, A2>(
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ) => <R>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E2, A2>,
   <R, E, E2, A, A2>(
     self: Stream.Stream<R, E, A>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ) => Stream.Stream<R, E2, A2>
 >(
   2,
   <R, E, E2, A, A2>(
     self: Stream.Stream<R, E, A>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ): Stream.Stream<R, E2, A2> => pipe(self, mapError(options.onFailure), map(options.onSuccess))
 )
 
@@ -4370,23 +4378,46 @@ export const peel = dual<
 })
 
 /** @internal */
-export const partition = dual<
+export const partition: {
+  <C extends A, B extends A, A = C>(
+    refinement: Refinement<A, B>,
+    options?: {
+      bufferSize?: number | undefined
+    }
+  ): <R, E>(
+    self: Stream.Stream<R, E, C>
+  ) => Effect.Effect<
+    Scope.Scope | R,
+    E,
+    [excluded: Stream.Stream<never, E, Exclude<C, B>>, satisfying: Stream.Stream<never, E, B>]
+  >
   <A>(
     predicate: Predicate<A>,
     options?: {
       bufferSize?: number | undefined
     }
-  ) => <R, E>(
+  ): <R, E>(
     self: Stream.Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R, E, [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]>,
+  ) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream.Stream<never, E, A>, satisfying: Stream.Stream<never, E, A>]>
+  <R, E, C extends A, B extends A, A = C>(
+    self: Stream.Stream<R, E, C>,
+    refinement: Refinement<A, B>,
+    options?: {
+      bufferSize?: number | undefined
+    }
+  ): Effect.Effect<
+    Scope.Scope | R,
+    E,
+    [excluded: Stream.Stream<never, E, Exclude<C, B>>, satisfying: Stream.Stream<never, E, B>]
+  >
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
     predicate: Predicate<A>,
     options?: {
       bufferSize?: number | undefined
     }
-  ) => Effect.Effect<Scope.Scope | R, E, [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]>
->(
+  ): Effect.Effect<Scope.Scope | R, E, [excluded: Stream.Stream<never, E, A>, satisfying: Stream.Stream<never, E, A>]>
+} = dual(
   (args) => typeof args[1] === "function",
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
@@ -4418,7 +4449,7 @@ export const partitionEither = dual<
   ) => Effect.Effect<
     Scope.Scope | R2 | R,
     E2 | E,
-    [Stream.Stream<never, E2 | E, A2>, Stream.Stream<never, E2 | E, A3>]
+    [left: Stream.Stream<never, E2 | E, A2>, right: Stream.Stream<never, E2 | E, A3>]
   >,
   <R, E, A, R2, E2, A2, A3>(
     self: Stream.Stream<R, E, A>,
@@ -4429,7 +4460,7 @@ export const partitionEither = dual<
   ) => Effect.Effect<
     Scope.Scope | R2 | R,
     E2 | E,
-    [Stream.Stream<never, E2 | E, A2>, Stream.Stream<never, E2 | E, A3>]
+    [left: Stream.Stream<never, E2 | E, A2>, right: Stream.Stream<never, E2 | E, A3>]
   >
 >(
   (args) => typeof args[1] === "function",
@@ -4752,7 +4783,7 @@ const rechunkProcess = <E, A>(
   })
 
 /** @internal */
-class StreamRechunker<E, A> {
+class StreamRechunker<in out E, out A> {
   private builder: Array<A> = []
   private pos = 0
 
@@ -5716,7 +5747,7 @@ export const slidingSize = dual<
   <R, E, A>(self: Stream.Stream<R, E, A>, chunkSize: number, stepSize: number): Stream.Stream<R, E, Chunk.Chunk<A>> => {
     if (chunkSize <= 0 || stepSize <= 0) {
       return die(
-        Cause.IllegalArgumentException("Invalid bounds - `chunkSize` and `stepSize` must be greater than zero")
+        new Cause.IllegalArgumentException("Invalid bounds - `chunkSize` and `stepSize` must be greater than zero")
       )
     }
     return new StreamImpl(core.suspend(() => {
@@ -5965,7 +5996,7 @@ export const take = dual<
   <R, E, A>(self: Stream.Stream<R, E, A>, n: number) => Stream.Stream<R, E, A>
 >(2, <R, E, A>(self: Stream.Stream<R, E, A>, n: number): Stream.Stream<R, E, A> => {
   if (!Number.isInteger(n)) {
-    return die(Cause.IllegalArgumentException(`${n} must be an integer`))
+    return die(new Cause.IllegalArgumentException(`${n} must be an integer`))
   }
   const loop = (n: number): Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<A>, unknown> =>
     core.readWith({
@@ -6082,10 +6113,12 @@ export const takeUntilEffect = dual<
 )
 
 /** @internal */
-export const takeWhile = dual<
-  <A, X extends A>(predicate: Predicate<X>) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
-  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>) => Stream.Stream<R, E, A>
->(2, <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>): Stream.Stream<R, E, A> => {
+export const takeWhile: {
+  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, B>
+  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream.Stream<R, E, B>) => Stream.Stream<R, E, B>
+  <R, E, A, B extends A>(self: Stream.Stream<R, E, A>, refinement: Refinement<A, B>): Stream.Stream<R, E, B>
+  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>): Stream.Stream<R, E, A>
+} = dual(2, <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>): Stream.Stream<R, E, A> => {
   const loop: Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<A>, unknown> = core.readWith({
     onInput: (input: Chunk.Chunk<A>) => {
       const taken = pipe(input, Chunk.takeWhile(predicate))
@@ -6508,7 +6541,7 @@ export const timeoutTo = dual<
     duration: Duration.DurationInput,
     that: Stream.Stream<R2, E2, A2>
   ): Stream.Stream<R | R2, E | E2, A | A2> => {
-    const StreamTimeout = Cause.RuntimeException("Stream Timeout")
+    const StreamTimeout = new Cause.RuntimeException("Stream Timeout")
     return pipe(
       self,
       timeoutFailCause<E | E2>(() => Cause.die(StreamTimeout), duration),
@@ -6835,12 +6868,12 @@ export const updateService = dual<
 
 /** @internal */
 export const when = dual<
-  (predicate: LazyArg<boolean>) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
-  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: LazyArg<boolean>) => Stream.Stream<R, E, A>
+  (test: LazyArg<boolean>) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
+  <R, E, A>(self: Stream.Stream<R, E, A>, test: LazyArg<boolean>) => Stream.Stream<R, E, A>
 >(
   2,
-  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: LazyArg<boolean>): Stream.Stream<R, E, A> =>
-    pipe(self, whenEffect(Effect.sync(predicate)))
+  <R, E, A>(self: Stream.Stream<R, E, A>, test: LazyArg<boolean>): Stream.Stream<R, E, A> =>
+    pipe(self, whenEffect(Effect.sync(test)))
 )
 
 /** @internal */