@fncts/io 0.0.12 → 0.0.15

package/Stream/api.d.ts

@@ -1,29 +1,27 @@
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 import { Sink } from "@fncts/io/Sink/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
-import { Maybe, Nothing } from "@fncts/base/data/Maybe";
+import { Maybe, Nothing } from "@fncts/base/data/Maybe/definition";
 import { Channel } from "@fncts/io/Channel";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Cause } from "@fncts/base/data/Cause";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import { IO, UIO } from "@fncts/io/IO/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
-import { Lazy } from "@fncts/base/data/function";
-import { Exit } from "@fncts/base/data/Exit";
-import { Has } from "@fncts/base/typeclass/Has";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Hub } from "@fncts/io/Hub/definition";
 import { Future } from "@fncts/io/Future";
 import { Ref } from "@fncts/io/Ref";
-import { Environment } from "@fncts/base/data/Environment";
-import { Duration } from "@fncts/base/data/Duration";
-import { HashMap } from "@fncts/base/collection/immutable/HashMap";
-import { Predicate } from "@fncts/base/data/Predicate";
-import { Refinement } from "@fncts/base/data/Refinement";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Layer } from "@fncts/io/Layer";
 import type { PHub } from "../Hub.js";
 import type { Canceler } from "../IO.js";
 import type { PQueue } from "../Queue.js";
-import type { Erase } from "@fncts/typelevel/Intersection.js";
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 import { Queue } from "../Queue.js";
 import { Stream } from "./definition.js";
@@ -33,7 +31,7 @@ import { Take } from "./internal/Take.js";
  * @tsplus getter fncts.io.Stream absolve
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function absolve<R, E, E2, A>(self: Stream<R, E, Either<E2, A>>): Stream<R, E | E2, A>;
+export declare function absolve<R, E, E2, A>(self: Stream<R, E, Either<E2, A>>, __tsplusTrace?: string): Stream<R, E | E2, A>;
 /**
  * Aggregates elements of this stream using the provided sink for as long
  * as the downstream operators on the stream are busy.
@@ -48,13 +46,13 @@ export declare function absolve<R, E, E2, A>(self: Stream<R, E, Either<E2, A>>):
  * @tsplus fluent fncts.io.Stream aggregateAsync
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function aggregateAsync_<R, E, A extends A1, R1, E1, A1, B>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>): Stream<R & R1, E | E1, B>;
+export declare function aggregateAsync_<R, E, A extends A1, R1, E1, A1, B>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Like `aggregateAsyncWithinEither`, but only returns the `Right` results.
  * @tsplus fluent fncts.io.Stream aggregateAsyncWithin
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function aggregateAsyncWithin_<R, E, A extends A1, R1, E1, A1, B, R2, C>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>): Stream<R & R1 & R2, E | E1, B>;
+export declare function aggregateAsyncWithin_<R, E, A extends A1, R1, E1, A1, B, R2, C>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): Stream<R | R1 | R2, E | E1, B>;
 /**
  * Aggregates elements using the provided sink until it completes, or until the
  * delay signalled by the schedule has passed.
@@ -69,7 +67,7 @@ export declare function aggregateAsyncWithin_<R, E, A extends A1, R1, E1, A1, B,
  * @tsplus fluent fncts.io.Stream aggregateAsyncWithinEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function aggregateAsyncWithinEither_<R, E, A extends A1, R1, E1, A1, B, R2, C>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>): Stream<R & R1 & R2, E | E1, Either<C, B>>;
+export declare function aggregateAsyncWithinEither_<R, E, A extends A1, R1, E1, A1, B, R2, C>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): Stream<R | R1 | R2, E | E1, Either<C, B>>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from this stream.
@@ -77,7 +75,7 @@ export declare function aggregateAsyncWithinEither_<R, E, A extends A1, R1, E1,
  * @tsplus fluent fncts.io.Stream apFirst
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function apFirst_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>): Stream<R & R1, E | E1, A>;
+export declare function apFirst_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from the other stream.
@@ -85,18 +83,18 @@ export declare function apFirst_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, t
  * @tsplus fluent fncts.io.Stream apSecond
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function apSecond_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>): Stream<R & R1, E | E1, A1>;
+export declare function apSecond_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E | E1, A1>;
 /**
  * Maps the success values of this stream to the specified constant value.
  * @tsplus fluent fncts.io.Stream as
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function as_<R, E, A, B>(stream: Stream<R, E, A>, b: Lazy<B>): Stream<R, E, B>;
+export declare function as_<R, E, A, B>(stream: Stream<R, E, A>, b: Lazy<B>, __tsplusTrace?: string): Stream<R, E, B>;
 /**
  * @tsplus static fncts.io.StreamOps asyncInterrupt
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function asyncInterrupt<R, E, A>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => Either<Canceler<R>, Stream<R, E, A>>, outputBuffer?: number): Stream<R, E, A>;
+export declare function asyncInterrupt<R, E, A>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => Either<Canceler<R>, Stream<R, E, A>>, outputBuffer?: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Creates a stream from an asynchronous callback that can be called multiple times.
  * The registration of the callback can possibly return the stream synchronously.
@@ -105,36 +103,36 @@ export declare function asyncInterrupt<R, E, A>(register: (resolve: (next: IO<R,
  * @tsplus static fncts.io.StreamOps asyncMaybe
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function asyncMaybe<R, E, A>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => Maybe<Stream<R, E, A>>, outputBuffer?: number): Stream<R, E, A>;
+export declare function asyncMaybe<R, E, A>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => Maybe<Stream<R, E, A>>, outputBuffer?: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * @tsplus static fncts.io.StreamOps async
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function async<R, E, A>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => void, outputBuffer?: number): Stream<R, E, A>;
+export declare function async<R, E, A>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => void, outputBuffer?: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * @tsplus static fncts.io.StreamOps asyncIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function asyncIO<R, E, A, R1 = R, E1 = E>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => IO<R1, E1, unknown>, outputBuffer?: number): Stream<R & R1, E | E1, A>;
+export declare function asyncIO<R, E, A, R1 = R, E1 = E>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => IO<R1, E1, unknown>, outputBuffer?: number, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * Returns a stream whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
  */
-export declare function bimap_<R, E, E1, A, A1>(stream: Stream<R, E, A>, f: (e: E) => E1, g: (a: A) => A1): Stream<R, E1, A1>;
+export declare function bimap_<R, E, E1, A, A1>(stream: Stream<R, E, A>, f: (e: E) => E1, g: (a: A) => A1, __tsplusTrace?: string): Stream<R, E1, A1>;
 /**
  * Creates a stream from a single value that will get cleaned up after the
  * stream is consumed
  * @tsplus static fncts.io.StreamOps acquireRelease
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function acquireRelease_<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A) => IO<R1, never, unknown>): Stream<R & R1, E, A>;
+export declare function acquireRelease_<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A) => IO<R1, never, unknown>, __tsplusTrace?: string): Stream<R | R1, E, A>;
 /**
  * Creates a stream from a single value that will get cleaned up after the
  * stream is consumed
  * @tsplus static fncts.io.StreamOps acquireReleaseExit
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function acquireReleaseExit_<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A, exit: Exit<any, any>) => IO<R1, never, unknown>): Stream<R & R1, E, A>;
+export declare function acquireReleaseExit_<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A, exit: Exit<any, any>) => IO<R1, never, unknown>, __tsplusTrace?: string): Stream<R | R1, E, A>;
 /**
  * Fan out the stream, producing a list of streams that have the same elements as this stream.
  * The driver stream will only ever advance of the `maximumLag` chunks before the
@@ -142,7 +140,7 @@ export declare function acquireReleaseExit_<R, E, A, R1>(acquire: IO<R, E, A>, r
  * @tsplus fluent fncts.io.Stream broadcast
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcast_<R, E, A>(stream: Stream<R, E, A>, n: number, maximumLag: number): IO<R & Has<Scope>, never, Conc<Stream<unknown, E, A>>>;
+export declare function broadcast_<R, E, A>(stream: Stream<R, E, A>, n: number, maximumLag: number, __tsplusTrace?: string): IO<R | Scope, never, Conc<Stream<unknown, E, A>>>;
 /**
  * Fan out the stream, producing a dynamic number of streams that have the same elements as this stream.
  * The driver stream will only ever advance of the `maximumLag` chunks before the
@@ -150,7 +148,7 @@ export declare function broadcast_<R, E, A>(stream: Stream<R, E, A>, n: number,
  * @tsplus fluent fncts.io.Stream broadcastDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastDynamic_<R, E, A>(stream: Stream<R, E, A>, maximumLag: number): IO<R & Has<Scope>, never, Stream<unknown, E, A>>;
+export declare function broadcastDynamic_<R, E, A>(stream: Stream<R, E, A>, maximumLag: number, __tsplusTrace?: string): IO<R | Scope, never, Stream<unknown, E, A>>;
 /**
  * Converts the stream to a managed list of queues. Every value will be replicated to every queue with the
  * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
@@ -159,7 +157,7 @@ export declare function broadcastDynamic_<R, E, A>(stream: Stream<R, E, A>, maxi
  * @tsplus fluent fncts.io.Stream broadcastedQueues
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueues_<R, E, A>(stream: Stream<R, E, A>, n: number, maximumLag: number): IO<R & Has<Scope>, never, Conc<Hub.Dequeue<unknown, never, Take<E, A>>>>;
+export declare function broadcastedQueues_<R, E, A>(stream: Stream<R, E, A>, n: number, maximumLag: number, __tsplusTrace?: string): IO<R | Scope, never, Conc<Hub.Dequeue<unknown, never, Take<E, A>>>>;
 /**
  * Converts the stream to a managed dynamic amount of queues. Every chunk will be replicated to every queue with the
  * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
@@ -168,33 +166,33 @@ export declare function broadcastedQueues_<R, E, A>(stream: Stream<R, E, A>, n:
  * @tsplus fluent fncts.io.Stream broadcastedQueuesDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueuesDynamic_<R, E, A>(stream: Stream<R, E, A>, maximumLag: number): IO<R & Has<Scope>, never, IO<Has<Scope>, never, Hub.Dequeue<unknown, never, Take<E, A>>>>;
+export declare function broadcastedQueuesDynamic_<R, E, A>(stream: Stream<R, E, A>, maximumLag: number, __tsplusTrace?: string): IO<R | Scope, never, IO<Scope, never, Hub.Dequeue<never, never, Take<E, A>>>>;
 /**
  * Allows a faster producer to progress independently of a slower consumer by buffering
  * up to `capacity` elements in a queue.
  * @tsplus fluent fncts.io.Stream buffer
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function buffer_<R, E, A>(stream: Stream<R, E, A>, capacity: number): Stream<R, E, A>;
+export declare function buffer_<R, E, A>(stream: Stream<R, E, A>, capacity: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * @tsplus fluent fncts.io.Stream bufferChunks
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function bufferChunks_<R, E, A>(stream: Stream<R, E, A>, capacity: number): Stream<R, E, A>;
+export declare function bufferChunks_<R, E, A>(stream: Stream<R, E, A>, capacity: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Allows a faster producer to progress independently of a slower consumer by buffering
  * elements into an unbounded queue.
  * @tsplus getter fncts.io.Stream bufferUnbounded
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function bufferUnbounded<R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A>;
+export declare function bufferUnbounded<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails with a typed error.
  * @tsplus fluent fncts.io.Stream catchAll
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchAll_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, f: (e: E) => Stream<R1, E1, A1>): Stream<R & R1, E1, A | A1>;
+export declare function catchAll_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, f: (e: E) => Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E1, A | A1>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails. Allows recovery from all causes of failure, including interruption if the
@@ -202,14 +200,14 @@ export declare function catchAll_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>,
  * @tsplus fluent fncts.io.Stream catchAllCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchAllCause_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, f: (cause: Cause<E>) => Stream<R1, E1, A1>): Stream<R & R1, E1, A | A1>;
+export declare function catchAllCause_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, f: (cause: Cause<E>) => Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E1, A | A1>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails with some typed error.
  * @tsplus fluent fncts.io.Stream catchJust
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchJust_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, pf: (e: E) => Maybe<Stream<R1, E1, A1>>): Stream<R & R1, E | E1, A | A1>;
+export declare function catchJust_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, pf: (e: E) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | A1>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails with some errors. Allows recovery from all causes of failure, including interruption if the
@@ -217,20 +215,27 @@ export declare function catchJust_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>,
  * @tsplus fluent fncts.io.Stream catchJustCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchJustCause_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, pf: (e: Cause<E>) => Maybe<Stream<R1, E1, A1>>): Stream<R & R1, E | E1, A | A1>;
+export declare function catchJustCause_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, pf: (e: Cause<E>) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | A1>;
 /**
  * Returns a stream made of the concatenation in strict order of all the streams
  * produced by passing each element of this stream to `f`
  * @tsplus fluent fncts.io.Stream flatMap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function flatMap_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => Stream<R1, E1, B>): Stream<R & R1, E | E1, B>;
+export declare function flatMap_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Exposes the underlying chunks of the stream as a stream of chunks of elements
  * @tsplus getter fncts.io.Stream chunks
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function chunks<R, E, A>(stream: Stream<R, E, A>): Stream<R, E, Conc<A>>;
+export declare function chunks<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, Conc<A>>;
+/**
+ * Performs the specified stream transformation with the chunk structure of
+ * the stream exposed.
+ * @tsplus fluent fncts.io.Stream chunksWith
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function chunksWith<R, E, A, R1, E1, B>(self: Stream<R, E, A>, f: (_: Stream<R, E, Conc<A>>) => Stream<R1, E1, Conc<B>>, __tsplusTrace?: string): Stream<R1, E1, B>;
 /**
  * Returns a new stream that only emits elements that are not equal to the
  * previous element emitted, using the specified function to determine
@@ -238,17 +243,17 @@ export declare function chunks<R, E, A>(stream: Stream<R, E, A>): Stream<R, E, C
  * @tsplus fluent fncts.io.Stream changesWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function changesWith_<R, E, A>(stream: Stream<R, E, A>, f: (x: A, y: A) => boolean): Stream<R, E, A>;
+export declare function changesWith_<R, E, A>(stream: Stream<R, E, A>, f: (x: A, y: A) => boolean, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Transforms all elements of the stream for as long as the specified partial function is defined.
  * @tsplus fluent fncts.io.Stream collectWhile
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function collectWhile_<R, E, A, A1>(stream: Stream<R, E, A>, pf: (a: A) => Maybe<A1>): Stream<R, E, A1>;
+export declare function collectWhile_<R, E, A, A1>(stream: Stream<R, E, A>, pf: (a: A) => Maybe<A1>, __tsplusTrace?: string): Stream<R, E, A1>;
 /**
  * Effectfully transforms all elements of the stream for as long as the specified partial function is defined.
  */
-export declare function collectWhileIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, pf: (a: A) => Maybe<IO<R1, E1, B>>): Stream<R & R1, E | E1, B>;
+export declare function collectWhileIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, pf: (a: A) => Maybe<IO<R1, E1, B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Combines the elements from this stream and the specified stream by repeatedly applying the
  * function `f` to extract an element using both sides and conceptually "offer"
@@ -259,7 +264,7 @@ export declare function collectWhileIO_<R, E, A, R1, E1, B>(stream: Stream<R, E,
  * @tsplus fluent fncts.io.Stream combine
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function combine_<R, E, A, R1, E1, A1, S, R2, A2>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, s: S, f: (s: S, eff1: IO<R, Maybe<E>, A>, eff2: IO<R1, Maybe<E1>, A1>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [A2, S]>>): Stream<R & R1 & R2, E | E1, A2>;
+export declare function combine_<R, E, A, R1, E1, A1, S, R2, A2>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, s: S, f: (s: S, eff1: IO<R, Maybe<E>, A>, eff2: IO<R1, Maybe<E1>, A1>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [A2, S]>>, __tsplusTrace?: string): Stream<R | R1 | R2, E | E1, A2>;
 /**
  * Combines the chunks from this stream and the specified stream by repeatedly applying the
  * function `f` to extract a chunk using both sides and conceptually "offer"
@@ -268,21 +273,21 @@ export declare function combine_<R, E, A, R1, E1, A1, S, R2, A2>(stream: Stream<
  * @tsplus fluent fncts.io.Stream combineChunks
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function combineChunks_<R, E, A, R1, E1, A1, S, R2, A2>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, s: S, f: (s: S, l: IO<R, Maybe<E>, Conc<A>>, r: IO<R1, Maybe<E1>, Conc<A1>>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [Conc<A2>, S]>>): Stream<R1 & R & R2, E | E1, A2>;
+export declare function combineChunks_<R, E, A, R1, E1, A1, S, R2, A2>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, s: S, f: (s: S, l: IO<R, Maybe<E>, Conc<A>>, r: IO<R1, Maybe<E1>, Conc<A1>>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [Conc<A2>, S]>>, __tsplusTrace?: string): Stream<R1 | R | R2, E | E1, A2>;
 /**
  * Concatenates the specified stream with this stream, resulting in a stream
  * that emits the elements from this stream and then the elements from the specified stream.
  * @tsplus fluent fncts.io.Stream concat
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function concat_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>): Stream<R & R1, E | E1, A | A1>;
+export declare function concat_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | A1>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements.
  * The `that` stream would be run multiple times, for every element in the `this` stream.
  * @tsplus fluent fncts.io.Stream cross
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function cross_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, that: Stream<R1, E1, B>): Stream<R & R1, E | E1, readonly [A, B]>;
+export declare function cross_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, that: Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, readonly [A, B]>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements
  * with a specified function.
@@ -290,25 +295,25 @@ export declare function cross_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, that
  * @tsplus fluent fncts.io.Stream crossWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function crossWith_<R, E, A, R1, E1, B, C>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, f: (a: A, b: B) => C): Stream<R & R1, E | E1, C>;
+export declare function crossWith_<R, E, A, R1, E1, B, C>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): Stream<R | R1, E | E1, C>;
 /**
  * Provides some of the environment required to run this effect,
  * leaving the remainder `R0`.
  * @tsplus fluent fncts.io.Stream contramapEnvironment
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function contramapEnvironment_<R, E, A, R0>(ra: Stream<R, E, A>, f: (r0: Environment<R0>) => Environment<R>): Stream<R0, E, A>;
+export declare function contramapEnvironment_<R, E, A, R0>(ra: Stream<R, E, A>, f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): Stream<R0, E, A>;
 /**
  * @tsplus fluent fncts.io.Stream debounce
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function debounce_<R, E, A>(stream: Stream<R, E, A>, duration: Lazy<Duration>): Stream<R, E, A>;
+export declare function debounce_<R, E, A>(stream: Stream<R, E, A>, duration: Lazy<Duration>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Switches to the provided stream in case this one is empty.
  * @tsplus fluent fncts.io.Stream defaultIfEmpty
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function defaultIfEmpty_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>): Stream<R & R1, E | E1, A | B>;
+export declare function defaultIfEmpty_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | B>;
 /**
  * More powerful version of `broadcast`. Allows to provide a function that determines what
  * queues should receive which elements. The decide function will receive the indices of the queues
@@ -316,7 +321,7 @@ export declare function defaultIfEmpty_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>,
  * @tsplus fluent fncts.io.Stream distributedWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWith_<R, E, A>(self: Stream<R, E, A>, n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>): IO<R & Has<Scope>, never, Conc<Queue.Dequeue<Exit<Maybe<E>, A>>>>;
+export declare function distributedWith_<R, E, A>(self: Stream<R, E, A>, n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>, __tsplusTrace?: string): IO<R | Scope, never, Conc<Queue.Dequeue<Exit<Maybe<E>, A>>>>;
 /**
  * More powerful version of `ZStream#distributedWith`. This returns a function that will produce
  * new queues and corresponding indices.
@@ -327,34 +332,34 @@ export declare function distributedWith_<R, E, A>(self: Stream<R, E, A>, n: numb
  * @tsplus fluent fncts.io.Stream distributedWithDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWithDynamic_<R, E, A>(self: Stream<R, E, A>, maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>): IO<R & Has<Scope>, never, UIO<readonly [symbol, Queue.Dequeue<Exit<Maybe<E>, A>>]>>;
+export declare function distributedWithDynamic_<R, E, A>(self: Stream<R, E, A>, maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>, __tsplusTrace?: string): IO<R | Scope, never, UIO<readonly [symbol, Queue.Dequeue<Exit<Maybe<E>, A>>]>>;
 /**
  * Converts this stream to a stream that executes its effects but emits no
  * elements. Useful for sequencing effects using streams.
  * @tsplus getter fncts.io.Stream drain
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function drain<R, E, A>(fa: Stream<R, E, A>): Stream<R, E, void>;
+export declare function drain<R, E, A>(fa: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, void>;
 /**
  * Drops the specified number of elements from this stream.
  * @tsplus fluent fncts.io.Stream drop
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function drop_<R, E, A>(stream: Stream<R, E, A>, n: number): Stream<R, E, A>;
+export declare function drop_<R, E, A>(stream: Stream<R, E, A>, n: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Drops all elements of the stream for as long as the specified predicate
  * evaluates to `true`.
  * @tsplus fluent fncts.io.Stream dropWhile
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function dropWhile_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>): Stream<R, E, A>;
+export declare function dropWhile_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Drops all elements of the stream until the specified predicate evaluates
  * to `true`.
  * @tsplus fluent fncts.io.Stream dropUntil
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function dropUntil_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>): Stream<R, E, A>;
+export declare function dropUntil_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Returns a stream whose failures and successes have been lifted into an
  * `Either`. The resulting stream cannot fail, because the failures have
@@ -363,12 +368,12 @@ export declare function dropUntil_<R, E, A>(stream: Stream<R, E, A>, p: Predicat
  * @tsplus getter fncts.io.Stream either
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function either<R, E, A>(stream: Stream<R, E, A>): Stream<R, never, Either<E, A>>;
+export declare function either<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, never, Either<E, A>>;
 /**
  * @tsplus static fncts.io.StreamOps empty
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare const empty: Stream<unknown, never, never>;
+export declare const empty: Stream<never, never, never>;
 /**
  * Halts the evaluation of this stream when the provided IO completes. The given IO
  * will be forked as part of the returned stream, and its success will be discarded.
@@ -380,59 +385,59 @@ export declare const empty: Stream<unknown, never, never>;
  * @tsplus fluent fncts.io.Stream endWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function endWhen_<R, E, A, R1, E1>(stream: Stream<R, E, A>, io: IO<R1, E1, any>): Stream<R & R1, E | E1, A>;
+export declare function endWhen_<R, E, A, R1, E1>(stream: Stream<R, E, A>, io: IO<R1, E1, any>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.io.Stream ensuring
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function ensuring_<R, E, A, R1>(self: Stream<R, E, A>, finalizer: IO<R1, never, any>): Stream<R & R1, E, A>;
+export declare function ensuring_<R, E, A, R1>(self: Stream<R, E, A>, finalizer: IO<R1, never, any>, __tsplusTrace?: string): Stream<R | R1, E, A>;
 /**
  * @tsplus static fncts.io.StreamOps environment
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function environment<R>(): Stream<R, never, Environment<R>>;
+export declare function environment<R>(__tsplusTrace?: string): Stream<R, never, Environment<R>>;
 /**
  * Accesses the environment of the stream.
  * @tsplus static fncts.io.StreamOps environmentWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function environmentWith<R, A>(f: (r: Environment<R>) => A): Stream<R, never, A>;
+export declare function environmentWith<R, A>(f: (r: Environment<R>) => A, __tsplusTrace?: string): Stream<R, never, A>;
 /**
  * Accesses the environment of the stream in the context of an effect.
  * @tsplus static fncts.io.StreamOps environmentWithIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function environmentWithIO<R0, R, E, A>(f: (r0: Environment<R0>) => IO<R, E, A>): Stream<R0 & R, E, A>;
+export declare function environmentWithIO<R0, R, E, A>(f: (r0: Environment<R0>) => IO<R, E, A>, __tsplusTrace?: string): Stream<R0 | R, E, A>;
 /**
  * Accesses the environment of the stream in the context of a stream.
  * @tsplus static fncts.io.StreamOps environmentWithStream
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function environmentWithStream<R0, R, E, A>(f: (r0: Environment<R0>) => Stream<R, E, A>): Stream<R0 & R, E, A>;
+export declare function environmentWithStream<R0, R, E, A>(f: (r0: Environment<R0>) => Stream<R, E, A>, __tsplusTrace?: string): Stream<R0 | R, E, A>;
 /**
  * Halt a stream with the specified error
  * @tsplus static fncts.io.StreamOps failNow
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function failNow<E>(error: E): Stream<unknown, E, never>;
+export declare function failNow<E>(error: E, __tsplusTrace?: string): Stream<never, E, never>;
 /**
  * Halt a stream with the specified error
  * @tsplus static fncts.io.StreamOps fail
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fail<E>(error: Lazy<E>): Stream<unknown, E, never>;
+export declare function fail<E>(error: Lazy<E>, __tsplusTrace?: string): Stream<never, E, never>;
 /**
  * The stream that always halts with `cause`.
  * @tsplus static fncts.io.StreamOps failCauseNow
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function failCauseNow<E>(cause: Cause<E>): Stream<unknown, E, never>;
+export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Stream<never, E, never>;
 /**
  * The stream that always halts with `cause`.
  * @tsplus static fncts.io.StreamOps failCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function failCause<E>(cause: Lazy<Cause<E>>): Stream<unknown, E, never>;
+export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Stream<never, E, never>;
 /**
  * @tsplus fluent fncts.io.Stream filter
  * @tsplus location "@fncts/io/Stream/api"
@@ -443,36 +448,36 @@ export declare function filter_<R, E, A>(fa: Stream<R, E, A>, predicate: Predica
  * @tsplus fluent fncts.io.Stream filterIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function filterIO_<R, E, A, R1, E1>(fa: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>): Stream<R & R1, E | E1, A>;
+export declare function filterIO_<R, E, A, R1, E1>(fa: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.io.Stream filterMap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function filterMap_<R, E, A, B>(fa: Stream<R, E, A>, f: (a: A) => Maybe<B>): Stream<R, E, B>;
+export declare function filterMap_<R, E, A, B>(fa: Stream<R, E, A>, f: (a: A) => Maybe<B>, __tsplusTrace?: string): Stream<R, E, B>;
 /**
  * @tsplus fluent fncts.io.Stream filterMapIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function filterMapIO_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Maybe<B>>): Stream<R & R1, E | E1, B>;
+export declare function filterMapIO_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Maybe<B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Finds the first element emitted by this stream that satisfies the provided predicate.
  * @tsplus fluent fncts.io.Stream find
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function find_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>): Stream<R, E, A>;
+export declare function find_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Finds the first element emitted by this stream that satisfies the provided effectful predicate.
  * @tsplus fluent fncts.io.Stream findIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function findIO_<R, E, A, R1, E1>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>): Stream<R & R1, E | E1, A>;
+export declare function findIO_<R, E, A, R1, E1>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * Flattens this stream-of-streams into a stream made of the concatenation in
  * strict order of all the streams.
  * @tsplus getter fncts.io.Stream flatten
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function flatten<R, E, R1, E1, A>(self: Stream<R, E, Stream<R1, E1, A>>): Stream<R & R1, E | E1, A>;
+export declare function flatten<R, E, R1, E1, A>(self: Stream<R, E, Stream<R1, E1, A>>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
  *
@@ -480,99 +485,99 @@ export declare function flatten<R, E, R1, E1, A>(self: Stream<R, E, Stream<R1, E
  * @tsplus getter fncts.io.Stream flattenExitOption
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function flattenExitOption<R, E, E1, A>(stream: Stream<R, E, Exit<Maybe<E1>, A>>): Stream<R, E | E1, A>;
+export declare function flattenExitOption<R, E, E1, A>(stream: Stream<R, E, Exit<Maybe<E1>, A>>, __tsplusTrace?: string): Stream<R, E | E1, A>;
 /**
  * Unwraps `Exit` values and flatten chunks that also signify end-of-stream by failing with `None`.
  * @tsplus getter fncts.io.Stream flattenTake
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function flattenTake<R, E, E1, A>(stream: Stream<R, E, Take<E1, A>>): Stream<R, E | E1, A>;
+export declare function flattenTake<R, E, E1, A>(stream: Stream<R, E, Take<E1, A>>, __tsplusTrace?: string): Stream<R, E | E1, A>;
 /**
  * Submerges the chunks carried by this stream into the stream's structure, while
  * still preserving them.
  * @tsplus getter fncts.io.Stream flattenChunks
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function flattenChunks<R, E, A>(stream: Stream<R, E, Conc<A>>): Stream<R, E, A>;
+export declare function flattenChunks<R, E, A>(stream: Stream<R, E, Conc<A>>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Repeats this stream forever.
  * @tsplus getter fncts.io.Stream forever
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function forever<R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A>;
+export declare function forever<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Creates a stream from a `Chunk` of values
  * @tsplus static fncts.io.StreamOps fromChunkNow
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromChunkNow<O>(c: Conc<O>): Stream<unknown, never, O>;
+export declare function fromChunkNow<O>(c: Conc<O>, __tsplusTrace?: string): Stream<never, never, O>;
 /**
  * Creates a stream from a `Chunk` of values
  * @tsplus static fncts.io.StreamOps fromChunk
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromChunk<O>(c: Lazy<Conc<O>>): Stream<unknown, never, O>;
+export declare function fromChunk<O>(c: Lazy<Conc<O>>, __tsplusTrace?: string): Stream<never, never, O>;
 /**
  * Creates a single-valued stream from a managed resource
  * @tsplus static fncts.io.StreamOps scoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scoped<R, E, A>(stream: IO<R & Has<Scope>, E, A>): Stream<R, E, A>;
+export declare function scoped<R, E, A>(stream: IO<R, E, A>, __tsplusTrace?: string): Stream<Exclude<R, Scope>, E, A>;
 /**
  * Creates a stream from an effect producing a value of type `A`
  * @tsplus static fncts.io.StreamOps fromIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromIO<R, E, A>(fa: IO<R, E, A>): Stream<R, E, A>;
+export declare function fromIO<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Creates a stream from an effect producing a value of type `A` or an empty Stream
  * @tsplus static fncts.io.StreamOps fromIOMaybe
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromIOMaybe<R, E, A>(fa: IO<R, Maybe<E>, A>): Stream<R, E, A>;
+export declare function fromIOMaybe<R, E, A>(fa: IO<R, Maybe<E>, A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * @tsplus static fncts.io.StreamOps fromAsyncIterable
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Stream<unknown, never, A>;
+export declare function fromAsyncIterable<A>(iterable: AsyncIterable<A>, __tsplusTrace?: string): Stream<unknown, never, A>;
 /**
  * @tsplus static fncts.io.StreamOps fromIterable
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromIterable<A>(iterable: Iterable<A>, maxChunkSize?: number): Stream<unknown, never, A>;
+export declare function fromIterable<A>(iterable: Iterable<A>, maxChunkSize?: number, __tsplusTrace?: string): Stream<unknown, never, A>;
 /**
  * @tsplus static fncts.io.StreamOps fromIterableSingle
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromIterableSingle<A>(iterable: Iterable<A>): Stream<unknown, never, A>;
+export declare function fromIterableSingle<A>(iterable: Iterable<A>, __tsplusTrace?: string): Stream<unknown, never, A>;
 /**
  * @tsplus static fncts.io.StreamOps fromPull
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromPull<R, E, A>(scopedPull: IO<R & Has<Scope>, never, IO<R, Maybe<E>, Conc<A>>>): Stream<R, E, A>;
+export declare function fromPull<R, E, A>(scopedPull: IO<R, never, IO<R, Maybe<E>, Conc<A>>>, __tsplusTrace?: string): Stream<Exclude<R, Scope>, E, A>;
 /**
  * Creates a stream from a `Queue` of values
  * @tsplus static fncts.io.StreamOps fromQueue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromQueue_<R, E, O>(queue: PQueue<never, R, unknown, E, never, O>, maxChunkSize?: number): Stream<R, E, O>;
+export declare function fromQueue_<R, E, O>(queue: PQueue<never, R, unknown, E, never, O>, maxChunkSize?: number, __tsplusTrace?: string): Stream<R, E, O>;
 /**
  * @tsplus static fncts.io.StreamOps fromQueueWithShutdown
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromQueueWithShutdown<R, E, A>(queue: PQueue<never, R, unknown, E, never, A>, maxChunkSize?: number): Stream<R, E, A>;
+export declare function fromQueueWithShutdown<R, E, A>(queue: PQueue<never, R, unknown, E, never, A>, maxChunkSize?: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Halt a stream with the specified exception
  * @tsplus static fncts.io.StreamOps haltNow
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function haltNow(u: unknown): Stream<unknown, never, never>;
+export declare function haltNow(u: unknown, __tsplusTrace?: string): Stream<never, never, never>;
 /**
  * Halt a stream with the specified exception
  * @tsplus static fncts.io.StreamOps halt
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function halt(u: Lazy<unknown>): Stream<unknown, never, never>;
+export declare function halt(u: Lazy<unknown>, __tsplusTrace?: string): Stream<never, never, never>;
 /**
  * Halts the evaluation of this stream when the provided IO completes. The
  * given IO will be forked as part of the returned stream, and its success
@@ -585,7 +590,7 @@ export declare function halt(u: Lazy<unknown>): Stream<unknown, never, never>;
  * @tsplus fluent fncts.io.Stream haltWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function haltWhen_<R, E, A, R1, E1>(fa: Stream<R, E, A>, io: IO<R1, E1, any>): Stream<R & R1, E | E1, A>;
+export declare function haltWhen_<R, E, A, R1, E1>(fa: Stream<R, E, A>, io: IO<R1, E1, any>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * Halts the evaluation of this stream when the provided promise resolves.
  *
@@ -593,12 +598,12 @@ export declare function haltWhen_<R, E, A, R1, E1>(fa: Stream<R, E, A>, io: IO<R
  * @tsplus fluent fncts.io.Stream haltWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function haltWhenFuture_<R, E, A, E1>(fa: Stream<R, E, A>, future: Future<E1, any>): Stream<R, E | E1, A>;
+export declare function haltWhenFuture_<R, E, A, E1>(fa: Stream<R, E, A>, future: Future<E1, any>, __tsplusTrace?: string): Stream<R, E | E1, A>;
 /**
  * @tsplus fluent fncts.io.Stream interleave
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interleave_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, sb: Stream<R1, E1, B>): Stream<R & R1, E | E1, A | B>;
+export declare function interleave_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, sb: Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | B>;
 /**
  * Combines this stream and the specified stream deterministically using the
  * stream of boolean values `b` to control which stream to pull from next.
@@ -609,11 +614,11 @@ export declare function interleave_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, sb:
  * @tsplus fluent fncts.io.Stream interleaveWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interleaveWith_<R, E, A, R1, E1, B, R2, E2>(sa: Stream<R, E, A>, sb: Stream<R1, E1, B>, b: Stream<R2, E2, boolean>): Stream<R & R1 & R2, E | E1 | E2, A | B>;
+export declare function interleaveWith_<R, E, A, R1, E1, B, R2, E2>(sa: Stream<R, E, A>, sb: Stream<R1, E1, B>, b: Stream<R2, E2, boolean>, __tsplusTrace?: string): Stream<R | R1 | R2, E | E1 | E2, A | B>;
 /**
  * Intersperse stream with provided element
  */
-export declare function intersperse_<R, E, A, A1>(stream: Stream<R, E, A>, middle: A1): Stream<R, E, A | A1>;
+export declare function intersperse_<R, E, A, A1>(stream: Stream<R, E, A>, middle: A1, __tsplusTrace?: string): Stream<R, E, A | A1>;
 /**
  * Interrupts the evaluation of this stream when the provided IO completes. The given
  * IO will be forked as part of this stream, and its success will be discarded. This
@@ -624,89 +629,89 @@ export declare function intersperse_<R, E, A, A1>(stream: Stream<R, E, A>, middl
  * @tsplus fluent fncts.io.Stream interruptWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interruptWhen_<R, E, A, R1, E1>(stream: Stream<R, E, A>, io: IO<R1, E1, any>): Stream<R & R1, E | E1, A>;
+export declare function interruptWhen_<R, E, A, R1, E1>(stream: Stream<R, E, A>, io: IO<R1, E1, any>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.io.Stream interruptWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interruptWhenFuture_<R, E, A, E1>(fa: Stream<R, E, A>, future: Future<E1, unknown>): Stream<R, E | E1, A>;
+export declare function interruptWhenFuture_<R, E, A, E1>(fa: Stream<R, E, A>, future: Future<E1, unknown>, __tsplusTrace?: string): Stream<R, E | E1, A>;
 /**
  * Transforms the elements of this stream using the supplied function.
  * @tsplus fluent fncts.io.Stream map
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function map_<R, E, A, B>(stream: Stream<R, E, A>, f: (o: A) => B): Stream<R, E, B>;
+export declare function map_<R, E, A, B>(stream: Stream<R, E, A>, f: (o: A) => B, __tsplusTrace?: string): Stream<R, E, B>;
 /**
  * Statefully maps over the elements of this stream to produce new elements.
  * @tsplus fluent fncts.io.Stream mapAccum
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapAccum_<R, E, A, S, B>(stream: Stream<R, E, A>, s: S, f: (s: S, a: A) => readonly [S, B]): Stream<R, E, B>;
+export declare function mapAccum_<R, E, A, S, B>(stream: Stream<R, E, A>, s: S, f: (s: S, a: A) => readonly [S, B], __tsplusTrace?: string): Stream<R, E, B>;
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
  * new elements.
  * @tsplus fluent fncts.io.Stream mapAccumIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapAccumIO_<R, E, A, R1, E1, S, B>(stream: Stream<R, E, A>, s: S, f: (s: S, a: A) => IO<R1, E1, readonly [B, S]>): Stream<R & R1, E | E1, B>;
+export declare function mapAccumIO_<R, E, A, R1, E1, S, B>(stream: Stream<R, E, A>, s: S, f: (s: S, a: A) => IO<R1, E1, readonly [B, S]>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Transforms the chunks emitted by this stream.
  * @tsplus fluent fncts.io.Stream mapChunks
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapChunks_<R, E, A, A1>(stream: Stream<R, E, A>, f: (chunk: Conc<A>) => Conc<A1>): Stream<R, E, A1>;
+export declare function mapChunks_<R, E, A, A1>(stream: Stream<R, E, A>, f: (chunk: Conc<A>) => Conc<A1>, __tsplusTrace?: string): Stream<R, E, A1>;
 /**
  * Effectfully transforms the chunks emitted by this stream.
  * @tsplus fluent fncts.io.Stream mapChunksIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapChunksIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (chunk: Conc<A>) => IO<R1, E1, Conc<B>>): Stream<R & R1, E | E1, B>;
+export declare function mapChunksIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (chunk: Conc<A>) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Maps each element to an iterable, and flattens the iterables into the
  * output of this stream.
  * @tsplus fluent fncts.io.Stream mapConcat
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcat_<R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => Iterable<B>): Stream<R, E, B>;
+export declare function mapConcat_<R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => Iterable<B>, __tsplusTrace?: string): Stream<R, E, B>;
 /**
  * Maps each element to a chunk, and flattens the chunks into the output of
  * this stream.
  * @tsplus fluent fncts.io.Stream mapConcatChunk
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcatChunk_<R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => Conc<B>): Stream<R, E, B>;
+export declare function mapConcatChunk_<R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => Conc<B>, __tsplusTrace?: string): Stream<R, E, B>;
 /**
  * Effectfully maps each element to a chunk, and flattens the chunks into
  * the output of this stream.
  * @tsplus fluent fncts.io.Stream mapConcatChunkIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcatChunkIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Conc<B>>): Stream<R & R1, E | E1, B>;
+export declare function mapConcatChunkIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Effectfully maps each element to an iterable, and flattens the iterables into
  * the output of this stream.
  * @tsplus fluent fncts.io.Stream mapConcatIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcatIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Iterable<B>>): Stream<R & R1, E | E1, B>;
+export declare function mapConcatIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Iterable<B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Transforms the errors emitted by this stream using `f`.
  * @tsplus fluent fncts.io.Stream mapError
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapError_<R, E, E1, A>(stream: Stream<R, E, A>, f: (e: E) => E1): Stream<R, E1, A>;
+export declare function mapError_<R, E, E1, A>(stream: Stream<R, E, A>, f: (e: E) => E1, __tsplusTrace?: string): Stream<R, E1, A>;
 /**
  * Transforms the full causes of failures emitted by this stream.
  * @tsplus fluent fncts.io.Stream mapErrorCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapErrorCause_<R, E, A, E1>(fa: Stream<R, E, A>, f: (e: Cause<E>) => Cause<E1>): Stream<R, E1, A>;
+export declare function mapErrorCause_<R, E, A, E1>(fa: Stream<R, E, A>, f: (e: Cause<E>) => Cause<E1>, __tsplusTrace?: string): Stream<R, E1, A>;
 /**
  * Maps over elements of the stream with the specified effectful function.
  * @tsplus fluent fncts.io.Stream mapIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, B>): Stream<R & R1, E | E1, B>;
+export declare function mapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Maps over elements of the stream with the specified effectful function,
  * executing up to `n` invocations of `f` concurrently. Transformed elements
@@ -715,7 +720,7 @@ export declare function mapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (
  * @tsplus fluent fncts.io.Stream mapIOC
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapIOC_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, n: number, f: (a: A) => IO<R1, E1, B>): Stream<R & R1, E | E1, B>;
+export declare function mapIOC_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Maps each element of this stream to another stream and returns the
  * non-deterministic merge of those streams, executing up to `n` inner streams
@@ -724,7 +729,7 @@ export declare function mapIOC_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, n:
  * @tsplus fluent fncts.io.Stream mergeMap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeMap_<R, E, A, R1, E1, B>(ma: Stream<R, E, A>, f: (a: A) => Stream<R1, E1, B>, n: number, bufferSize?: number): Stream<R & R1, E | E1, B>;
+export declare function mergeMap_<R, E, A, R1, E1, B>(ma: Stream<R, E, A>, f: (a: A) => Stream<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Maps over elements of the stream with the specified effectful function,
  * executing up to `n` invocations of `f` concurrently. The element order
@@ -732,19 +737,19 @@ export declare function mergeMap_<R, E, A, R1, E1, B>(ma: Stream<R, E, A>, f: (a
  * @tsplus fluent fncts.io.Stream mergeMapIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeMapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, B>, n: number, bufferSize?: number): Stream<R & R1, E | E1, B>;
+export declare function mergeMapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.io.Stream mergeEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeEither_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>): Stream<R & R1, E | E1, Either<A, B>>;
-export declare function mergeWithHandler<R, E>(terminate: boolean): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown>;
+export declare function mergeEither_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, Either<A, B>>;
+export declare function mergeWithHandler<R, E>(terminate: boolean, __tsplusTrace?: string): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown>;
 export declare type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
 /**
  * @tsplus fluent fncts.io.Stream mergeWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeWith_<R, E, A, R1, E1, A1, B, C>(sa: Stream<R, E, A>, sb: Stream<R1, E1, A1>, l: (a: A) => B, r: (b: A1) => C, strategy?: TerminationStrategy): Stream<R & R1, E | E1, B | C>;
+export declare function mergeWith_<R, E, A, R1, E1, A1, B, C>(sa: Stream<R, E, A>, sb: Stream<R1, E1, A1>, l: (a: A) => B, r: (b: A1) => C, strategy?: TerminationStrategy, __tsplusTrace?: string): Stream<R | R1, E | E1, B | C>;
 /**
  * Runs the specified effect if this stream fails, providing the error to the effect if it exists.
  *
@@ -752,7 +757,7 @@ export declare function mergeWith_<R, E, A, R1, E1, A1, B, C>(sa: Stream<R, E, A
  * @tsplus fluent fncts.io.Stream onError
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function onError_<R, E, A, R1>(stream: Stream<R, E, A>, cleanup: (e: Cause<E>) => IO<R1, never, any>): Stream<R & R1, E, A>;
+export declare function onError_<R, E, A, R1>(stream: Stream<R, E, A>, cleanup: (e: Cause<E>) => IO<R1, never, any>, __tsplusTrace?: string): Stream<R | R1, E, A>;
 /**
  * Switches to the provided stream in case this one fails with a typed error.
  *
@@ -760,7 +765,7 @@ export declare function onError_<R, E, A, R1>(stream: Stream<R, E, A>, cleanup:
  * @tsplus fluent fncts.io.Stream orElse
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElse_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, that: Lazy<Stream<R1, E1, A1>>): Stream<R & R1, E1, A | A1>;
+export declare function orElse_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): Stream<R | R1, E1, A | A1>;
 /**
  * Switches to the provided stream in case this one fails with a typed error.
  *
@@ -768,7 +773,7 @@ export declare function orElse_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, th
  * @tsplus fluent fncts.io.Stream orElseEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElseEither_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, that: Lazy<Stream<R1, E1, A1>>): Stream<R & R1, E1, Either<A, A1>>;
+export declare function orElseEither_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): Stream<R | R1, E1, Either<A, A1>>;
 /**
  * Fails with given error in case this one fails with a typed error.
  *
@@ -776,31 +781,31 @@ export declare function orElseEither_<R, E, A, R1, E1, A1>(stream: Stream<R, E,
  * @tsplus fluent fncts.io.Stream orElseFail
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElseFail_<R, E, A, E1>(stream: Stream<R, E, A>, e: Lazy<E1>): Stream<R, E1, A>;
+export declare function orElseFail_<R, E, A, E1>(stream: Stream<R, E, A>, e: Lazy<E1>, __tsplusTrace?: string): Stream<R, E1, A>;
 /**
  * Switches to the provided stream in case this one fails with the `None` value.
  *
  * See also Stream#catchAll.
  */
-export declare function orElseOptional_<R, E, A, R1, E1, A1>(stream: Stream<R, Maybe<E>, A>, that: Lazy<Stream<R1, Maybe<E1>, A1>>): Stream<R & R1, Maybe<E | E1>, A | A1>;
+export declare function orElseOptional_<R, E, A, R1, E1, A1>(stream: Stream<R, Maybe<E>, A>, that: Lazy<Stream<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): Stream<R | R1, Maybe<E | E1>, A | A1>;
 /**
  * Succeeds with the specified value if this one fails with a typed error.
  * @tsplus fluent fncts.io.Stream orElseSucceed
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElseSucceed_<R, E, A, A1>(stream: Stream<R, E, A>, a: Lazy<A1>): Stream<R, never, A | A1>;
+export declare function orElseSucceed_<R, E, A, A1>(stream: Stream<R, E, A>, a: Lazy<A1>, __tsplusTrace?: string): Stream<R, never, A | A1>;
 /**
  * @tsplus fluent fncts.io.Stream pipeThrough
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function pipeThrough_<R, E, A, R1, E1, L, Z>(ma: Stream<R, E, A>, sa: Sink<R1, E1, A, L, Z>): Stream<R & R1, E | E1, L>;
+export declare function pipeThrough_<R, E, A, R1, E1, L, Z>(ma: Stream<R, E, A>, sa: Sink<R1, E1, A, L, Z>, __tsplusTrace?: string): Stream<R | R1, E | E1, L>;
 /**
  * Provides the stream with its required environment, which eliminates
  * its dependency on `R`.
  * @tsplus fluent fncts.io.Stream provideEnvironment
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function provideEnvironment_<R, E, A>(ra: Stream<R, E, A>, r: Environment<R>): Stream<unknown, E, A>;
+export declare function provideEnvironment_<R, E, A>(ra: Stream<R, E, A>, r: Environment<R>, __tsplusTrace?: string): Stream<never, E, A>;
 /**
  * @tsplus fluent fncts.io.Stream provideLayer
  * @tsplus location "@fncts/io/Stream/api"
@@ -810,7 +815,7 @@ export declare function provideLayer_<RIn, E, ROut, E1, A>(self: Stream<ROut, E,
  * @tsplus fluent fncts.io.Stream provideSomeLayer
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function provideSomeLayer_<R, E, A, RIn, E1, ROut>(self: Stream<R, E, A>, layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): Stream<RIn & Erase<R, ROut>, E | E1, A>;
+export declare function provideSomeLayer_<R, E, A, RIn, E1, ROut>(self: Stream<R, E, A>, layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): Stream<RIn | Exclude<R, ROut>, E | E1, A>;
 /**
  * Re-chunks the elements of the stream into chunks of
  * `n` elements each.
@@ -818,150 +823,150 @@ export declare function provideSomeLayer_<R, E, A, RIn, E1, ROut>(self: Stream<R
  * @tsplus fluent fncts.io.Stream rechunk
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function rechunk_<R, E, A>(stream: Stream<R, E, A>, n: number): Stream<R, E, A>;
+export declare function rechunk_<R, E, A>(stream: Stream<R, E, A>, n: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Repeats the provided value infinitely.
  * @tsplus static fncts.io.StreamOps repeatValue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function repeatValue<A>(a: A): Stream<unknown, never, A>;
+export declare function repeatValue<A>(a: A, __tsplusTrace?: string): Stream<unknown, never, A>;
 /**
  * Creates a stream from an effect producing a value of type `A` which repeats forever.
  * @tsplus static fncts.io.StreamOps repeatIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function repeatIO<R, E, A>(fa: IO<R, E, A>): Stream<R, E, A>;
+export declare function repeatIO<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Creates a stream from an effect producing values of type `A` until it fails with None.
  * @tsplus static fncts.io.StreamOps repeatIOMaybe
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function repeatIOMaybe<R, E, A>(fa: IO<R, Maybe<E>, A>): Stream<R, E, A>;
+export declare function repeatIOMaybe<R, E, A>(fa: IO<R, Maybe<E>, A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Creates a stream from an effect producing chunks of `A` values which repeats forever.
  * @tsplus static fncts.io.StreamOps repeatIOChunk
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function repeatIOChunk<R, E, A>(fa: IO<R, E, Conc<A>>): Stream<R, E, A>;
+export declare function repeatIOChunk<R, E, A>(fa: IO<R, E, Conc<A>>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Creates a stream from an effect producing chunks of `A` values until it fails with None.
  * @tsplus static fncts.io.StreamOps repeatIOChunkMaybe
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function repeatIOChunkMaybe<R, E, A>(fa: IO<R, Maybe<E>, Conc<A>>): Stream<R, E, A>;
+export declare function repeatIOChunkMaybe<R, E, A>(fa: IO<R, Maybe<E>, Conc<A>>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
  * @tsplus fluent fncts.io.Stream run
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function run_<R, E, A, R2, E2, Z>(stream: Stream<R, E, A>, sink: Sink<R2, E2, A, unknown, Z>): IO<R & R2, E | E2, Z>;
+export declare function run_<R, E, A, R2, E2, Z>(stream: Stream<R, E, A>, sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): IO<R | R2, E | E2, Z>;
 /**
  * Runs the stream and collects all of its elements to a chunk.
  * @tsplus getter fncts.io.Stream runCollect
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runCollect<R, E, A>(stream: Stream<R, E, A>): IO<R, E, Conc<A>>;
+export declare function runCollect<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): IO<R, E, Conc<A>>;
 /**
  * Runs the stream and collects ignore its elements.
  * @tsplus getter fncts.io.Stream runDrain
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runDrain<R, E, A>(stream: Stream<R, E, A>): IO<R, E, void>;
+export declare function runDrain<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * @tsplus fluent fncts.io.Stream runForeachScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runForeachScoped_<R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: A) => IO<R2, E2, any>): IO<R & R2 & Has<Scope>, E | E2, void>;
+export declare function runForeachScoped_<R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R | R2 | Scope, E | E2, void>;
 /**
  * Like `into`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus fluent fncts.io.Stream runIntoElementsScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoElementsScoped_<R, E, A, R1, E1>(stream: Stream<R, E, A>, queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>): IO<R & R1 & Has<Scope>, E | E1, void>;
+export declare function runIntoElementsScoped_<R, E, A, R1, E1>(stream: Stream<R, E, A>, queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>, __tsplusTrace?: string): IO<R | R1 | Scope, E | E1, void>;
 /**
  * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus fluent fncts.io.Stream runIntoQueueScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoQueueScoped_<R, R1, E extends E1, E1, A>(stream: Stream<R, E, A>, queue: PQueue<R1, never, never, unknown, Take<E1, A>, any>): IO<R & R1 & Has<Scope>, E | E1, void>;
+export declare function runIntoQueueScoped_<R, R1, E extends E1, E1, A>(stream: Stream<R, E, A>, queue: PQueue<R1, never, never, unknown, Take<E1, A>, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E | E1, void>;
 /**
  * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus fluent fncts.io.Stream runIntoHubScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoHubScoped_<R, R1, E extends E1, E1, A>(stream: Stream<R, E, A>, hub: PHub<R1, never, never, unknown, Take<E1, A>, any>): IO<R & R1 & Has<Scope>, E | E1, void>;
+export declare function runIntoHubScoped_<R, R1, E extends E1, E1, A>(stream: Stream<R, E, A>, hub: PHub<R1, never, never, unknown, Take<E1, A>, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E | E1, void>;
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
  * @tsplus fluent fncts.io.Stream runScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runScoped_<R, E, A, R2, E2, Z>(stream: Stream<R, E, A>, sink: Sink<R2, E2, A, unknown, Z>): IO<R & R2 & Has<Scope>, E | E2, Z>;
+export declare function runScoped_<R, E, A, R2, E2, Z>(stream: Stream<R, E, A>, sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): IO<R | R2 | Scope, E | E2, Z>;
 /**
  * Statefully maps over the elements of this stream to produce all intermediate results
  * of type `B` given an initial B.
  * @tsplus fluent fncts.io.Stream scan
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scan_<R, E, A, B>(sa: Stream<R, E, A>, b: B, f: (b: B, a: A) => B): Stream<R, E, B>;
+export declare function scan_<R, E, A, B>(sa: Stream<R, E, A>, b: B, f: (b: B, a: A) => B, __tsplusTrace?: string): Stream<R, E, B>;
 /**
  * Statefully and effectfully maps over the elements of this stream to produce all
  * intermediate results of type `B` given an initial B.
  * @tsplus fluent fncts.io.Stream scanIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scanIO_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, b: B, f: (b: B, a: A) => IO<R1, E1, B>): Stream<R & R1, E | E1, B>;
+export declare function scanIO_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, b: B, f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Statefully maps over the elements of this stream to produce all
  * intermediate results.
  * @tsplus fluent fncts.io.Stream scanReduce
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scanReduce_<R, E, A extends B, B>(fa: Stream<R, E, A>, f: (b: B, a: A) => B): Stream<R, E, B>;
+export declare function scanReduce_<R, E, A extends B, B>(fa: Stream<R, E, A>, f: (b: B, a: A) => B, __tsplusTrace?: string): Stream<R, E, B>;
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
  * all intermediate results.
  * @tsplus fluent fncts.io.Stream scanReduceIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scanReduceIO_<R, E, A extends B, R1, E1, B>(fa: Stream<R, E, A>, f: (b: B, a: A) => IO<R1, E1, B>): Stream<R & R1, E | E1, B>;
+export declare function scanReduceIO_<R, E, A extends B, R1, E1, B>(fa: Stream<R, E, A>, f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Creates a single-valued pure stream
  * @tsplus static fncts.io.StreamOps succeedNow
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function succeedNow<O>(o: O): Stream<unknown, never, O>;
+export declare function succeedNow<O>(o: O, __tsplusTrace?: string): Stream<never, never, O>;
 /**
  * Creates a single-valued pure stream
  * @tsplus static fncts.io.StreamOps succeed
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function succeed<A>(a: Lazy<A>): Stream<unknown, never, A>;
+export declare function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Stream<never, never, A>;
 /**
  * Takes the specified number of elements from this stream.
  * @tsplus fluent fncts.io.Stream take
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function take_<R, E, A>(stream: Stream<R, E, A>, n: number): Stream<R, E, A>;
+export declare function take_<R, E, A>(stream: Stream<R, E, A>, n: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * @tsplus fluent fncts.io.Stream takeUntilIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function takeUntilIO_<R, E, A, R1, E1>(ma: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>): Stream<R & R1, E | E1, A>;
+export declare function takeUntilIO_<R, E, A, R1, E1>(ma: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * Takes all elements of the stream until the specified predicate evaluates
  * to `true`.
  * @tsplus fluent fncts.io.Stream takeUntil
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function takeUntil_<R, E, A>(fa: Stream<R, E, A>, p: Predicate<A>): Stream<R, E, A>;
+export declare function takeUntil_<R, E, A>(fa: Stream<R, E, A>, p: Predicate<A>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * @tsplus fluent fncts.io.Stream tap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function tap_<R, E, A, R1, E1>(ma: Stream<R, E, A>, f: (a: A) => IO<R1, E1, any>): Stream<R & R1, E | E1, A>;
+export declare function tap_<R, E, A, R1, E1>(ma: Stream<R, E, A>, f: (a: A) => IO<R1, E1, any>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * Throttles the chunks of this stream according to the given bandwidth parameters using the token bucket
  * algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate
@@ -970,7 +975,7 @@ export declare function tap_<R, E, A, R1, E1>(ma: Stream<R, E, A>, f: (a: A) =>
  * @tsplus fluent fncts.io.Stream throttleEnforce
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function throttleEnforce_<R, E, A>(sa: Stream<R, E, A>, costFn: (chunk: Conc<A>) => number, units: number, duration: number, burst?: number): Stream<R, E, A>;
+export declare function throttleEnforce_<R, E, A>(sa: Stream<R, E, A>, costFn: (chunk: Conc<A>) => number, units: number, duration: number, burst?: number, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Throttles the chunks of this stream according to the given bandwidth parameters using the token bucket
  * algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate
@@ -979,88 +984,88 @@ export declare function throttleEnforce_<R, E, A>(sa: Stream<R, E, A>, costFn: (
  * @tsplus fluent fncts.io.Stream throttleEnforceIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function throttleEnforceIO_<R, E, A, R1, E1>(sa: Stream<R, E, A>, costFn: (chunk: Conc<A>) => IO<R1, E1, number>, units: number, duration: number, burst?: number): Stream<R & R1, E | E1, A>;
+export declare function throttleEnforceIO_<R, E, A, R1, E1>(sa: Stream<R, E, A>, costFn: (chunk: Conc<A>) => IO<R1, E1, number>, units: number, duration: number, burst?: number, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * Converts the stream to a managed hub of chunks. After the managed hub is used,
  * the hub will never again produce values and should be discarded.
  * @tsplus fluent fncts.io.Stream toHub
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toHub_<R, E, A>(stream: Stream<R, E, A>, capacity: number): IO<R & Has<Scope>, never, Hub<Take<E, A>>>;
+export declare function toHub_<R, E, A>(stream: Stream<R, E, A>, capacity: number, __tsplusTrace?: string): IO<R | Scope, never, Hub<Take<E, A>>>;
 /**
  * Interpret the stream as a managed pull
  * @tsplus getter fncts.io.Stream toPull
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toPull<R, E, A>(stream: Stream<R, E, A>): IO<R & Has<Scope>, never, IO<R, Maybe<E>, Conc<A>>>;
+export declare function toPull<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): IO<R | Scope, never, IO<R, Maybe<E>, Conc<A>>>;
 /**
  * Converts the stream to a managed queue of chunks. After the managed queue is used,
  * the queue will never again produce values and should be discarded.
  * @tsplus fluent fncts.io.Stream toQueue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueue_<R, E, A>(stream: Stream<R, E, A>, capacity?: number): IO<R & Has<Scope>, never, Queue<Take<E, A>>>;
+export declare function toQueue_<R, E, A>(stream: Stream<R, E, A>, capacity?: number, __tsplusTrace?: string): IO<R | Scope, never, Queue<Take<E, A>>>;
 /**
  * @tsplus fluent fncts.io.Stream toQueueDropping
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueDropping_<R, E, A>(stream: Stream<R, E, A>, capacity?: number): IO<R & Has<Scope>, never, Queue.Dequeue<Take<E, A>>>;
+export declare function toQueueDropping_<R, E, A>(stream: Stream<R, E, A>, capacity?: number, __tsplusTrace?: string): IO<R | Scope, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * @tsplus fluent fncts.io.Stream toQueueOfElements
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueOfElements_<R, E, A>(stream: Stream<R, E, A>, capacity?: number): IO<R & Has<Scope>, never, Queue.Dequeue<Exit<Maybe<E>, A>>>;
+export declare function toQueueOfElements_<R, E, A>(stream: Stream<R, E, A>, capacity?: number, __tsplusTrace?: string): IO<R | Scope, never, Queue.Dequeue<Exit<Maybe<E>, A>>>;
 /**
  * @tsplus fluent fncts.io.Stream toQueueSliding
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueSliding_<R, E, A>(stream: Stream<R, E, A>, capacity?: number): IO<R & Has<Scope>, never, Queue.Dequeue<Take<E, A>>>;
+export declare function toQueueSliding_<R, E, A>(stream: Stream<R, E, A>, capacity?: number, __tsplusTrace?: string): IO<R | Scope, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * Converts the stream into an unbounded managed queue. After the managed queue
  * is used, the queue will never again produce values and should be discarded.
  * @tsplus getter fncts.io.Stream toQueueUnbounded
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueUnbounded<R, E, A>(stream: Stream<R, E, A>): IO<R & Has<Scope>, never, Queue<Take<E, A>>>;
+export declare function toQueueUnbounded<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): IO<R | Scope, never, Queue<Take<E, A>>>;
 /**
  * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
  * @tsplus static fncts.io.StreamOps unfoldChunkIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function unfoldChunkIO<R, E, A, S>(s: S, f: (s: S) => IO<R, E, Maybe<readonly [Conc<A>, S]>>): Stream<R, E, A>;
+export declare function unfoldChunkIO<R, E, A, S>(s: S, f: (s: S) => IO<R, E, Maybe<readonly [Conc<A>, S]>>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
  * @tsplus static fncts.io.StreamOps unfoldIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function unfoldIO<S, R, E, A>(s: S, f: (s: S) => IO<R, E, Maybe<readonly [A, S]>>): Stream<R, E, A>;
+export declare function unfoldIO<S, R, E, A>(s: S, f: (s: S) => IO<R, E, Maybe<readonly [A, S]>>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * @tsplus static fncts.io.StreamOps unfoldChunk
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function unfoldChunk<S, A>(s: S, f: (s: S) => Maybe<readonly [Conc<A>, S]>): Stream<unknown, never, A>;
+export declare function unfoldChunk<S, A>(s: S, f: (s: S) => Maybe<readonly [Conc<A>, S]>, __tsplusTrace?: string): Stream<never, never, A>;
 /**
  * @tsplus static fncts.io.StreamOps unfold
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function unfold<S, A>(s: S, f: (s: S) => Maybe<readonly [A, S]>): Stream<unknown, never, A>;
+export declare function unfold<S, A>(s: S, f: (s: S) => Maybe<readonly [A, S]>, __tsplusTrace?: string): Stream<never, never, A>;
 /**
  * Creates a stream produced from an IO
  * @tsplus static fncts.io.StreamOps unwrap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function unwrap<R, E, R1, E1, A>(stream: IO<R, E, Stream<R1, E1, A>>): Stream<R & R1, E | E1, A>;
+export declare function unwrap<R, E, R1, E1, A>(stream: IO<R, E, Stream<R1, E1, A>>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
 /**
  * Creates a stream produced from a managed
  * @tsplus static fncts.io.StreamOps unwrapScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function unwrapScoped<R0, E0, R, E, A>(stream: IO<R0 & Has<Scope>, E0, Stream<R, E, A>>): Stream<R0 & R, E0 | E, A>;
+export declare function unwrapScoped<R0, E0, R, E, A>(stream: IO<R0, E0, Stream<R, E, A>>, __tsplusTrace?: string): Stream<R | Exclude<R0, Scope>, E0 | E, A>;
 /**
  * @tsplus getter fncts.io.Stream zipWithIndex
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function zipWithIndex_<R, E, A>(self: Stream<R, E, A>, __tsPlusTrace?: string): Stream<R, E, readonly [A, number]>;
+export declare function zipWithIndex_<R, E, A>(self: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, readonly [A, number]>;
 /**
  * Zips the two streams so that when a value is emitted by either of the two
  * streams, it is combined with the latest value from the other stream to
@@ -1072,4 +1077,4 @@ export declare function zipWithIndex_<R, E, A>(self: Stream<R, E, A>, __tsPlusTr
  * @tsplus fluent fncts.io.Stream zipWithLatest
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function zipWithLatest_<R, E, A, R1, E1, B, C>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, f: (a: A, b: B) => C): Stream<R & R1, E | E1, C>;
+export declare function zipWithLatest_<R, E, A, R1, E1, B, C>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): Stream<R | R1, E | E1, C>;