@fncts/io 0.0.48 → 0.0.49

package/Stream/api.d.ts

@@ -1,14 +1,14 @@
 import { Either } from "@fncts/base/data/Either/definition";
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Sink } from "@fncts/io/Sink/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
 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/definition";
-import { IO, UIO } from "@fncts/io/IO/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
-import { Exit } from "@fncts/base/data/Exit/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Future } from "@fncts/io/Future";
 import { Ref } from "@fncts/io/Ref/definition";
@@ -31,6 +31,20 @@ import { Take } from "./internal/Take.js";
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function absolve<R, E, E2, A>(self: Stream<R, E, Either<E2, A>>, __tsplusTrace?: string): Stream<R, E | E2, A>;
+/**
+ * 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>, __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>, __tsplusTrace?: string): Stream<R | R1, E, A>;
 /**
  * Aggregates elements of this stream using the provided sink for as long
  * as the downstream operators on the stream are busy.
@@ -68,32 +82,26 @@ export declare function aggregateAsyncWithin<R1, E1, A1, B, R2, C>(sink: Sink<R1
  */
 export declare function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => 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.
- * The `that` stream would be run multiple times, for every element in the `this` stream.
- * @tsplus pipeable fncts.io.Stream zipLeft
+ * Maps the success values of this stream to the specified constant value.
+ * @tsplus pipeable fncts.io.Stream as
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
+export declare function as<B>(b: Lazy<B>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, B>;
 /**
- * Composes this stream with the specified stream to create a cartesian product of elements,
- * but keeps only elements from the other stream.
- * The `that` stream would be run multiple times, for every element in the `this` stream.
- * @tsplus pipeable fncts.io.Stream zipRight
+ * @tsplus static fncts.io.StreamOps async
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function zipRight<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A1>;
+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>;
 /**
- * Maps the success values of this stream to the specified constant value.
- * @tsplus pipeable fncts.io.Stream as
+ * @tsplus static fncts.io.StreamOps asyncInterrupt
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function as<B>(b: Lazy<B>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, B>;
+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>;
 /**
- * @tsplus static fncts.io.StreamOps asyncInterrupt
+ * @tsplus static fncts.io.StreamOps asyncIO
  * @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, __tsplusTrace?: string): Stream<R, E, 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>;
 /**
  * Creates a stream from an asynchronous callback that can be called multiple times.
  * The registration of the callback can possibly return the stream synchronously.
@@ -103,16 +111,6 @@ export declare function asyncInterrupt<R, E, A>(register: (resolve: (next: IO<R,
  * @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, __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, __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, __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`.
@@ -120,20 +118,6 @@ export declare function asyncIO<R, E, A, R1 = R, E1 = E>(register: (resolve: (ne
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function bimap<E, E1, A, A1>(f: (e: E) => E1, g: (a: A) => A1, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => 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>, __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>, __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
@@ -218,12 +202,13 @@ export declare function catchJust<R1, E, E1, A1>(pf: (e: E) => Maybe<Stream<R1,
  */
 export declare function catchJustCause<R1, E, E1, A1>(pf: (e: Cause<E>) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => 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 pipeable fncts.io.Stream flatMap
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using the specified function to determine
+ * whether two elements are equal.
+ * @tsplus pipeable fncts.io.Stream changesWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function flatMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
+export declare function changesWith<A>(f: (x: A, y: A) => boolean, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Exposes the underlying chunks of the stream as a stream of chunks of elements
  * @tsplus getter fncts.io.Stream chunks
@@ -237,14 +222,6 @@ export declare function chunks<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?:
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function chunksWith<R, E, A, R1, E1, B>(f: (_: Stream<R, E, Conc<A>>) => Stream<R1, E1, Conc<B>>, __tsplusTrace?: string): (self: Stream<R, E, A>) => 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
- * whether two elements are equal.
- * @tsplus pipeable fncts.io.Stream changesWith
- * @tsplus location "@fncts/io/Stream/api"
- */
-export declare function changesWith<A>(f: (x: A, y: A) => boolean, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Transforms all elements of the stream for as long as the specified partial function is defined.
  * @tsplus pipeable fncts.io.Stream collectWhile
@@ -282,6 +259,13 @@ export declare function combineChunks<R, E, A, R1, E1, A1, S, R2, A2>(that: Stre
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function concat<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A | A1>;
+/**
+ * Provides some of the environment required to run this effect,
+ * leaving the remainder `R0`.
+ * @tsplus pipeable fncts.io.Stream contramapEnvironment
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): <E, A>(ra: Stream<R, E, A>) => Stream<R0, E, A>;
 /**
  * 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.
@@ -297,29 +281,22 @@ export declare function cross<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function crossWith<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, C>;
-/**
- * Provides some of the environment required to run this effect,
- * leaving the remainder `R0`.
- * @tsplus pipeable fncts.io.Stream contramapEnvironment
- * @tsplus location "@fncts/io/Stream/api"
- */
-export declare function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): <E, A>(ra: Stream<R, E, A>) => Stream<R0, E, A>;
 /**
  * @tsplus pipeable fncts.io.Stream debounce
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function debounce(duration: Lazy<Duration>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
-/**
- * @tsplus static fncts.io.StreamOps defer
- * @tsplus location "@fncts/io/Stream/api"
- */
-export declare function defer<R, E, A>(self: Lazy<Stream<R, E, A>>): Stream<R, E, A>;
 /**
  * Switches to the provided stream in case this one is empty.
  * @tsplus pipeable fncts.io.Stream defaultIfEmpty
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function defaultIfEmpty<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, A | B>;
+/**
+ * @tsplus static fncts.io.StreamOps defer
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function defer<R, E, A>(self: Lazy<Stream<R, E, A>>): Stream<R, E, A>;
 /**
  * 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
@@ -352,13 +329,6 @@ export declare function drain<R, E, A>(fa: Stream<R, E, A>, __tsplusTrace?: stri
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function drop(n: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
-/**
- * Drops all elements of the stream for as long as the specified predicate
- * evaluates to `true`.
- * @tsplus pipeable fncts.io.Stream dropWhile
- * @tsplus location "@fncts/io/Stream/api"
- */
-export declare function dropWhile<A>(p: Predicate<A>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Drops all elements of the stream until the specified predicate evaluates
  * to `true`.
@@ -366,6 +336,13 @@ export declare function dropWhile<A>(p: Predicate<A>, __tsplusTrace?: string): <
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function dropUntil<A>(p: Predicate<A>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A>;
+/**
+ * Drops all elements of the stream for as long as the specified predicate
+ * evaluates to `true`.
+ * @tsplus pipeable fncts.io.Stream dropWhile
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function dropWhile<A>(p: Predicate<A>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => 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
@@ -375,11 +352,35 @@ export declare function dropUntil<A>(p: Predicate<A>, __tsplusTrace?: string): <
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function either<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, never, Either<E, A>>;
+/**
+ * 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 pipeable fncts.io.Stream flatMap
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
+/**
+ * Composes this stream with the specified stream to create a cartesian product of elements,
+ * but keeps only elements from this stream.
+ * The `that` stream would be run multiple times, for every element in the `this` stream.
+ * @tsplus pipeable fncts.io.Stream zipLeft
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => 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.
+ * The `that` stream would be run multiple times, for every element in the `this` stream.
+ * @tsplus pipeable fncts.io.Stream zipRight
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function zipRight<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A1>;
 /**
  * @tsplus static fncts.io.StreamOps empty
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare const empty: Stream<never, never, never>;
+export type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
 /**
  * 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.
@@ -428,16 +429,16 @@ export declare function environmentWithStream<R0, R, E, A>(f: (r0: Environment<R
 export declare function execute<R, E>(io: IO<R, E, any>, __tsplusTrace?: string): Stream<R, E, never>;
 /**
  * Halt a stream with the specified error
- * @tsplus static fncts.io.StreamOps failNow
+ * @tsplus static fncts.io.StreamOps fail
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function failNow<E>(error: E, __tsplusTrace?: string): Stream<never, E, never>;
+export declare function fail<E>(error: Lazy<E>, __tsplusTrace?: string): Stream<never, E, never>;
 /**
- * Halt a stream with the specified error
- * @tsplus static fncts.io.StreamOps fail
+ * The stream that always halts with `cause`.
+ * @tsplus static fncts.io.StreamOps failCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fail<E>(error: Lazy<E>, __tsplusTrace?: string): Stream<never, E, never>;
+export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Stream<never, E, never>;
 /**
  * The stream that always halts with `cause`.
  * @tsplus static fncts.io.StreamOps failCauseNow
@@ -445,11 +446,11 @@ export declare function fail<E>(error: Lazy<E>, __tsplusTrace?: string): Stream<
  */
 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
+ * Halt a stream with the specified error
+ * @tsplus static fncts.io.StreamOps failNow
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Stream<never, E, never>;
+export declare function failNow<E>(error: E, __tsplusTrace?: string): Stream<never, E, never>;
 /**
  * @tsplus pipeable fncts.io.Stream filter
  * @tsplus location "@fncts/io/Stream/api"
@@ -490,6 +491,13 @@ export declare function findIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __ts
  * @tsplus location "@fncts/io/Stream/api"
  */
 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>;
+/**
+ * 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>>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
  *
@@ -504,13 +512,6 @@ export declare function flattenExitOption<R, E, E1, A>(stream: Stream<R, E, Exit
  * @tsplus location "@fncts/io/Stream/api"
  */
 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>>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Repeats this stream forever.
  * @tsplus getter fncts.io.Stream forever
@@ -518,11 +519,10 @@ export declare function flattenChunks<R, E, A>(stream: Stream<R, E, Conc<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 static fncts.io.StreamOps fromAsyncIterable
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromChunkNow<O>(c: Conc<O>, __tsplusTrace?: string): Stream<never, never, O>;
+export declare function fromAsyncIterable<A>(iterable: AsyncIterable<A>, __tsplusTrace?: string): Stream<unknown, never, A>;
 /**
  * Creates a stream from a `Chunk` of values
  * @tsplus static fncts.io.StreamOps fromChunk
@@ -530,22 +530,21 @@ export declare function fromChunkNow<O>(c: Conc<O>, __tsplusTrace?: string): Str
  */
 export declare function fromChunk<O>(c: Lazy<Conc<O>>, __tsplusTrace?: string): Stream<never, never, O>;
 /**
- * @tsplus static fncts.io.StreamOps fromReadableStream
+ * Creates a stream from a `Chunk` of values
+ * @tsplus static fncts.io.StreamOps fromChunkNow
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromReadableStream<A, E>(evaluate: Lazy<ReadableStream<A>>, onError: (error: unknown) => E): Stream<never, E, A>;
+export declare function fromChunkNow<O>(c: Conc<O>, __tsplusTrace?: string): Stream<never, never, O>;
 /**
- * Creates a single-valued stream from a managed resource
- * @tsplus static fncts.io.StreamOps scoped
+ * @tsplus static fncts.io.StreamOps fromHub
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scoped<R, E, A>(stream: Lazy<IO<R, E, A>>, __tsplusTrace?: string): Stream<Exclude<R, Scope>, E, A>;
+export declare function fromHub<A>(hub: Lazy<Hub<A>>, maxChunkSize?: number, __tsplusTrace?: string): Stream<never, never, A>;
 /**
- * Emits a sliding window of n elements.
- * @tsplus pipeable fncts.io.Stream sliding
+ * @tsplus static fncts.io.StreamOps fromHubScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function sliding(chunkSize: number, stepSize: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Conc<A>>;
+export declare function fromHubScoped<A>(hub: Lazy<Hub<A>>, maxChunkSize?: number, __tsplusTrace?: string): IO<Scope, never, Stream<never, never, A>>;
 /**
  * Creates a stream from an effect producing a value of type `A`
  * @tsplus static fncts.io.StreamOps fromIO
@@ -558,11 +557,6 @@ export declare function fromIO<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string)
  * @tsplus location "@fncts/io/Stream/api"
  */
 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>, __tsplusTrace?: string): Stream<unknown, never, A>;
 /**
  * @tsplus static fncts.io.StreamOps fromIterable
  * @tsplus location "@fncts/io/Stream/api"
@@ -590,27 +584,22 @@ export declare function fromQueue<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB,
  */
 export declare function fromQueueWithShutdown<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, maxChunkSize?: number, __tsplusTrace?: string): Stream<RB, EB, B>;
 /**
- * @tsplus static fncts.io.StreamOps fromHub
+ * @tsplus static fncts.io.StreamOps fromReadableStream
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromHub<A>(hub: Lazy<Hub<A>>, maxChunkSize?: number, __tsplusTrace?: string): Stream<never, never, A>;
+export declare function fromReadableStream<A, E>(evaluate: Lazy<ReadableStream<A>>, onError: (error: unknown) => E): Stream<never, E, A>;
 /**
- * @tsplus static fncts.io.StreamOps fromHubScoped
+ * Halt a stream with the specified exception
+ * @tsplus static fncts.io.StreamOps halt
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromHubScoped<A>(hub: Lazy<Hub<A>>, maxChunkSize?: number, __tsplusTrace?: string): IO<Scope, never, Stream<never, never, A>>;
+export declare function halt(u: Lazy<unknown>, __tsplusTrace?: string): Stream<never, never, never>;
 /**
  * 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, __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>, __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
@@ -648,10 +637,6 @@ export declare function interleave<R1, E1, B>(sb: Stream<R1, E1, B>, __tsplusTra
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function interleaveWith<R1, E1, B, R2, E2>(sb: Stream<R1, E1, B>, b: Stream<R2, E2, boolean>, __tsplusTrace?: string): <R, E, A>(sa: Stream<R, E, A>) => 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, __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
@@ -668,6 +653,10 @@ export declare function interruptWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function interruptWhenFuture<E1>(future: Future<E1, unknown>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R, E | E1, A>;
+/**
+ * Intersperse stream with provided element
+ */
+export declare function intersperse<R, E, A, A1>(stream: Stream<R, E, A>, middle: A1, __tsplusTrace?: string): Stream<R, E, A | A1>;
 /**
  * Transforms the elements of this stream using the supplied function.
  * @tsplus pipeable fncts.io.Stream map
@@ -768,6 +757,11 @@ export declare function mapIOConcurrentlyUnordered<A, R1, E1, B>(n: number, f: (
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function merge<R1, E1, B>(that: Stream<R1, E1, B>, strategy?: TerminationStrategy, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A | B>;
+/**
+ * @tsplus pipeable fncts.io.Stream mergeEither
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, Either<A, B>>;
 /**
  * Merges this stream and the specified stream together. New produced stream
  * will terminate when either stream terminates.
@@ -796,13 +790,6 @@ export declare function mergeHaltRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsp
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function mergeLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
-/**
- * Merges this stream and the specified stream together, discarding the values
- * from the left stream.
- * @tsplus pipeable fncts.io.Stream mergeRight
- * @tsplus location "@fncts/io/Stream/api"
- */
-export declare function mergeRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => 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
@@ -821,11 +808,12 @@ export declare function mergeMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, n
  */
 export declare function mergeMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
- * @tsplus pipeable fncts.io.Stream mergeEither
+ * Merges this stream and the specified stream together, discarding the values
+ * from the left stream.
+ * @tsplus pipeable fncts.io.Stream mergeRight
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, Either<A, B>>;
-export type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
+export declare function mergeRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Stream mergeWith
  * @tsplus location "@fncts/io/Stream/api"
@@ -910,24 +898,12 @@ export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, RO
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function rechunk(n: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => 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, __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>, __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>, __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
@@ -940,6 +916,18 @@ export declare function repeatIOChunk<R, E, A>(fa: IO<R, E, Conc<A>>, __tsplusTr
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function repeatIOChunkMaybe<R, E, A>(fa: IO<R, Maybe<E>, Conc<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>, __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, __tsplusTrace?: string): Stream<unknown, never, A>;
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
  * @tsplus pipeable fncts.io.Stream run
@@ -971,12 +959,12 @@ export declare function runForeachScoped<A, R2, E2>(f: (a: A) => IO<R2, E2, any>
  */
 export declare function runIntoElementsScoped_<E, A, R1, E1>(queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => IO<R | R1 | Scope, E | E1, void>;
 /**
- * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
+ * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
- * @tsplus pipeable fncts.io.Stream runIntoQueueScoped
+ * @tsplus pipeable fncts.io.Stream runIntoHubScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => IO<R | RA | Scope, E | EA | E1, void>;
+export declare function runIntoHubScoped<RA, RB, EA, EB, E1, A, B>(hub: PHub<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => IO<R | RA | Scope, E | EA | E1, void>;
 /**
  * Like runIntoQueue, but provides the result as a scoped IO
  * to allow for scope composition.
@@ -985,12 +973,12 @@ export declare function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(queue: PEnq
  */
 export declare function runIntoQueueElementsScoped<E, A>(queue: Lazy<Queue.Enqueue<Exit<Maybe<E>, A>>>): <R>(self: Stream<R, E, A>) => IO<R | Scope, never, void>;
 /**
- * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
+ * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
  * composition.
- * @tsplus pipeable fncts.io.Stream runIntoHubScoped
+ * @tsplus pipeable fncts.io.Stream runIntoQueueScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoHubScoped<RA, RB, EA, EB, E1, A, B>(hub: PHub<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => IO<R | RA | Scope, E | EA | E1, void>;
+export declare function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => IO<R | RA | Scope, E | EA | E1, void>;
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
  * @tsplus pipeable fncts.io.Stream runScoped
@@ -1025,6 +1013,18 @@ export declare function scanReduce<A extends B, B>(f: (b: B, a: A) => B, __tsplu
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function scanReduceIO<A extends B, R1, E1, B>(f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
+/**
+ * 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: Lazy<IO<R, E, A>>, __tsplusTrace?: string): Stream<Exclude<R, Scope>, E, A>;
+/**
+ * Emits a sliding window of n elements.
+ * @tsplus pipeable fncts.io.Stream sliding
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function sliding(chunkSize: number, stepSize: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Conc<A>>;
 /**
  * @tsplus pipeable fncts.io.Stream split
  * @tsplus location "@fncts/io/Stream/api"
@@ -1032,27 +1032,22 @@ export declare function scanReduceIO<A extends B, R1, E1, B>(f: (b: B, a: A) =>
 export declare function split<A>(predicate: Predicate<A>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Conc<A>>;
 /**
  * Creates a single-valued pure stream
- * @tsplus static fncts.io.StreamOps succeedNow
+ * @tsplus static fncts.io.StreamOps succeed
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function succeedNow<O>(o: O, __tsplusTrace?: string): Stream<never, never, O>;
+export declare function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Stream<never, never, A>;
 /**
  * Creates a single-valued pure stream
- * @tsplus static fncts.io.StreamOps succeed
+ * @tsplus static fncts.io.StreamOps succeedNow
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Stream<never, never, A>;
+export declare function succeedNow<O>(o: O, __tsplusTrace?: string): Stream<never, never, O>;
 /**
  * Takes the specified number of elements from this stream.
  * @tsplus pipeable fncts.io.Stream take
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function take(n: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
-/**
- * @tsplus pipeable fncts.io.Stream takeUntilIO
- * @tsplus location "@fncts/io/Stream/api"
- */
-export declare function takeUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Takes all elements of the stream until the specified predicate evaluates
  * to `true`.
@@ -1060,6 +1055,11 @@ export declare function takeUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>,
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function takeUntil<A>(p: Predicate<A>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, A>;
+/**
+ * @tsplus pipeable fncts.io.Stream takeUntilIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function takeUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Stream tap
  * @tsplus location "@fncts/io/Stream/api"
@@ -1158,27 +1158,27 @@ export declare function toQueueUnbounded<R, E, A>(stream: Stream<R, E, A>, __tsp
  */
 export declare function toReadableStream<E, A>(self: Stream<never, E, A>, __tsplusTrace?: string): ReadableStream<A>;
 /**
- * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
- * @tsplus static fncts.io.StreamOps unfoldChunkIO
+ * @tsplus static fncts.io.StreamOps unfold
  * @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]>>, __tsplusTrace?: string): Stream<R, E, 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 by effectfully peeling off the "layers" of a value of type `S`
- * @tsplus static fncts.io.StreamOps unfoldIO
+ * @tsplus static fncts.io.StreamOps unfoldChunk
  * @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]>>, __tsplusTrace?: string): Stream<R, E, 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 unfoldChunk
+ * 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 unfoldChunk<S, A>(s: S, f: (s: S) => Maybe<readonly [Conc<A>, S]>, __tsplusTrace?: string): Stream<never, never, 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>;
 /**
- * @tsplus static fncts.io.StreamOps unfold
+ * 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 unfold<S, A>(s: S, f: (s: S) => Maybe<readonly [A, S]>, __tsplusTrace?: string): Stream<never, never, 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>;
 /**
  * Creates a stream produced from an IO
  * @tsplus static fncts.io.StreamOps unwrap