effect 2.0.0-next.53 → 2.0.0-next.55

package/src/internal/stream.ts

@@ -1,52 +1,53 @@
-import * as Cause from "../Cause"
-import type * as Channel from "../Channel"
-import * as MergeDecision from "../ChannelMergeDecision"
-import * as Chunk from "../Chunk"
-import * as Clock from "../Clock"
-import * as Context from "../Context"
-import * as Deferred from "../Deferred"
-import * as Duration from "../Duration"
-import * as Effect from "../Effect"
-import * as Either from "../Either"
-import * as Equal from "../Equal"
-import * as Exit from "../Exit"
-import * as Fiber from "../Fiber"
-import { constTrue, dual, identity, pipe } from "../Function"
-import type { LazyArg } from "../Function"
-import * as Layer from "../Layer"
-import * as Option from "../Option"
-import type * as Order from "../Order"
-import { pipeArguments } from "../Pipeable"
-import { hasProperty, isTagged, type Predicate, type Refinement } from "../Predicate"
-import * as PubSub from "../PubSub"
-import * as Queue from "../Queue"
-import * as Ref from "../Ref"
-import * as Runtime from "../Runtime"
-import * as Schedule from "../Schedule"
-import * as Scope from "../Scope"
-import type * as Sink from "../Sink"
-import type * as Stream from "../Stream"
-import type * as Emit from "../StreamEmit"
-import * as HaltStrategy from "../StreamHaltStrategy"
-import type * as Take from "../Take"
-import type * as Tracer from "../Tracer"
-import * as channel from "./channel"
-import * as channelExecutor from "./channel/channelExecutor"
-import * as MergeStrategy from "./channel/mergeStrategy"
-import * as singleProducerAsyncInput from "./channel/singleProducerAsyncInput"
-import * as core from "./core-stream"
-import { RingBuffer } from "./ringBuffer"
-import * as _sink from "./sink"
-import * as DebounceState from "./stream/debounceState"
-import * as emit from "./stream/emit"
-import * as haltStrategy from "./stream/haltStrategy"
-import * as Handoff from "./stream/handoff"
-import * as HandoffSignal from "./stream/handoffSignal"
-import * as pull from "./stream/pull"
-import * as SinkEndReason from "./stream/sinkEndReason"
-import * as ZipAllState from "./stream/zipAllState"
-import * as ZipChunksState from "./stream/zipChunksState"
-import * as _take from "./take"
+import * as Cause from "../Cause.js"
+import type * as Channel from "../Channel.js"
+import * as Chunk from "../Chunk.js"
+import * as Clock from "../Clock.js"
+import * as Context from "../Context.js"
+import * as Deferred from "../Deferred.js"
+import * as Duration from "../Duration.js"
+import * as Effect from "../Effect.js"
+import * as Either from "../Either.js"
+import * as Equal from "../Equal.js"
+import * as Exit from "../Exit.js"
+import * as Fiber from "../Fiber.js"
+import { constTrue, dual, identity, pipe } from "../Function.js"
+import type { LazyArg } from "../Function.js"
+import * as Layer from "../Layer.js"
+import * as MergeDecision from "../MergeDecision.js"
+import * as Option from "../Option.js"
+import type * as Order from "../Order.js"
+import { pipeArguments } from "../Pipeable.js"
+import { hasProperty, isTagged, type Predicate, type Refinement } from "../Predicate.js"
+import * as PubSub from "../PubSub.js"
+import * as Queue from "../Queue.js"
+import * as Ref from "../Ref.js"
+import * as Runtime from "../Runtime.js"
+import * as Schedule from "../Schedule.js"
+import * as Scope from "../Scope.js"
+import type * as Sink from "../Sink.js"
+import type * as Stream from "../Stream.js"
+import type * as Emit from "../StreamEmit.js"
+import * as HaltStrategy from "../StreamHaltStrategy.js"
+import type * as Take from "../Take.js"
+import type * as Tracer from "../Tracer.js"
+import * as Tuple from "../Tuple.js"
+import * as channel from "./channel.js"
+import * as channelExecutor from "./channel/channelExecutor.js"
+import * as MergeStrategy from "./channel/mergeStrategy.js"
+import * as singleProducerAsyncInput from "./channel/singleProducerAsyncInput.js"
+import * as core from "./core-stream.js"
+import { RingBuffer } from "./ringBuffer.js"
+import * as _sink from "./sink.js"
+import * as DebounceState from "./stream/debounceState.js"
+import * as emit from "./stream/emit.js"
+import * as haltStrategy from "./stream/haltStrategy.js"
+import * as Handoff from "./stream/handoff.js"
+import * as HandoffSignal from "./stream/handoffSignal.js"
+import * as pull from "./stream/pull.js"
+import * as SinkEndReason from "./stream/sinkEndReason.js"
+import * as ZipAllState from "./stream/zipAllState.js"
+import * as ZipChunksState from "./stream/zipChunksState.js"
+import * as _take from "./take.js"
 
 /** @internal */
 const StreamSymbolKey = "effect/Stream"
@@ -809,7 +810,7 @@ export const buffer = dual<
       readonly capacity: "unbounded"
     } | {
       readonly capacity: number
-      readonly strategy?: "dropping" | "sliding" | "suspend"
+      readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
     }
   ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
   <R, E, A>(
@@ -818,7 +819,7 @@ export const buffer = dual<
       readonly capacity: "unbounded"
     } | {
       readonly capacity: number
-      readonly strategy?: "dropping" | "sliding" | "suspend"
+      readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
     }
   ) => Stream.Stream<R, E, A>
 >(2, <R, E, A>(
@@ -827,7 +828,7 @@ export const buffer = dual<
     readonly capacity: "unbounded"
   } | {
     readonly capacity: number
-    readonly strategy?: "dropping" | "sliding" | "suspend"
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
   }
 ): Stream.Stream<R, E, A> => {
   if (options.capacity === "unbounded") {
@@ -862,15 +863,15 @@ export const buffer = dual<
 export const bufferChunks = dual<
   (options: {
     readonly capacity: number
-    readonly strategy?: "dropping" | "sliding" | "suspend"
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
   }) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
   <R, E, A>(self: Stream.Stream<R, E, A>, options: {
     readonly capacity: number
-    readonly strategy?: "dropping" | "sliding" | "suspend"
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
   }) => Stream.Stream<R, E, A>
 >(2, <R, E, A>(self: Stream.Stream<R, E, A>, options: {
   readonly capacity: number
-  readonly strategy?: "dropping" | "sliding" | "suspend"
+  readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
 }): Stream.Stream<R, E, A> => {
   if (options.strategy === "dropping") {
     return bufferChunksDropping(self, options.capacity)
@@ -1562,17 +1563,17 @@ export const concatAll = <R, E, A>(streams: Chunk.Chunk<Stream.Stream<R, E, A>>)
 export const cross = dual<
   <R2, E2, A2>(
     that: Stream.Stream<R2, E2, A2>
-  ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, readonly [A, A2]>,
+  ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, [A, A2]>,
   <R, E, A, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [A, A2]>
+  ) => Stream.Stream<R2 | R, E2 | E, [A, A2]>
 >(
   2,
   <R, E, A, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>
-  ): Stream.Stream<R | R2, E | E2, readonly [A, A2]> => pipe(self, crossWith(that, (a, a2) => [a, a2]))
+  ): Stream.Stream<R | R2, E | E2, [A, A2]> => pipe(self, crossWith(that, (a, a2) => [a, a2]))
 )
 
 /** @internal */
@@ -1639,12 +1640,12 @@ export const debounce = dual<
     Effect.flatMap((input) =>
       Effect.transplant<never, never, Stream.Stream<R, E, A>>((grafter) =>
         pipe(
-          Handoff.make<HandoffSignal.HandoffSignal<never, A>>(),
+          Handoff.make<HandoffSignal.HandoffSignal<E, A>>(),
           Effect.map((handoff) => {
             const enqueue = (last: Chunk.Chunk<A>): Effect.Effect<
               never,
               never,
-              Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<A>, unknown>
+              Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>
             > =>
               pipe(
                 Clock.sleep(duration),
@@ -1682,8 +1683,8 @@ export const debounce = dual<
                   )
               })
             const consumer = (
-              state: DebounceState.DebounceState<never, A>
-            ): Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<A>, unknown> => {
+              state: DebounceState.DebounceState<E, A>
+            ): Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown> => {
               switch (state._tag) {
                 case DebounceState.OP_NOT_STARTED: {
                   return pipe(
@@ -1767,7 +1768,7 @@ export const debounce = dual<
                 Effect.forkScoped,
                 Effect.as(pipe(
                   consumer(DebounceState.notStarted),
-                  core.embedInput<E, Chunk.Chunk<A>, unknown>(input)
+                  core.embedInput<E, Chunk.Chunk<A>, unknown>(input as any)
                 )),
                 channel.unwrapScoped
               )
@@ -1898,7 +1899,7 @@ export const distributedWithDynamic = dual<
   ) => Effect.Effect<
     Scope.Scope | R,
     never,
-    Effect.Effect<never, never, readonly [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
+    Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
   >,
   <R, E, A, _>(
     self: Stream.Stream<R, E, A>,
@@ -1909,7 +1910,7 @@ export const distributedWithDynamic = dual<
   ) => Effect.Effect<
     Scope.Scope | R,
     never,
-    Effect.Effect<never, never, readonly [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
+    Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
   >
 >(2, <R, E, A, _>(
   self: Stream.Stream<R, E, A>,
@@ -1920,9 +1921,10 @@ export const distributedWithDynamic = dual<
 ): Effect.Effect<
   R | Scope.Scope,
   never,
-  Effect.Effect<never, never, readonly [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
+  Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
 > => distributedWithDynamicCallback(self, options.maximumLag, options.decide, () => Effect.unit))
 
+/** @internal */
 export const distributedWithDynamicCallback = dual<
   <E, A, _>(
     maximumLag: number,
@@ -1933,7 +1935,7 @@ export const distributedWithDynamicCallback = dual<
   ) => Effect.Effect<
     Scope.Scope | R,
     never,
-    Effect.Effect<never, never, readonly [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
+    Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
   >,
   <R, E, A, _>(
     self: Stream.Stream<R, E, A>,
@@ -1943,7 +1945,7 @@ export const distributedWithDynamicCallback = dual<
   ) => Effect.Effect<
     Scope.Scope | R,
     never,
-    Effect.Effect<never, never, readonly [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
+    Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
   >
 >(4, <R, E, A, _>(
   self: Stream.Stream<R, E, A>,
@@ -1953,7 +1955,7 @@ export const distributedWithDynamicCallback = dual<
 ): Effect.Effect<
   R | Scope.Scope,
   never,
-  Effect.Effect<never, never, readonly [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
+  Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
 > =>
   pipe(
     Effect.acquireRelease(
@@ -2009,14 +2011,14 @@ export const distributedWithDynamicCallback = dual<
           )
         const queuesLock = yield* $(Effect.makeSemaphore(1))
         const newQueue = yield* $(
-          Ref.make<Effect.Effect<never, never, readonly [number, Queue.Queue<Exit.Exit<Option.Option<E>, A>>]>>(
+          Ref.make<Effect.Effect<never, never, [number, Queue.Queue<Exit.Exit<Option.Option<E>, A>>]>>(
             pipe(
               Queue.bounded<Exit.Exit<Option.Option<E>, A>>(maximumLag),
               Effect.flatMap((queue) => {
                 const id = newDistributedWithDynamicId()
                 return pipe(
                   Ref.update(queuesRef, (map) => map.set(id, queue)),
-                  Effect.as([id, queue] as const)
+                  Effect.as([id, queue])
                 )
               })
             )
@@ -2036,7 +2038,7 @@ export const distributedWithDynamicCallback = dual<
                     const id = newDistributedWithDynamicId()
                     return pipe(
                       Ref.update(queuesRef, (map) => map.set(id, queue)),
-                      Effect.as([id, queue] as const)
+                      Effect.as(Tuple.make(id, queue))
                     )
                   })
                 )
@@ -2584,29 +2586,29 @@ export const flatMap = dual<
   <A, R2, E2, A2>(
     f: (a: A) => Stream.Stream<R2, E2, A2>,
     options?: {
-      readonly concurrency?: number | "unbounded"
-      readonly bufferSize?: number
-      readonly switch?: boolean
+      readonly concurrency?: number | "unbounded" | undefined
+      readonly bufferSize?: number | undefined
+      readonly switch?: boolean | undefined
     }
   ) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, A2>,
   <R, E, A, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     f: (a: A) => Stream.Stream<R2, E2, A2>,
     options?: {
-      readonly concurrency?: number | "unbounded"
-      readonly bufferSize?: number
-      readonly switch?: boolean
+      readonly concurrency?: number | "unbounded" | undefined
+      readonly bufferSize?: number | undefined
+      readonly switch?: boolean | undefined
     }
   ) => Stream.Stream<R2 | R, E2 | E, A2>
 >(
-  (args) => typeof args[0] !== "function",
+  (args) => isStream(args[0]),
   <R, E, A, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     f: (a: A) => Stream.Stream<R2, E2, A2>,
     options?: {
-      readonly concurrency?: number | "unbounded"
-      readonly bufferSize?: number
-      readonly switch?: boolean
+      readonly concurrency?: number | "unbounded" | undefined
+      readonly bufferSize?: number | undefined
+      readonly switch?: boolean | undefined
     }
   ): Stream.Stream<R | R2, E | E2, A2> => {
     const bufferSize = options?.bufferSize ?? 16
@@ -2700,16 +2702,16 @@ const flatMapParSwitchBuffer = dual<
 /** @internal */
 export const flatten = dual<
   (options?: {
-    readonly concurrency?: number | "unbounded"
-    readonly bufferSize?: number
+    readonly concurrency?: number | "unbounded" | undefined
+    readonly bufferSize?: number | undefined
   }) => <R, E, R2, E2, A>(
     self: Stream.Stream<R, E, Stream.Stream<R2, E2, A>>
   ) => Stream.Stream<R | R2, E | E2, A>,
   <R, E, R2, E2, A>(
     self: Stream.Stream<R, E, Stream.Stream<R2, E2, A>>,
     options?: {
-      readonly concurrency?: number | "unbounded"
-      readonly bufferSize?: number
+      readonly concurrency?: number | "unbounded" | undefined
+      readonly bufferSize?: number | undefined
     }
   ) => Stream.Stream<R | R2, E | E2, A>
 >((args) => isStream(args[0]), (self, options) => flatMap(self, identity, options))
@@ -2733,8 +2735,8 @@ export const flattenChunks = <R, E, A>(self: Stream.Stream<R, E, Chunk.Chunk<A>>
 export const flattenEffect = dual<
   (
     options?: {
-      readonly concurrency?: number | "unbounded"
-      readonly unordered?: boolean
+      readonly concurrency?: number | "unbounded" | undefined
+      readonly unordered?: boolean | undefined
     }
   ) => <R, E, R2, E2, A>(
     self: Stream.Stream<R, E, Effect.Effect<R2, E2, A>>
@@ -2742,8 +2744,8 @@ export const flattenEffect = dual<
   <R, E, R2, E2, A>(
     self: Stream.Stream<R, E, Effect.Effect<R2, E2, A>>,
     options?: {
-      readonly concurrency?: number | "unbounded"
-      readonly unordered?: boolean
+      readonly concurrency?: number | "unbounded" | undefined
+      readonly unordered?: boolean | undefined
     }
   ) => Stream.Stream<R | R2, E | E2, A>
 >(
@@ -2877,11 +2879,11 @@ export const fromChunk = <A>(chunk: Chunk.Chunk<A>): Stream.Stream<never, never,
 export const fromChunkPubSub: {
   <A>(pubsub: PubSub.PubSub<Chunk.Chunk<A>>, options: {
     readonly scoped: true
-    readonly shutdown?: boolean
+    readonly shutdown?: boolean | undefined
   }): Effect.Effect<Scope.Scope, never, Stream.Stream<never, never, A>>
   <A>(pubsub: PubSub.PubSub<Chunk.Chunk<A>>, options?: {
-    readonly scoped?: false
-    readonly shutdown?: boolean
+    readonly scoped?: false | undefined
+    readonly shutdown?: boolean | undefined
   }): Stream.Stream<never, never, A>
 } = (pubsub, options): any => {
   if (options?.scoped) {
@@ -2894,7 +2896,7 @@ export const fromChunkPubSub: {
 
 /** @internal */
 export const fromChunkQueue = <A>(queue: Queue.Dequeue<Chunk.Chunk<A>>, options?: {
-  readonly shutdown?: boolean
+  readonly shutdown?: boolean | undefined
 }): Stream.Stream<never, never, A> =>
   pipe(
     Queue.take(queue),
@@ -2939,13 +2941,13 @@ export const fromEffectOption = <R, E, A>(effect: Effect.Effect<R, Option.Option
 export const fromPubSub: {
   <A>(pubsub: PubSub.PubSub<A>, options: {
     readonly scoped: true
-    readonly maxChunkSize?: number
-    readonly shutdown?: boolean
+    readonly maxChunkSize?: number | undefined
+    readonly shutdown?: boolean | undefined
   }): Effect.Effect<Scope.Scope, never, Stream.Stream<never, never, A>>
   <A>(pubsub: PubSub.PubSub<A>, options?: {
-    readonly scoped?: false
-    readonly maxChunkSize?: number
-    readonly shutdown?: boolean
+    readonly scoped?: false | undefined
+    readonly maxChunkSize?: number | undefined
+    readonly shutdown?: boolean | undefined
   }): Stream.Stream<never, never, A>
 } = (pubsub, options): any => {
   const maxChunkSize = options?.maxChunkSize ?? DefaultChunkSize
@@ -3036,8 +3038,8 @@ export const fromPull = <R, R2, E, A>(
 export const fromQueue = <A>(
   queue: Queue.Dequeue<A>,
   options?: {
-    readonly maxChunkSize?: number
-    readonly shutdown?: boolean
+    readonly maxChunkSize?: number | undefined
+    readonly shutdown?: boolean | undefined
   }
 ): Stream.Stream<never, never, A> =>
   pipe(
@@ -3139,24 +3141,24 @@ const readChunkStreamByobReader = <E>(
 export const groupAdjacentBy = dual<
   <A, K>(
     f: (a: A) => K
-  ) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, readonly [K, Chunk.NonEmptyChunk<A>]>,
+  ) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, [K, Chunk.NonEmptyChunk<A>]>,
   <R, E, A, K>(
     self: Stream.Stream<R, E, A>,
     f: (a: A) => K
-  ) => Stream.Stream<R, E, readonly [K, Chunk.NonEmptyChunk<A>]>
+  ) => Stream.Stream<R, E, [K, Chunk.NonEmptyChunk<A>]>
 >(
   2,
   <R, E, A, K>(
     self: Stream.Stream<R, E, A>,
     f: (a: A) => K
-  ): Stream.Stream<R, E, readonly [K, Chunk.NonEmptyChunk<A>]> => {
-    type Output = readonly [K, Chunk.NonEmptyChunk<A>]
+  ): Stream.Stream<R, E, [K, Chunk.NonEmptyChunk<A>]> => {
+    type Output = [K, Chunk.NonEmptyChunk<A>]
     const groupAdjacentByChunk = (
       state: Option.Option<Output>,
       chunk: Chunk.Chunk<A>
-    ): readonly [Option.Option<Output>, Chunk.Chunk<Output>] => {
+    ): [Option.Option<Output>, Chunk.Chunk<Output>] => {
       if (Chunk.isEmpty(chunk)) {
-        return [state, Chunk.empty()] as const
+        return [state, Chunk.empty()]
       }
       const builder: Array<Output> = []
       let from = 0
@@ -3205,7 +3207,7 @@ export const groupAdjacentBy = dual<
       }
       const nonEmptyChunk = Chunk.appendAll(previousChunk, Chunk.unsafeFromArray(Array.from(chunk).slice(from, until)))
       const output = Chunk.unsafeFromArray(builder)
-      return [Option.some([key, nonEmptyChunk as Chunk.NonEmptyChunk<A>] as const), output]
+      return [Option.some([key, nonEmptyChunk as Chunk.NonEmptyChunk<A>]), output]
     }
 
     const groupAdjacent = (
@@ -3414,7 +3416,7 @@ export const interleaveWith = dual<
       channel.unwrapScoped(
         pipe(
           Handoff.make<Take.Take<E | E2 | E3, A | A2>>(),
-          Effect.zip(Handoff.make<Take.Take<E | E2, A | A2>>()),
+          Effect.zip(Handoff.make<Take.Take<E | E2 | E3, A | A2>>()),
           Effect.tap(([left]) =>
             pipe(
               toChannel(self),
@@ -3892,14 +3894,14 @@ export const merge = dual<
   <R2, E2, A2>(
     that: Stream.Stream<R2, E2, A2>,
     options?: {
-      readonly haltStrategy?: HaltStrategy.HaltStrategyInput
+      readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
     }
   ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, A2 | A>,
   <R, E, A, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>,
     options?: {
-      readonly haltStrategy?: HaltStrategy.HaltStrategyInput
+      readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
     }
   ) => Stream.Stream<R2 | R, E2 | E, A2 | A>
 >(
@@ -3908,7 +3910,7 @@ export const merge = dual<
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>,
     options?: {
-      readonly haltStrategy?: HaltStrategy.HaltStrategyInput
+      readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
     }
   ): Stream.Stream<R | R2, E | E2, A | A2> =>
     mergeWith(self, that, {
@@ -3922,11 +3924,11 @@ export const merge = dual<
 export const mergeAll = dual<
   (options: {
     readonly concurrency: number | "unbounded"
-    readonly bufferSize?: number
+    readonly bufferSize?: number | undefined
   }) => <R, E, A>(streams: Iterable<Stream.Stream<R, E, A>>) => Stream.Stream<R, E, A>,
   <R, E, A>(streams: Iterable<Stream.Stream<R, E, A>>, options: {
     readonly concurrency: number | "unbounded"
-    readonly bufferSize?: number
+    readonly bufferSize?: number | undefined
   }) => Stream.Stream<R, E, A>
 >((args) => Symbol.iterator in args[0], (streams, options) => flatten(fromIterable(streams), options))
 
@@ -3989,7 +3991,7 @@ export const mergeWith = dual<
     options: {
       readonly onSelf: (a: A) => A3
       readonly onOther: (a2: A2) => A4
-      readonly haltStrategy?: HaltStrategy.HaltStrategyInput
+      readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
     }
   ) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, A3 | A4>,
   <R, E, R2, E2, A2, A, A3, A4>(
@@ -3998,7 +4000,7 @@ export const mergeWith = dual<
     options: {
       readonly onSelf: (a: A) => A3
       readonly onOther: (a2: A2) => A4
-      readonly haltStrategy?: HaltStrategy.HaltStrategyInput
+      readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
     }
   ) => Stream.Stream<R2 | R, E2 | E, A3 | A4>
 >(
@@ -4009,7 +4011,7 @@ export const mergeWith = dual<
     options: {
       readonly onSelf: (a: A) => A3
       readonly onOther: (a2: A2) => A4
-      readonly haltStrategy?: HaltStrategy.HaltStrategyInput
+      readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
     }
   ): Stream.Stream<R | R2, E | E2, A3 | A4> => {
     const strategy = options.haltStrategy ? haltStrategy.fromInput(options.haltStrategy) : HaltStrategy.Both
@@ -4251,15 +4253,15 @@ export const peel = dual<
     sink: Sink.Sink<R2, E2, A, A, Z>
   ) => <R, E>(
     self: Stream.Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, readonly [Z, Stream.Stream<never, E, A>]>,
+  ) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, [Z, Stream.Stream<never, E, A>]>,
   <R, E, R2, E2, A, Z>(
     self: Stream.Stream<R, E, A>,
     sink: Sink.Sink<R2, E2, A, A, Z>
-  ) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, readonly [Z, Stream.Stream<never, E, A>]>
+  ) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, [Z, Stream.Stream<never, E, A>]>
 >(2, <R, E, R2, E2, A, Z>(
   self: Stream.Stream<R, E, A>,
   sink: Sink.Sink<R2, E2, A, A, Z>
-): Effect.Effect<R | R2 | Scope.Scope, E2 | E, readonly [Z, Stream.Stream<never, E, A>]> => {
+): Effect.Effect<R | R2 | Scope.Scope, E2 | E, [Z, Stream.Stream<never, E, A>]> => {
   type Signal = Emit | Halt | End
   const OP_EMIT = "Emit" as const
   type OP_EMIT = typeof OP_EMIT
@@ -4358,7 +4360,7 @@ export const peel = dual<
             run(consumer),
             Effect.forkScoped,
             Effect.zipRight(Deferred.await(deferred)),
-            Effect.map((z) => [z, new StreamImpl(producer)] as const)
+            Effect.map((z) => [z, new StreamImpl(producer)] as [Z, StreamImpl<never, E, A>])
           )
         })
       )
@@ -4371,25 +4373,31 @@ export const peel = dual<
 export const partition = dual<
   <A>(
     predicate: Predicate<A>,
-    options?: { bufferSize?: number }
+    options?: {
+      bufferSize?: number | undefined
+    }
   ) => <R, E>(
     self: Stream.Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R, E, readonly [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]>,
+  ) => Effect.Effect<Scope.Scope | R, E, [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]>,
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
     predicate: Predicate<A>,
-    options?: { bufferSize?: number }
-  ) => Effect.Effect<Scope.Scope | R, E, readonly [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]>
+    options?: {
+      bufferSize?: number | undefined
+    }
+  ) => Effect.Effect<Scope.Scope | R, E, [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]>
 >(
   (args) => typeof args[1] === "function",
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
     predicate: Predicate<A>,
-    options?: { readonly bufferSize?: number }
+    options?: {
+      readonly bufferSize?: number | undefined
+    }
   ): Effect.Effect<
     R | Scope.Scope,
     E,
-    readonly [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]
+    [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]
   > =>
     partitionEither(
       self,
@@ -4402,33 +4410,39 @@ export const partition = dual<
 export const partitionEither = dual<
   <A, R2, E2, A2, A3>(
     predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
-    options?: { readonly bufferSize?: number }
+    options?: {
+      readonly bufferSize?: number | undefined
+    }
   ) => <R, E>(
     self: Stream.Stream<R, E, A>
   ) => Effect.Effect<
     Scope.Scope | R2 | R,
     E2 | E,
-    readonly [Stream.Stream<never, E2 | E, A2>, Stream.Stream<never, E2 | E, A3>]
+    [Stream.Stream<never, E2 | E, A2>, Stream.Stream<never, E2 | E, A3>]
   >,
   <R, E, A, R2, E2, A2, A3>(
     self: Stream.Stream<R, E, A>,
     predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
-    options?: { readonly bufferSize?: number }
+    options?: {
+      readonly bufferSize?: number | undefined
+    }
   ) => Effect.Effect<
     Scope.Scope | R2 | R,
     E2 | E,
-    readonly [Stream.Stream<never, E2 | E, A2>, Stream.Stream<never, E2 | E, A3>]
+    [Stream.Stream<never, E2 | E, A2>, Stream.Stream<never, E2 | E, A3>]
   >
 >(
   (args) => typeof args[1] === "function",
   <R, E, A, R2, E2, A2, A3>(
     self: Stream.Stream<R, E, A>,
     predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
-    options?: { readonly bufferSize?: number }
+    options?: {
+      readonly bufferSize?: number | undefined
+    }
   ): Effect.Effect<
     R | R2 | Scope.Scope,
     E | E2,
-    readonly [Stream.Stream<never, E | E2, A2>, Stream.Stream<never, E | E2, A3>]
+    [Stream.Stream<never, E | E2, A2>, Stream.Stream<never, E | E2, A3>]
   > =>
     pipe(
       mapEffectSequential(self, predicate),
@@ -4954,11 +4968,11 @@ export const repeatElementsWith = dual<
             never,
             Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<C>, void>
           > = pipe(
-            driver.last(),
+            driver.last,
             Effect.orDie,
             Effect.flatMap((b) =>
               pipe(
-                driver.reset(),
+                driver.reset,
                 Effect.map(() =>
                   pipe(
                     core.write(Chunk.of(options.onSchedule(b))),
@@ -5019,7 +5033,7 @@ export const repeatWith = dual<
     return pipe(
       Schedule.driver(schedule),
       Effect.map((driver) => {
-        const scheduleOutput = pipe(driver.last(), Effect.orDie, Effect.map(options.onSchedule))
+        const scheduleOutput = pipe(driver.last, Effect.orDie, Effect.map(options.onSchedule))
         const process = pipe(self, map(options.onElement), toChannel)
         const loop: Channel.Channel<R | R2, unknown, unknown, unknown, E, Chunk.Chunk<C>, void> = channel.unwrap(
           Effect.match(driver.next(void 0), {
@@ -5089,7 +5103,7 @@ export const retry = dual<
           unwrap(
             Effect.matchEffect(driver.next(error as E0), {
               onFailure: () => Effect.fail(error),
-              onSuccess: () => Effect.succeed(pipe(loop, tap(() => driver.reset())))
+              onSuccess: () => Effect.succeed(pipe(loop, tap(() => driver.reset)))
             })
           ))
         return loop
@@ -5579,7 +5593,7 @@ export const scheduleWith = dual<
         Effect.matchEffect(driver.next(next.value as A0), {
           onFailure: () =>
             pipe(
-              driver.last(),
+              driver.last,
               Effect.orDie,
               Effect.map((b) =>
                 pipe(
@@ -5587,7 +5601,7 @@ export const scheduleWith = dual<
                   core.flatMap(() => loop(driver, iterator))
                 )
               ),
-              Effect.zipLeft(driver.reset())
+              Effect.zipLeft(driver.reset)
             ),
           onSuccess: () =>
             Effect.succeed(pipe(
@@ -6243,8 +6257,8 @@ export const throttle = dual<
       readonly cost: (chunk: Chunk.Chunk<A>) => number
       readonly units: number
       readonly duration: Duration.DurationInput
-      readonly burst?: number
-      readonly strategy?: "enforce" | "shape"
+      readonly burst?: number | undefined
+      readonly strategy?: "enforce" | "shape" | undefined
     }
   ) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
   <R, E, A>(
@@ -6253,8 +6267,8 @@ export const throttle = dual<
       readonly cost: (chunk: Chunk.Chunk<A>) => number
       readonly units: number
       readonly duration: Duration.DurationInput
-      readonly burst?: number
-      readonly strategy?: "enforce" | "shape"
+      readonly burst?: number | undefined
+      readonly strategy?: "enforce" | "shape" | undefined
     }
   ) => Stream.Stream<R, E, A>
 >(
@@ -6265,8 +6279,8 @@ export const throttle = dual<
       readonly cost: (chunk: Chunk.Chunk<A>) => number
       readonly units: number
       readonly duration: Duration.DurationInput
-      readonly burst?: number
-      readonly strategy?: "enforce" | "shape"
+      readonly burst?: number | undefined
+      readonly strategy?: "enforce" | "shape" | undefined
     }
   ): Stream.Stream<R, E, A> =>
     throttleEffect(self, {
@@ -6282,8 +6296,8 @@ export const throttleEffect = dual<
       readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, number>
       readonly units: number
       readonly duration: Duration.DurationInput
-      readonly burst?: number
-      readonly strategy?: "enforce" | "shape"
+      readonly burst?: number | undefined
+      readonly strategy?: "enforce" | "shape" | undefined
     }
   ) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, A>,
   <R, E, A, R2, E2>(
@@ -6292,8 +6306,8 @@ export const throttleEffect = dual<
       readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, number>
       readonly units: number
       readonly duration: Duration.DurationInput
-      readonly burst?: number
-      readonly strategy?: "enforce" | "shape"
+      readonly burst?: number | undefined
+      readonly strategy?: "enforce" | "shape" | undefined
     }
   ) => Stream.Stream<R2 | R, E2 | E, A>
 >(
@@ -6304,8 +6318,8 @@ export const throttleEffect = dual<
       readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, number>
       readonly units: number
       readonly duration: Duration.DurationInput
-      readonly burst?: number
-      readonly strategy?: "enforce" | "shape"
+      readonly burst?: number | undefined
+      readonly strategy?: "enforce" | "shape" | undefined
     }
   ): Stream.Stream<R | R2, E | E2, A> => {
     if (options.strategy === "enforce") {
@@ -6549,25 +6563,31 @@ export const toPull = <R, E, A>(
 export const toQueue = dual<
   (
     options?: {
-      readonly strategy?: "suspend" | "sliding" | "dropping"
-      readonly capacity?: number
-    } | { readonly strategy: "unbounded" }
+      readonly strategy?: "suspend" | "sliding" | "dropping" | undefined
+      readonly capacity?: number | undefined
+    } | {
+      readonly strategy: "unbounded"
+    }
   ) => <R, E, A>(
     self: Stream.Stream<R, E, A>
   ) => Effect.Effect<R | Scope.Scope, never, Queue.Dequeue<Take.Take<E, A>>>,
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
     options?: {
-      readonly strategy?: "suspend" | "sliding" | "dropping"
-      readonly capacity?: number
-    } | { readonly strategy: "unbounded" }
+      readonly strategy?: "suspend" | "sliding" | "dropping" | undefined
+      readonly capacity?: number | undefined
+    } | {
+      readonly strategy: "unbounded"
+    }
   ) => Effect.Effect<R | Scope.Scope, never, Queue.Dequeue<Take.Take<E, A>>>
 >((args) => isStream(args[0]), <R, E, A>(
   self: Stream.Stream<R, E, A>,
   options?: {
-    readonly strategy?: "suspend" | "sliding" | "dropping"
-    readonly capacity?: number
-  } | { readonly strategy: "unbounded" }
+    readonly strategy?: "suspend" | "sliding" | "dropping" | undefined
+    readonly capacity?: number | undefined
+  } | {
+    readonly strategy: "unbounded"
+  }
 ) =>
   Effect.tap(
     Effect.acquireRelease(
@@ -6585,16 +6605,22 @@ export const toQueue = dual<
 
 /** @internal */
 export const toQueueOfElements = dual<
-  (options?: { readonly capacity?: number }) => <R, E, A>(
+  (options?: {
+    readonly capacity?: number | undefined
+  }) => <R, E, A>(
     self: Stream.Stream<R, E, A>
   ) => Effect.Effect<R | Scope.Scope, never, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>>,
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
-    options?: { readonly capacity?: number }
+    options?: {
+      readonly capacity?: number | undefined
+    }
   ) => Effect.Effect<R | Scope.Scope, never, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>>
 >((args) => isStream(args[0]), <R, E, A>(
   self: Stream.Stream<R, E, A>,
-  options?: { readonly capacity?: number }
+  options?: {
+    readonly capacity?: number | undefined
+  }
 ) =>
   Effect.tap(
     Effect.acquireRelease(
@@ -6866,22 +6892,22 @@ export const withSpan = dual<
   (
     name: string,
     options?: {
-      readonly attributes?: Record<string, unknown>
-      readonly links?: ReadonlyArray<Tracer.SpanLink>
-      readonly parent?: Tracer.ParentSpan
-      readonly root?: boolean
-      readonly context?: Context.Context<never>
+      readonly attributes?: Record<string, unknown> | undefined
+      readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+      readonly parent?: Tracer.ParentSpan | undefined
+      readonly root?: boolean | undefined
+      readonly context?: Context.Context<never> | undefined
     }
   ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<Exclude<R, Tracer.ParentSpan>, E, A>,
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
     name: string,
     options?: {
-      readonly attributes?: Record<string, unknown>
-      readonly links?: ReadonlyArray<Tracer.SpanLink>
-      readonly parent?: Tracer.ParentSpan
-      readonly root?: boolean
-      readonly context?: Context.Context<never>
+      readonly attributes?: Record<string, unknown> | undefined
+      readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+      readonly parent?: Tracer.ParentSpan | undefined
+      readonly root?: boolean | undefined
+      readonly context?: Context.Context<never> | undefined
     }
   ) => Stream.Stream<Exclude<R, Tracer.ParentSpan>, E, A>
 >(3, (self, name, options) => new StreamImpl(channel.withSpan(toChannel(self), name, options)))
@@ -6890,17 +6916,17 @@ export const withSpan = dual<
 export const zip = dual<
   <R2, E2, A2>(
     that: Stream.Stream<R2, E2, A2>
-  ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, readonly [A, A2]>,
+  ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, [A, A2]>,
   <R, E, A, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [A, A2]>
+  ) => Stream.Stream<R2 | R, E2 | E, [A, A2]>
 >(
   2,
   <R, E, A, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>
-  ): Stream.Stream<R | R2, E | E2, readonly [A, A2]> => pipe(self, zipWith(that, (a, a2) => [a, a2]))
+  ): Stream.Stream<R | R2, E | E2, [A, A2]> => pipe(self, zipWith(that, (a, a2) => [a, a2]))
 )
 
 /** @internal */
@@ -6909,17 +6935,17 @@ export const zipFlatten = dual<
     that: Stream.Stream<R2, E2, A2>
   ) => <R, E, A extends ReadonlyArray<any>>(
     self: Stream.Stream<R, E, A>
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [...A, A2]>,
+  ) => Stream.Stream<R2 | R, E2 | E, [...A, A2]>,
   <R, E, A extends ReadonlyArray<any>, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [...A, A2]>
+  ) => Stream.Stream<R2 | R, E2 | E, [...A, A2]>
 >(
   2,
   <R, E, A extends ReadonlyArray<any>, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>
-  ): Stream.Stream<R | R2, E | E2, readonly [...A, A2]> => pipe(self, zipWith(that, (a, a2) => [...a, a2]))
+  ): Stream.Stream<R | R2, E | E2, [...A, A2]> => pipe(self, zipWith(that, (a, a2) => [...a, a2]))
 )
 
 /** @internal */
@@ -6930,7 +6956,7 @@ export const zipAll = dual<
       readonly defaultSelf: A
       readonly defaultOther: A2
     }
-  ) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, readonly [A, A2]>,
+  ) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, [A, A2]>,
   <R, E, R2, E2, A2, A>(
     self: Stream.Stream<R, E, A>,
     options: {
@@ -6938,7 +6964,7 @@ export const zipAll = dual<
       readonly defaultSelf: A
       readonly defaultOther: A2
     }
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [A, A2]>
+  ) => Stream.Stream<R2 | R, E2 | E, [A, A2]>
 >(
   2,
   <R, E, R2, E2, A2, A>(
@@ -6948,7 +6974,7 @@ export const zipAll = dual<
       readonly defaultSelf: A
       readonly defaultOther: A2
     }
-  ): Stream.Stream<R | R2, E | E2, readonly [A, A2]> =>
+  ): Stream.Stream<R | R2, E | E2, [A, A2]> =>
     zipAllWith(self, {
       other: options.other,
       onSelf: (a) => [a, options.defaultOther],
@@ -7020,7 +7046,7 @@ export const zipAllSortedByKey = dual<
     }
   ) => <R, E>(
     self: Stream.Stream<R, E, readonly [K, A]>
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [K, readonly [A, A2]]>,
+  ) => Stream.Stream<R2 | R, E2 | E, [K, [A, A2]]>,
   <R, E, R2, E2, A2, A, K>(
     self: Stream.Stream<R, E, readonly [K, A]>,
     options: {
@@ -7029,7 +7055,7 @@ export const zipAllSortedByKey = dual<
       readonly defaultOther: A2
       readonly order: Order.Order<K>
     }
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [K, readonly [A, A2]]>
+  ) => Stream.Stream<R2 | R, E2 | E, [K, [A, A2]]>
 >(
   2,
   <R, E, R2, E2, A2, A, K>(
@@ -7040,12 +7066,12 @@ export const zipAllSortedByKey = dual<
       readonly defaultOther: A2
       readonly order: Order.Order<K>
     }
-  ): Stream.Stream<R | R2, E | E2, readonly [K, readonly [A, A2]]> =>
+  ): Stream.Stream<R | R2, E | E2, [K, [A, A2]]> =>
     zipAllSortedByKeyWith(self, {
       other: options.other,
-      onSelf: (a) => [a, options.defaultOther] as const,
-      onOther: (a2) => [options.defaultSelf, a2] as const,
-      onBoth: (a, a2) => [a, a2] as const,
+      onSelf: (a) => [a, options.defaultOther],
+      onOther: (a2) => [options.defaultSelf, a2],
+      onBoth: (a, a2) => [a, a2],
       order: options.order
     })
 )
@@ -7058,7 +7084,7 @@ export const zipAllSortedByKeyLeft = dual<
       readonly defaultSelf: A
       readonly order: Order.Order<K>
     }
-  ) => <R, E>(self: Stream.Stream<R, E, readonly [K, A]>) => Stream.Stream<R2 | R, E2 | E, readonly [K, A]>,
+  ) => <R, E>(self: Stream.Stream<R, E, readonly [K, A]>) => Stream.Stream<R2 | R, E2 | E, [K, A]>,
   <R, E, R2, E2, A2, A, K>(
     self: Stream.Stream<R, E, readonly [K, A]>,
     options: {
@@ -7066,7 +7092,7 @@ export const zipAllSortedByKeyLeft = dual<
       readonly defaultSelf: A
       readonly order: Order.Order<K>
     }
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [K, A]>
+  ) => Stream.Stream<R2 | R, E2 | E, [K, A]>
 >(
   2,
   <R, E, R2, E2, A2, A, K>(
@@ -7076,7 +7102,7 @@ export const zipAllSortedByKeyLeft = dual<
       readonly defaultSelf: A
       readonly order: Order.Order<K>
     }
-  ): Stream.Stream<R | R2, E | E2, readonly [K, A]> =>
+  ): Stream.Stream<R | R2, E | E2, [K, A]> =>
     zipAllSortedByKeyWith(self, {
       other: options.other,
       onSelf: identity,
@@ -7094,7 +7120,7 @@ export const zipAllSortedByKeyRight = dual<
       readonly defaultOther: A2
       readonly order: Order.Order<K>
     }
-  ) => <R, E, A>(self: Stream.Stream<R, E, readonly [K, A]>) => Stream.Stream<R2 | R, E2 | E, readonly [K, A2]>,
+  ) => <R, E, A>(self: Stream.Stream<R, E, readonly [K, A]>) => Stream.Stream<R2 | R, E2 | E, [K, A2]>,
   <R, E, A, R2, E2, A2, K>(
     self: Stream.Stream<R, E, readonly [K, A]>,
     options: {
@@ -7102,7 +7128,7 @@ export const zipAllSortedByKeyRight = dual<
       readonly defaultOther: A2
       readonly order: Order.Order<K>
     }
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [K, A2]>
+  ) => Stream.Stream<R2 | R, E2 | E, [K, A2]>
 >(
   2,
   <R, E, A, R2, E2, A2, K>(
@@ -7112,7 +7138,7 @@ export const zipAllSortedByKeyRight = dual<
       readonly defaultOther: A2
       readonly order: Order.Order<K>
     }
-  ): Stream.Stream<R | R2, E | E2, readonly [K, A2]> =>
+  ): Stream.Stream<R | R2, E | E2, [K, A2]> =>
     zipAllSortedByKeyWith(self, {
       other: options.other,
       onSelf: () => options.defaultOther,
@@ -7132,7 +7158,7 @@ export const zipAllSortedByKeyWith = dual<
       readonly onBoth: (a: A, a2: A2) => A3
       readonly order: Order.Order<K>
     }
-  ) => <R, E>(self: Stream.Stream<R, E, readonly [K, A]>) => Stream.Stream<R2 | R, E2 | E, readonly [K, A3]>,
+  ) => <R, E>(self: Stream.Stream<R, E, readonly [K, A]>) => Stream.Stream<R2 | R, E2 | E, [K, A3]>,
   <R, E, R2, E2, A, A3, A2, K>(
     self: Stream.Stream<R, E, readonly [K, A]>,
     options: {
@@ -7142,7 +7168,7 @@ export const zipAllSortedByKeyWith = dual<
       readonly onBoth: (a: A, a2: A2) => A3
       readonly order: Order.Order<K>
     }
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [K, A3]>
+  ) => Stream.Stream<R2 | R, E2 | E, [K, A3]>
 >(
   2,
   <R, E, R2, E2, A, A3, A2, K>(
@@ -7154,7 +7180,7 @@ export const zipAllSortedByKeyWith = dual<
       readonly onBoth: (a: A, a2: A2) => A3
       readonly order: Order.Order<K>
     }
-  ): Stream.Stream<R | R2, E | E2, readonly [K, A3]> => {
+  ): Stream.Stream<R | R2, E | E2, [K, A3]> => {
     const pull = (
       state: ZipAllState.ZipAllState<readonly [K, A], readonly [K, A2]>,
       pullLeft: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<readonly [K, A]>>,
@@ -7165,7 +7191,7 @@ export const zipAllSortedByKeyWith = dual<
       Exit.Exit<
         Option.Option<E | E2>,
         readonly [
-          Chunk.Chunk<readonly [K, A3]>,
+          Chunk.Chunk<[K, A3]>,
           ZipAllState.ZipAllState<readonly [K, A], readonly [K, A2]>
         ]
       >
@@ -7179,7 +7205,7 @@ export const zipAllSortedByKeyWith = dual<
               onSuccess: (leftChunk) =>
                 Exit.succeed(
                   [
-                    Chunk.map(leftChunk, ([k, a]) => [k, options.onSelf(a)] as const),
+                    Chunk.map(leftChunk, ([k, a]) => [k, options.onSelf(a)]),
                     ZipAllState.DrainLeft
                   ] as const
                 )
@@ -7194,7 +7220,7 @@ export const zipAllSortedByKeyWith = dual<
               onSuccess: (rightChunk) =>
                 Exit.succeed(
                   [
-                    Chunk.map(rightChunk, ([k, a2]) => [k, options.onOther(a2)] as const),
+                    Chunk.map(rightChunk, ([k, a2]) => [k, options.onOther(a2)]),
                     ZipAllState.DrainRight
                   ] as const
                 )
@@ -7227,7 +7253,7 @@ export const zipAllSortedByKeyWith = dual<
                   return Effect.succeed(
                     Exit.succeed(
                       [
-                        pipe(leftOption.value, Chunk.map(([k, a]) => [k, options.onSelf(a)] as const)),
+                        pipe(leftOption.value, Chunk.map(([k, a]) => [k, options.onSelf(a)])),
                         ZipAllState.DrainLeft
                       ] as const
                     )
@@ -7240,7 +7266,7 @@ export const zipAllSortedByKeyWith = dual<
                   return Effect.succeed(
                     Exit.succeed(
                       [
-                        pipe(rightOption.value, Chunk.map(([k, a2]) => [k, options.onOther(a2)] as const)),
+                        pipe(rightOption.value, Chunk.map(([k, a2]) => [k, options.onOther(a2)])),
                         ZipAllState.DrainRight
                       ] as const
                     )
@@ -7257,7 +7283,7 @@ export const zipAllSortedByKeyWith = dual<
               onNone: () =>
                 Effect.succeed(
                   Exit.succeed([
-                    pipe(state.rightChunk, Chunk.map(([k, a2]) => [k, options.onOther(a2)] as const)),
+                    pipe(state.rightChunk, Chunk.map(([k, a2]) => [k, options.onOther(a2)])),
                     ZipAllState.DrainRight
                   ])
                 ),
@@ -7266,7 +7292,7 @@ export const zipAllSortedByKeyWith = dual<
                   Exit.Exit<
                     Option.Option<E | E2>,
                     readonly [
-                      Chunk.Chunk<readonly [K, A3]>,
+                      Chunk.Chunk<[K, A3]>,
                       ZipAllState.ZipAllState<readonly [K, A], readonly [K, A2]>
                     ]
                   >
@@ -7285,7 +7311,7 @@ export const zipAllSortedByKeyWith = dual<
                 Effect.succeed(
                   Exit.succeed(
                     [
-                      Chunk.map(state.leftChunk, ([k, a]) => [k, options.onSelf(a)] as const),
+                      Chunk.map(state.leftChunk, ([k, a]) => [k, options.onSelf(a)]),
                       ZipAllState.DrainLeft
                     ] as const
                   )
@@ -7295,7 +7321,7 @@ export const zipAllSortedByKeyWith = dual<
                   Exit.Exit<
                     Option.Option<E | E2>,
                     readonly [
-                      Chunk.Chunk<readonly [K, A3]>,
+                      Chunk.Chunk<[K, A3]>,
                       ZipAllState.ZipAllState<readonly [K, A], readonly [K, A2]>
                     ]
                   >
@@ -7313,11 +7339,11 @@ export const zipAllSortedByKeyWith = dual<
       leftChunk: Chunk.Chunk<readonly [K, A]>,
       rightChunk: Chunk.Chunk<readonly [K, A2]>
     ): readonly [
-      Chunk.Chunk<readonly [K, A3]>,
+      Chunk.Chunk<[K, A3]>,
       ZipAllState.ZipAllState<readonly [K, A], readonly [K, A2]>
     ] => {
       const hasNext = <T>(chunk: Chunk.Chunk<T>, index: number) => index < chunk.length - 1
-      const builder: Array<readonly [K, A3]> = []
+      const builder: Array<[K, A3]> = []
       let state:
         | ZipAllState.ZipAllState<
           readonly [K, A],
@@ -7357,7 +7383,7 @@ export const zipAllSortedByKeyWith = dual<
             loop = false
           }
         } else if (compare < 0) {
-          builder.push([k1, options.onSelf(a)] as const)
+          builder.push([k1, options.onSelf(a)])
           if (hasNext(leftChunk, leftIndex)) {
             leftIndex = leftIndex + 1
             leftTuple = pipe(leftChunk, Chunk.unsafeGet(leftIndex))
@@ -7375,7 +7401,7 @@ export const zipAllSortedByKeyWith = dual<
             loop = false
           }
         } else {
-          builder.push([k2, options.onOther(a2)] as const)
+          builder.push([k2, options.onOther(a2)])
           if (hasNext(rightChunk, rightIndex)) {
             rightIndex = rightIndex + 1
             rightTuple = pipe(rightChunk, Chunk.unsafeGet(rightIndex))
@@ -7394,7 +7420,7 @@ export const zipAllSortedByKeyWith = dual<
           }
         }
       }
-      return [Chunk.unsafeFromArray(builder), state!] as const
+      return [Chunk.unsafeFromArray(builder), state!]
     }
     return combineChunks(self, options.other, ZipAllState.PullBoth, pull)
   }
@@ -7601,17 +7627,17 @@ export const zipAllWith = dual<
 export const zipLatest = dual<
   <R2, E2, A2>(
     that: Stream.Stream<R2, E2, A2>
-  ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, readonly [A, A2]>,
+  ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R2 | R, E2 | E, [A, A2]>,
   <R, E, A, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>
-  ) => Stream.Stream<R2 | R, E2 | E, readonly [A, A2]>
+  ) => Stream.Stream<R2 | R, E2 | E, [A, A2]>
 >(
   2,
   <R, E, A, R2, E2, A2>(
     self: Stream.Stream<R, E, A>,
     that: Stream.Stream<R2, E2, A2>
-  ): Stream.Stream<R | R2, E | E2, readonly [A, A2]> => pipe(self, zipLatestWith(that, (a, a2) => [a, a2]))
+  ): Stream.Stream<R | R2, E | E2, [A, A2]> => pipe(self, zipLatestWith(that, (a, a2) => [a, a2]))
 )
 
 /** @internal */
@@ -7906,13 +7932,13 @@ export const zipWithChunks = dual<
 })
 
 /** @internal */
-export const zipWithIndex = <R, E, A>(self: Stream.Stream<R, E, A>): Stream.Stream<R, E, readonly [A, number]> =>
-  pipe(self, mapAccum(0, (index, a) => [index + 1, [a, index] as const] as const))
+export const zipWithIndex = <R, E, A>(self: Stream.Stream<R, E, A>): Stream.Stream<R, E, [A, number]> =>
+  pipe(self, mapAccum(0, (index, a) => [index + 1, [a, index]]))
 
 /** @internal */
 export const zipWithNext = <R, E, A>(
   self: Stream.Stream<R, E, A>
-): Stream.Stream<R, E, readonly [A, Option.Option<A>]> => {
+): Stream.Stream<R, E, [A, Option.Option<A>]> => {
   const process = (
     last: Option.Option<A>
   ): Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<readonly [A, Option.Option<A>]>, void> =>
@@ -7952,10 +7978,10 @@ export const zipWithNext = <R, E, A>(
 /** @internal */
 export const zipWithPrevious = <R, E, A>(
   self: Stream.Stream<R, E, A>
-): Stream.Stream<R, E, readonly [Option.Option<A>, A]> =>
+): Stream.Stream<R, E, [Option.Option<A>, A]> =>
   pipe(
     self,
-    mapAccum<Option.Option<A>, A, readonly [Option.Option<A>, A]>(
+    mapAccum<Option.Option<A>, A, [Option.Option<A>, A]>(
       Option.none(),
       (prev, curr) => [Option.some(curr), [prev, curr]]
     )
@@ -7964,10 +7990,10 @@ export const zipWithPrevious = <R, E, A>(
 /** @internal */
 export const zipWithPreviousAndNext = <R, E, A>(
   self: Stream.Stream<R, E, A>
-): Stream.Stream<R, E, readonly [Option.Option<A>, A, Option.Option<A>]> =>
+): Stream.Stream<R, E, [Option.Option<A>, A, Option.Option<A>]> =>
   pipe(
     zipWithNext(zipWithPrevious(self)),
-    map(([[prev, curr], next]) => [prev, curr, pipe(next, Option.map((tuple) => tuple[1]))] as const)
+    map(([[prev, curr], next]) => [prev, curr, pipe(next, Option.map((tuple) => tuple[1]))])
   )
 
 /** @internal */
@@ -7975,17 +8001,17 @@ const zipChunks = <A, B, C>(
   left: Chunk.Chunk<A>,
   right: Chunk.Chunk<B>,
   f: (a: A, b: B) => C
-): readonly [Chunk.Chunk<C>, Either.Either<Chunk.Chunk<A>, Chunk.Chunk<B>>] => {
+): [Chunk.Chunk<C>, Either.Either<Chunk.Chunk<A>, Chunk.Chunk<B>>] => {
   if (left.length > right.length) {
     return [
       pipe(left, Chunk.take(right.length), Chunk.zipWith(right, f)),
       Either.left(pipe(left, Chunk.drop(right.length)))
-    ] as const
+    ]
   }
   return [
     pipe(left, Chunk.zipWith(pipe(right, Chunk.take(left.length)), f)),
     Either.right(pipe(right, Chunk.drop(left.length)))
-  ] as const
+  ]
 }
 
 // Do notation
@@ -7999,8 +8025,8 @@ export const bind = dual<
     tag: Exclude<N, keyof K>,
     f: (_: K) => Stream.Stream<R2, E2, A>,
     options?: {
-      readonly concurrency?: number | "unbounded"
-      readonly bufferSize?: number
+      readonly concurrency?: number | "unbounded" | undefined
+      readonly bufferSize?: number | undefined
     }
   ) => <R, E>(self: Stream.Stream<R, E, K>) => Stream.Stream<
     R | R2,
@@ -8012,8 +8038,8 @@ export const bind = dual<
     tag: Exclude<N, keyof K>,
     f: (_: K) => Stream.Stream<R2, E2, A>,
     options?: {
-      readonly concurrency?: number | "unbounded"
-      readonly bufferSize?: number
+      readonly concurrency?: number | "unbounded" | undefined
+      readonly bufferSize?: number | undefined
     }
   ) => Stream.Stream<
     R | R2,
@@ -8025,8 +8051,8 @@ export const bind = dual<
   tag: Exclude<N, keyof K>,
   f: (_: K) => Stream.Stream<R2, E2, A>,
   options?: {
-    readonly concurrency?: number | "unbounded"
-    readonly bufferSize?: number
+    readonly concurrency?: number | "unbounded" | undefined
+    readonly bufferSize?: number | undefined
   }
 ) =>
   flatMap(self, (k) =>