effect 4.0.0-beta.69 → 4.0.0-beta.70

package/dist/Stream.d.ts

@@ -84,6 +84,8 @@ export declare const TypeId: TypeId;
  * A `Stream<A, E, R>` describes a program that can emit many `A` values, fail
  * with `E`, and require `R`.
  *
+ * **Details**
+ *
  * Streams are pull-based with backpressure and emit chunks to amortize effect
  * evaluation. They support monadic composition and error handling similar to
  * `Effect`, adapted for multiple values.
@@ -158,6 +160,8 @@ export interface StreamTypeLambda extends TypeLambda {
 /**
  * Type-level variance marker for `Stream`.
  *
+ * **Details**
+ *
  * The emitted value `A`, error `E`, and service requirement `R` type
  * parameters are covariant.
  *
@@ -171,6 +175,8 @@ export interface Variance<out A, out E, out R> {
  * Structural encoding used by `Variance` to record each `Stream` type
  * parameter's variance.
  *
+ * **Details**
+ *
  * `_A`, `_E`, and `_R` are covariant markers.
  *
  * @category models
@@ -504,6 +510,8 @@ export declare const tick: (interval: Duration.Input) => Stream<void>;
 /**
  * Creates a stream from a pull effect, such as one produced by `Stream.toPull`.
  *
+ * **Details**
+ *
  * A pull effect yields chunks on demand and completes when the upstream stream ends.
  * See `Stream.toPull` for a matching producer.
  *
@@ -558,6 +566,8 @@ export declare const transformPull: <A, E, R, B, E2, R2, EX, RX>(self: Stream<A,
 /**
  * Transforms a stream by effectfully transforming its pull effect.
  *
+ * **Details**
+ *
  * A forked scope is also provided to the transformation function, which is
  * closed once the resulting stream has finished processing.
  *
@@ -617,6 +627,8 @@ export declare const toChannel: <A, E, R>(stream: Stream<A, E, R>) => Channel.Ch
 /**
  * Creates a stream from a callback that can emit values into a queue.
  *
+ * **When to use**
+ *
  * You can use the `Queue` with the apis from the `Queue` module to emit
  * values to the stream or to signal the stream ending.
  *
@@ -723,6 +735,8 @@ export declare const make: <const As extends ReadonlyArray<any>>(...values: As)
 /**
  * Creates a stream that synchronously evaluates a function and emits the result as a single value.
  *
+ * **Details**
+ *
  * The function is evaluated each time the stream is run.
  *
  * **Example** (Evaluating a value synchronously)
@@ -746,6 +760,8 @@ export declare const sync: <A>(evaluate: LazyArg<A>) => Stream<A>;
 /**
  * Creates a lazily constructed stream.
  *
+ * **Details**
+ *
  * The stream factory is evaluated each time the stream is run.
  *
  * **Example** (Creating a lazily constructed stream)
@@ -898,6 +914,8 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => St
 /**
  * Creates a stream that consumes values from an iterator.
  *
+ * **Details**
+ *
  * The `maxChunkSize` parameter controls how many values are pulled per chunk.
  *
  * **Example** (Consuming values from an iterator)
@@ -929,7 +947,7 @@ export declare const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, max
 /**
  * Creates a new `Stream` from an iterable collection of values.
  *
- * **Options**
+ * **Details**
  *
  * - `chunkSize`: Maximum number of values emitted per chunk.
  *
@@ -1085,6 +1103,8 @@ export declare const fromArrays: <Arr extends ReadonlyArray<ReadonlyArray<any>>>
 /**
  * Creates a stream that pulls values from a `Queue.Dequeue`.
  *
+ * **Details**
+ *
  * The stream emits non-empty batches of queued values and ends when the queue
  * fails with `Cause.Done`; other queue failures are propagated.
  *
@@ -1149,6 +1169,8 @@ export declare const fromPubSub: <A>(pubsub: PubSub.PubSub<A>) => Stream<A>;
 /**
  * Creates a stream from a PubSub of `Take` values.
  *
+ * **Details**
+ *
  * `Take` values include end and failure signals.
  *
  * **Example** (Creating a stream from PubSub takes)
@@ -1180,6 +1202,8 @@ export declare const fromPubSubTake: <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E
 /**
  * Creates a stream from a lazily supplied Web `ReadableStream`.
  *
+ * **Details**
+ *
  * The stream reads from a `ReadableStreamDefaultReader`, maps read failures
  * with `onError`, and closes the reader when the stream finalizes. By default
  * the reader is canceled; set `releaseLockOnEnd` to release the lock instead.
@@ -1279,6 +1303,8 @@ export declare const fromSchedule: <O, E, R>(schedule: Schedule.Schedule<O, unkn
 /**
  * Creates a stream from a PubSub subscription.
  *
+ * **When to use**
+ *
  * Use `PubSub.subscribe` to create the subscription and `Stream.take` or
  * cancellation to control how many values are consumed.
  *
@@ -1367,6 +1393,8 @@ export declare const fromEventListener: <A = unknown>(target: EventListener<A>,
  * Creates a stream by repeatedly applying an effectful step function to a
  * state.
  *
+ * **Details**
+ *
  * Each `readonly [value, nextState]` result emits `value` and continues with
  * `nextState`; returning `undefined` ends the stream.
  *
@@ -1441,6 +1469,8 @@ export declare const iterate: <A>(value: A, next: (value: A) => A) => Stream<A>;
 /**
  * Constructs a stream from a range of integers, including both endpoints.
  *
+ * **Details**
+ *
  * If the provided `min` is greater than `max`, the stream will not emit any
  * values.
  *
@@ -1457,6 +1487,7 @@ export declare const iterate: <A>(value: A, next: (value: A) => A) => Stream<A>;
  * Effect.runPromise(program)
  * // Output: [ 1, 2, 3, 4, 5 ]
  * ```
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -2023,6 +2054,8 @@ export declare const mapArrayEffect: {
 /**
  * Lifts failures and successes into a `Result`, yielding a stream that cannot fail.
  *
+ * **Details**
+ *
  * The stream ends after the first failure, emitting a `Result.fail` value.
  *
  * **Example** (Converting failures to results)
@@ -2366,6 +2399,8 @@ export declare const tapSink: {
 /**
  * Maps each element to a stream and flattens the resulting streams.
  *
+ * **Details**
+ *
  * With the default sequential concurrency, inner streams are concatenated in
  * input order. When `concurrency` is greater than `1` or `"unbounded"`,
  * multiple inner streams may run at the same time and their outputs are merged
@@ -2395,6 +2430,8 @@ export declare const flatMap: {
     /**
      * Maps each element to a stream and flattens the resulting streams.
      *
+     * **Details**
+     *
      * With the default sequential concurrency, inner streams are concatenated in
      * input order. When `concurrency` is greater than `1` or `"unbounded"`,
      * multiple inner streams may run at the same time and their outputs are merged
@@ -2427,6 +2464,8 @@ export declare const flatMap: {
     /**
      * Maps each element to a stream and flattens the resulting streams.
      *
+     * **Details**
+     *
      * With the default sequential concurrency, inner streams are concatenated in
      * input order. When `concurrency` is greater than `1` or `"unbounded"`,
      * multiple inner streams may run at the same time and their outputs are merged
@@ -2542,6 +2581,8 @@ export declare const switchMap: {
 /**
  * Flattens a stream of streams into a single stream.
  *
+ * **Details**
+ *
  * With the default sequential concurrency, inner streams are concatenated in
  * strict order. When `concurrency` is greater than `1` or `"unbounded"`,
  * multiple inner streams may run at the same time and their outputs are merged
@@ -2944,6 +2985,8 @@ export declare const timeout: {
  * Switches to a fallback stream if this stream does not emit a value within
  * the specified duration.
  *
+ * **Details**
+ *
  * The timeout is checked for each pull. A zero duration uses `orElse`
  * immediately, while an infinite duration leaves the original stream
  * unchanged.
@@ -2956,6 +2999,8 @@ export declare const timeoutOrElse: {
      * Switches to a fallback stream if this stream does not emit a value within
      * the specified duration.
      *
+     * **Details**
+     *
      * The timeout is checked for each pull. A zero duration uses `orElse`
      * immediately, while an infinite duration leaves the original stream
      * unchanged.
@@ -2971,6 +3016,8 @@ export declare const timeoutOrElse: {
      * Switches to a fallback stream if this stream does not emit a value within
      * the specified duration.
      *
+     * **Details**
+     *
      * The timeout is checked for each pull. A zero duration uses `orElse`
      * immediately, while an infinite duration leaves the original stream
      * unchanged.
@@ -3281,6 +3328,8 @@ export declare const prepend: {
 /**
  * Merges two streams, emitting elements from both as they arrive.
  *
+ * **Details**
+ *
  * By default, the merged stream ends when both streams end. Use
  * `haltStrategy` to change the termination behavior.
  *
@@ -3308,6 +3357,8 @@ export declare const merge: {
     /**
      * Merges two streams, emitting elements from both as they arrive.
      *
+     * **Details**
+     *
      * By default, the merged stream ends when both streams end. Use
      * `haltStrategy` to change the termination behavior.
      *
@@ -3337,6 +3388,8 @@ export declare const merge: {
     /**
      * Merges two streams, emitting elements from both as they arrive.
      *
+     * **Details**
+     *
      * By default, the merged stream ends when both streams end. Use
      * `haltStrategy` to change the termination behavior.
      *
@@ -3367,6 +3420,8 @@ export declare const merge: {
 /**
  * Merges this stream with a background effect, keeping the stream's elements.
  *
+ * **Details**
+ *
  * The effect runs concurrently, fails the stream if it fails, and is interrupted
  * when the stream completes.
  *
@@ -3396,6 +3451,8 @@ export declare const mergeEffect: {
     /**
      * Merges this stream with a background effect, keeping the stream's elements.
      *
+     * **Details**
+     *
      * The effect runs concurrently, fails the stream if it fails, and is interrupted
      * when the stream completes.
      *
@@ -3425,6 +3482,8 @@ export declare const mergeEffect: {
     /**
      * Merges this stream with a background effect, keeping the stream's elements.
      *
+     * **Details**
+     *
      * The effect runs concurrently, fails the stream if it fails, and is interrupted
      * when the stream completes.
      *
@@ -3561,6 +3620,8 @@ export declare const mergeResult: {
 /**
  * Merges two streams while emitting only the values from the left stream.
  *
+ * **Details**
+ *
  * The right stream still runs for its effects, and any failures from the right
  * stream are propagated. The merged stream completes when the left stream
  * completes, interrupting the right stream.
@@ -3588,6 +3649,8 @@ export declare const mergeLeft: {
     /**
      * Merges two streams while emitting only the values from the left stream.
      *
+     * **Details**
+     *
      * The right stream still runs for its effects, and any failures from the right
      * stream are propagated. The merged stream completes when the left stream
      * completes, interrupting the right stream.
@@ -3615,6 +3678,8 @@ export declare const mergeLeft: {
     /**
      * Merges two streams while emitting only the values from the left stream.
      *
+     * **Details**
+     *
      * The right stream still runs for its effects, and any failures from the right
      * stream are propagated. The merged stream completes when the left stream
      * completes, interrupting the right stream.
@@ -3644,6 +3709,8 @@ export declare const mergeLeft: {
  * Merges this stream and the specified stream together, emitting only the
  * values from the right stream while the left stream runs for its effects.
  *
+ * **Details**
+ *
  * The merged stream ends when the right stream completes, interrupting the
  * left stream. Failures from the left stream still fail the merged stream.
  *
@@ -3676,6 +3743,8 @@ export declare const mergeRight: {
      * Merges this stream and the specified stream together, emitting only the
      * values from the right stream while the left stream runs for its effects.
      *
+     * **Details**
+     *
      * The merged stream ends when the right stream completes, interrupting the
      * left stream. Failures from the left stream still fail the merged stream.
      *
@@ -3708,6 +3777,8 @@ export declare const mergeRight: {
      * Merges this stream and the specified stream together, emitting only the
      * values from the right stream while the left stream runs for its effects.
      *
+     * **Details**
+     *
      * The merged stream ends when the right stream completes, interrupting the
      * left stream. Failures from the left stream still fail the merged stream.
      *
@@ -3832,6 +3903,8 @@ export declare const mergeAll: {
  * Creates the cartesian product of two streams, running the `right` stream for
  * each element in the `left` stream.
  *
+ * **Details**
+ *
  * See also `Stream.zip` for the more common point-wise variant.
  *
  * **Example** (Computing cartesian products)
@@ -3858,6 +3931,8 @@ export declare const cross: {
      * Creates the cartesian product of two streams, running the `right` stream for
      * each element in the `left` stream.
      *
+     * **Details**
+     *
      * See also `Stream.zip` for the more common point-wise variant.
      *
      * **Example** (Computing cartesian products)
@@ -3884,6 +3959,8 @@ export declare const cross: {
      * Creates the cartesian product of two streams, running the `right` stream for
      * each element in the `left` stream.
      *
+     * **Details**
+     *
      * See also `Stream.zip` for the more common point-wise variant.
      *
      * **Example** (Computing cartesian products)
@@ -3910,6 +3987,8 @@ export declare const cross: {
 /**
  * Creates a cartesian product of elements from two streams using a function.
  *
+ * **Details**
+ *
  * The `right` stream is rerun for every element in the `left` stream.
  *
  * See also `Stream.zipWith` for the more common point-wise variant.
@@ -3938,6 +4017,8 @@ export declare const crossWith: {
     /**
      * Creates a cartesian product of elements from two streams using a function.
      *
+     * **Details**
+     *
      * The `right` stream is rerun for every element in the `left` stream.
      *
      * See also `Stream.zipWith` for the more common point-wise variant.
@@ -3966,6 +4047,8 @@ export declare const crossWith: {
     /**
      * Creates a cartesian product of elements from two streams using a function.
      *
+     * **Details**
+     *
      * The `right` stream is rerun for every element in the `left` stream.
      *
      * See also `Stream.zipWith` for the more common point-wise variant.
@@ -4074,6 +4157,8 @@ export declare const zipWith: {
 /**
  * Zips two streams by applying a function to non-empty arrays of elements.
  *
+ * **Details**
+ *
  * The function returns output plus leftover arrays that carry into the next pull.
  *
  * **Example** (Zipping stream chunks)
@@ -4107,6 +4192,8 @@ export declare const zipWithArray: {
     /**
      * Zips two streams by applying a function to non-empty arrays of elements.
      *
+     * **Details**
+     *
      * The function returns output plus leftover arrays that carry into the next pull.
      *
      * **Example** (Zipping stream chunks)
@@ -4144,6 +4231,8 @@ export declare const zipWithArray: {
     /**
      * Zips two streams by applying a function to non-empty arrays of elements.
      *
+     * **Details**
+     *
      * The function returns output plus leftover arrays that carry into the next pull.
      *
      * **Example** (Zipping stream chunks)
@@ -4265,6 +4354,8 @@ export declare const zip: {
  * Zips this stream with another point-wise and keeps only the values from
  * the left stream.
  *
+ * **Details**
+ *
  * The resulting stream ends when either side ends.
  *
  * **Example** (Zipping streams while keeping left values)
@@ -4292,6 +4383,8 @@ export declare const zipLeft: {
      * Zips this stream with another point-wise and keeps only the values from
      * the left stream.
      *
+     * **Details**
+     *
      * The resulting stream ends when either side ends.
      *
      * **Example** (Zipping streams while keeping left values)
@@ -4319,6 +4412,8 @@ export declare const zipLeft: {
      * Zips this stream with another point-wise and keeps only the values from
      * the left stream.
      *
+     * **Details**
+     *
      * The resulting stream ends when either side ends.
      *
      * **Example** (Zipping streams while keeping left values)
@@ -4420,6 +4515,8 @@ export declare const zipRight: {
  * Zips this stream with another point-wise and emits tuples of elements from
  * both streams, flattening the left tuple.
  *
+ * **Details**
+ *
  * The new stream will end when one of the sides ends.
  *
  * **Example** (Zipping and flattening tuples)
@@ -4451,6 +4548,8 @@ export declare const zipFlatten: {
      * Zips this stream with another point-wise and emits tuples of elements from
      * both streams, flattening the left tuple.
      *
+     * **Details**
+     *
      * The new stream will end when one of the sides ends.
      *
      * **Example** (Zipping and flattening tuples)
@@ -4482,6 +4581,8 @@ export declare const zipFlatten: {
      * Zips this stream with another point-wise and emits tuples of elements from
      * both streams, flattening the left tuple.
      *
+     * **Details**
+     *
      * The new stream will end when one of the sides ends.
      *
      * **Example** (Zipping and flattening tuples)
@@ -4617,6 +4718,8 @@ export declare const zipWithPreviousAndNext: <A, E, R>(self: Stream<A, E, R>) =>
  * Zips multiple streams so that when a value is emitted by any stream, it is
  * combined with the latest values from the other streams to produce a result.
  *
+ * **Gotchas**
+ *
  * Note: tracking the latest value is done on a per-array basis. That means
  * that emitted elements that are not the last value in arrays will never be
  * used for zipping.
@@ -4648,6 +4751,8 @@ export declare const zipLatestAll: <T extends ReadonlyArray<Stream<any, any, any
 /**
  * Combines two streams by emitting each new element with the latest value from the other stream.
  *
+ * **Gotchas**
+ *
  * Note: tracking the latest value is done on a per-array basis. That means
  * that emitted elements that are not the last value in arrays will never be
  * used for zipping.
@@ -4675,6 +4780,8 @@ export declare const zipLatest: {
     /**
      * Combines two streams by emitting each new element with the latest value from the other stream.
      *
+     * **Gotchas**
+     *
      * Note: tracking the latest value is done on a per-array basis. That means
      * that emitted elements that are not the last value in arrays will never be
      * used for zipping.
@@ -4702,6 +4809,8 @@ export declare const zipLatest: {
     /**
      * Combines two streams by emitting each new element with the latest value from the other stream.
      *
+     * **Gotchas**
+     *
      * Note: tracking the latest value is done on a per-array basis. That means
      * that emitted elements that are not the last value in arrays will never be
      * used for zipping.
@@ -4731,6 +4840,8 @@ export declare const zipLatest: {
  * Combines the latest values from both streams whenever either emits, using
  * the provided function.
  *
+ * **Gotchas**
+ *
  * Note: tracking the latest value is done on a per-array basis. That means
  * that emitted elements that are not the last value in arrays will never be
  * used for zipping.
@@ -4763,6 +4874,8 @@ export declare const zipLatestWith: {
      * Combines the latest values from both streams whenever either emits, using
      * the provided function.
      *
+     * **Gotchas**
+     *
      * Note: tracking the latest value is done on a per-array basis. That means
      * that emitted elements that are not the last value in arrays will never be
      * used for zipping.
@@ -4795,6 +4908,8 @@ export declare const zipLatestWith: {
      * Combines the latest values from both streams whenever either emits, using
      * the provided function.
      *
+     * **Gotchas**
+     *
      * Note: tracking the latest value is done on a per-array basis. That means
      * that emitted elements that are not the last value in arrays will never be
      * used for zipping.
@@ -4828,13 +4943,12 @@ export declare const zipLatestWith: {
  * Runs all streams concurrently until one stream emits its first value, then
  * mirrors that winning stream and interrupts the rest.
  *
+ * **Details**
+ *
  * Failures or completion from losing streams before a winner is chosen are
  * ignored unless every stream fails or completes before emitting. After a
  * winner is chosen, that stream's later failures are propagated.
  *
- * @category Racing
- * @since 3.5.0
- *
  * **Example** (Racing multiple streams)
  *
  * ```ts
@@ -4851,12 +4965,17 @@ export declare const zipLatestWith: {
  * Effect.runPromise(program)
  * // Output: [ 0, 1, 2 ]
  * ```
+ *
+ * @category Racing
+ * @since 3.5.0
  */
 export declare const raceAll: <S extends ReadonlyArray<Stream<any, any, any>>>(...streams: S) => Stream<Success<S[number]>, Error<S[number]>, Services<S[number]>>;
 /**
  * Runs both streams concurrently until one stream emits its first value, then
  * mirrors that winning stream and interrupts the other.
  *
+ * **Details**
+ *
  * A failure or completion from one side before the other side emits does not
  * win the race unless both sides fail or complete before emitting. After a
  * winner is chosen, that stream's later failures are propagated.
@@ -4888,6 +5007,8 @@ export declare const race: {
      * Runs both streams concurrently until one stream emits its first value, then
      * mirrors that winning stream and interrupts the other.
      *
+     * **Details**
+     *
      * A failure or completion from one side before the other side emits does not
      * win the race unless both sides fail or complete before emitting. After a
      * winner is chosen, that stream's later failures are propagated.
@@ -4919,6 +5040,8 @@ export declare const race: {
      * Runs both streams concurrently until one stream emits its first value, then
      * mirrors that winning stream and interrupts the other.
      *
+     * **Details**
+     *
      * A failure or completion from one side before the other side emits does not
      * win the race unless both sides fail or complete before emitting. After a
      * winner is chosen, that stream's later failures are propagated.
@@ -5186,6 +5309,8 @@ export declare const filterMapEffect: {
  * Partitions a stream using a `Filter` and exposes passing and failing values
  * as scoped queues.
  *
+ * **Details**
+ *
  * The queues are backed by a fiber in the current scope and should be consumed
  * while that scope remains open. Each queue fails with the stream error or
  * `Cause.Done` when the source ends.
@@ -5220,6 +5345,8 @@ export declare const partitionQueue: {
      * Partitions a stream using a `Filter` and exposes passing and failing values
      * as scoped queues.
      *
+     * **Details**
+     *
      * The queues are backed by a fiber in the current scope and should be consumed
      * while that scope remains open. Each queue fails with the stream error or
      * `Cause.Done` when the source ends.
@@ -5259,6 +5386,8 @@ export declare const partitionQueue: {
      * Partitions a stream using a `Filter` and exposes passing and failing values
      * as scoped queues.
      *
+     * **Details**
+     *
      * The queues are backed by a fiber in the current scope and should be consumed
      * while that scope remains open. Each queue fails with the stream error or
      * `Cause.Done` when the source ends.
@@ -5299,6 +5428,8 @@ export declare const partitionQueue: {
  * Splits a stream with an effectful `Filter`, returning scoped streams for
  * filter successes and failures.
  *
+ * **Details**
+ *
  * The returned streams are backed by queues in the current scope and should be
  * consumed while that scope remains open. The first stream emits success values
  * from the filter, and the second emits failure values.
@@ -5311,6 +5442,8 @@ export declare const partitionEffect: {
      * Splits a stream with an effectful `Filter`, returning scoped streams for
      * filter successes and failures.
      *
+     * **Details**
+     *
      * The returned streams are backed by queues in the current scope and should be
      * consumed while that scope remains open. The first stream emits success values
      * from the filter, and the second emits failure values.
@@ -5329,6 +5462,8 @@ export declare const partitionEffect: {
      * Splits a stream with an effectful `Filter`, returning scoped streams for
      * filter successes and failures.
      *
+     * **Details**
+     *
      * The returned streams are backed by queues in the current scope and should be
      * consumed while that scope remains open. The first stream emits success values
      * from the filter, and the second emits failure values.
@@ -5348,13 +5483,12 @@ export declare const partitionEffect: {
  * Splits a stream into scoped excluded and satisfying substreams using a
  * `Filter`.
  *
+ * **Details**
+ *
  * The returned streams are backed by queues in the current scope and should be
  * consumed while that scope remains open. The faster stream may advance up to
  * `bufferSize` elements ahead of the slower one.
  *
- * @category filtering
- * @since 2.0.0
- *
  * **Example** (Partitioning a stream)
  *
  * ```ts
@@ -5373,19 +5507,21 @@ export declare const partitionEffect: {
  *   // Output: [ 2, 4 ]
  * })
  * ```
+ *
+ * @category filtering
+ * @since 2.0.0
  */
 export declare const partition: {
     /**
      * Splits a stream into scoped excluded and satisfying substreams using a
      * `Filter`.
      *
+     * **Details**
+     *
      * The returned streams are backed by queues in the current scope and should be
      * consumed while that scope remains open. The faster stream may advance up to
      * `bufferSize` elements ahead of the slower one.
      *
-     * @category filtering
-     * @since 2.0.0
-     *
      * **Example** (Partitioning a stream)
      *
      * ```ts
@@ -5404,6 +5540,9 @@ export declare const partition: {
      *   // Output: [ 2, 4 ]
      * })
      * ```
+     *
+     * @category filtering
+     * @since 2.0.0
      */
     <A, Pass, Fail>(filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly bufferSize?: number | undefined;
@@ -5415,13 +5554,12 @@ export declare const partition: {
      * Splits a stream into scoped excluded and satisfying substreams using a
      * `Filter`.
      *
+     * **Details**
+     *
      * The returned streams are backed by queues in the current scope and should be
      * consumed while that scope remains open. The faster stream may advance up to
      * `bufferSize` elements ahead of the slower one.
      *
-     * @category filtering
-     * @since 2.0.0
-     *
      * **Example** (Partitioning a stream)
      *
      * ```ts
@@ -5440,6 +5578,9 @@ export declare const partition: {
      *   // Output: [ 2, 4 ]
      * })
      * ```
+     *
+     * @category filtering
+     * @since 2.0.0
      */
     <A, E, R, Pass, Fail>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly bufferSize?: number | undefined;
@@ -5525,6 +5666,8 @@ export declare const when: {
  * Runs a sink to peel off enough elements to produce a value and returns that
  * value with the remaining stream in a scope.
  *
+ * **Details**
+ *
  * The returned stream is only valid within the scope.
  *
  * **Example** (Peeling a stream with a sink)
@@ -5555,6 +5698,8 @@ export declare const peel: {
      * Runs a sink to peel off enough elements to produce a value and returns that
      * value with the remaining stream in a scope.
      *
+     * **Details**
+     *
      * The returned stream is only valid within the scope.
      *
      * **Example** (Peeling a stream with a sink)
@@ -5585,6 +5730,8 @@ export declare const peel: {
      * Runs a sink to peel off enough elements to produce a value and returns that
      * value with the remaining stream in a scope.
      *
+     * **Details**
+     *
      * The returned stream is only valid within the scope.
      *
      * **Example** (Peeling a stream with a sink)
@@ -5616,6 +5763,8 @@ export declare const peel: {
  * Buffers up to `capacity` elements so a faster producer can progress
  * independently of a slower consumer.
  *
+ * **Details**
+ *
  * Finite buffers use the configured queue strategy: `"suspend"` applies
  * backpressure, while `"dropping"` and `"sliding"` may discard elements when
  * the buffer is full. This combinator destroys chunking; use `Stream.rechunk`
@@ -5646,6 +5795,8 @@ export declare const buffer: {
      * Buffers up to `capacity` elements so a faster producer can progress
      * independently of a slower consumer.
      *
+     * **Details**
+     *
      * Finite buffers use the configured queue strategy: `"suspend"` applies
      * backpressure, while `"dropping"` and `"sliding"` may discard elements when
      * the buffer is full. This combinator destroys chunking; use `Stream.rechunk`
@@ -5681,6 +5832,8 @@ export declare const buffer: {
      * Buffers up to `capacity` elements so a faster producer can progress
      * independently of a slower consumer.
      *
+     * **Details**
+     *
      * Finite buffers use the configured queue strategy: `"suspend"` applies
      * backpressure, while `"dropping"` and `"sliding"` may discard elements when
      * the buffer is full. This combinator destroys chunking; use `Stream.rechunk`
@@ -5717,6 +5870,8 @@ export declare const buffer: {
  * Allows a faster producer to progress independently of a slower consumer by
  * buffering up to `capacity` chunks in a queue.
  *
+ * **Details**
+ *
  * Finite buffers use the configured queue strategy: `"suspend"` applies
  * backpressure, while `"dropping"` and `"sliding"` may discard chunks when the
  * buffer is full. This combinator preserves chunking and is best with
@@ -5746,6 +5901,8 @@ export declare const bufferArray: {
      * Allows a faster producer to progress independently of a slower consumer by
      * buffering up to `capacity` chunks in a queue.
      *
+     * **Details**
+     *
      * Finite buffers use the configured queue strategy: `"suspend"` applies
      * backpressure, while `"dropping"` and `"sliding"` may discard chunks when the
      * buffer is full. This combinator preserves chunking and is best with
@@ -5780,6 +5937,8 @@ export declare const bufferArray: {
      * Allows a faster producer to progress independently of a slower consumer by
      * buffering up to `capacity` chunks in a queue.
      *
+     * **Details**
+     *
      * Finite buffers use the configured queue strategy: `"suspend"` applies
      * backpressure, while `"dropping"` and `"sliding"` may discard chunks when the
      * buffer is full. This combinator preserves chunking and is best with
@@ -6118,6 +6277,8 @@ export declare const tapError: {
 /**
  * Recovers from errors that match a predicate by switching to a recovery stream.
  *
+ * **Details**
+ *
  * When a failure matches the filter, the stream switches to the recovery
  * stream. Non-matching failures propagate downstream, so the error type is
  * preserved unless the filter narrows it.
@@ -6151,6 +6312,8 @@ export declare const catchIf: {
     /**
      * Recovers from errors that match a predicate by switching to a recovery stream.
      *
+     * **Details**
+     *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
      * preserved unless the filter narrows it.
@@ -6184,6 +6347,8 @@ export declare const catchIf: {
     /**
      * Recovers from errors that match a predicate by switching to a recovery stream.
      *
+     * **Details**
+     *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
      * preserved unless the filter narrows it.
@@ -6217,6 +6382,8 @@ export declare const catchIf: {
     /**
      * Recovers from errors that match a predicate by switching to a recovery stream.
      *
+     * **Details**
+     *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
      * preserved unless the filter narrows it.
@@ -6250,6 +6417,8 @@ export declare const catchIf: {
     /**
      * Recovers from errors that match a predicate by switching to a recovery stream.
      *
+     * **Details**
+     *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
      * preserved unless the filter narrows it.
@@ -6310,7 +6479,7 @@ export declare const catchFilter: {
  * Recovers from failures whose `_tag` matches the provided value by switching to
  * the stream returned by `f`.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `catchTag` when your error type is a tagged union with a readonly `_tag`
  * field and you want to handle a specific error case.
@@ -6345,7 +6514,7 @@ export declare const catchTag: {
      * Recovers from failures whose `_tag` matches the provided value by switching to
      * the stream returned by `f`.
      *
-     * **When to Use**
+     * **When to use**
      *
      * Use `catchTag` when your error type is a tagged union with a readonly `_tag`
      * field and you want to handle a specific error case.
@@ -6380,7 +6549,7 @@ export declare const catchTag: {
      * Recovers from failures whose `_tag` matches the provided value by switching to
      * the stream returned by `f`.
      *
-     * **When to Use**
+     * **When to use**
      *
      * Use `catchTag` when your error type is a tagged union with a readonly `_tag`
      * field and you want to handle a specific error case.
@@ -6562,6 +6731,8 @@ export declare const catchTags: {
 /**
  * Catches a specific reason within a tagged error.
  *
+ * **When to use**
+ *
  * Use this to handle nested error causes without removing the parent error
  * from the error channel. The handler receives the unwrapped reason.
  *
@@ -6607,6 +6778,8 @@ export declare const catchReason: {
     /**
      * Catches a specific reason within a tagged error.
      *
+     * **When to use**
+     *
      * Use this to handle nested error causes without removing the parent error
      * from the error channel. The handler receives the unwrapped reason.
      *
@@ -6652,6 +6825,8 @@ export declare const catchReason: {
     /**
      * Catches a specific reason within a tagged error.
      *
+     * **When to use**
+     *
      * Use this to handle nested error causes without removing the parent error
      * from the error channel. The handler receives the unwrapped reason.
      *
@@ -7207,6 +7382,8 @@ export declare const orDie: <A, E, R>(self: Stream<A, E, R>) => Stream<A, never,
 /**
  * Ignores failures and ends the stream on error.
  *
+ * **When to use**
+ *
  * Use the `log` option to emit the full {@link Cause} when the stream fails.
  *
  * **Example** (Ignoring stream failures)
@@ -7254,6 +7431,8 @@ export declare const ignore: <Arg extends Stream<any, any, any> | {
 /**
  * Ignores the stream's failure cause, including defects, and ends the stream.
  *
+ * **When to use**
+ *
  * Use the `log` option to emit the full {@link Cause} when the stream fails.
  *
  * **Example** (Ignoring stream failure causes)
@@ -7284,6 +7463,8 @@ export declare const ignoreCause: <Arg extends Stream<any, any, any> | {
 /**
  * When the stream fails, retry it according to the given schedule.
  *
+ * **Details**
+ *
  * This retries the entire stream, so will re-execute all of the stream's
  * acquire operations.
  *
@@ -7317,6 +7498,8 @@ export declare const retry: {
     /**
      * When the stream fails, retry it according to the given schedule.
      *
+     * **Details**
+     *
      * This retries the entire stream, so will re-execute all of the stream's
      * acquire operations.
      *
@@ -7350,6 +7533,8 @@ export declare const retry: {
     /**
      * When the stream fails, retry it according to the given schedule.
      *
+     * **Details**
+     *
      * This retries the entire stream, so will re-execute all of the stream's
      * acquire operations.
      *
@@ -7385,6 +7570,8 @@ export declare const retry: {
  * Apply an `ExecutionPlan` to a stream, retrying with step-provided resources
  * until it succeeds or the plan is exhausted.
  *
+ * **Details**
+ *
  * By default, a failing step can fallback even after emitting elements; set
  * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
  * a later fallback.
@@ -7427,6 +7614,8 @@ export declare const withExecutionPlan: {
      * Apply an `ExecutionPlan` to a stream, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
      *
+     * **Details**
+     *
      * By default, a failing step can fallback even after emitting elements; set
      * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
      * a later fallback.
@@ -7476,6 +7665,8 @@ export declare const withExecutionPlan: {
      * Apply an `ExecutionPlan` to a stream, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
      *
+     * **Details**
+     *
      * By default, a failing step can fallback even after emitting elements; set
      * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
      * a later fallback.
@@ -7671,6 +7862,8 @@ export declare const takeRight: {
 /**
  * Takes elements until the predicate matches.
  *
+ * **Details**
+ *
  * When `excludeLast` is `true`, the matching element is dropped.
  *
  * **Example** (Taking until a predicate matches)
@@ -7704,6 +7897,8 @@ export declare const takeUntil: {
     /**
      * Takes elements until the predicate matches.
      *
+     * **Details**
+     *
      * When `excludeLast` is `true`, the matching element is dropped.
      *
      * **Example** (Taking until a predicate matches)
@@ -7739,6 +7934,8 @@ export declare const takeUntil: {
     /**
      * Takes elements until the predicate matches.
      *
+     * **Details**
+     *
      * When `excludeLast` is `true`, the matching element is dropped.
      *
      * **Example** (Taking until a predicate matches)
@@ -7979,6 +8176,8 @@ export declare const takeWhile: {
  * Takes the longest initial prefix accepted by a `Filter` and emits the
  * filter's success values.
  *
+ * **Details**
+ *
  * The stream stops at the first `Result.fail` returned by the filter.
  *
  * @category filtering
@@ -7989,6 +8188,8 @@ export declare const takeWhileFilter: {
      * Takes the longest initial prefix accepted by a `Filter` and emits the
      * filter's success values.
      *
+     * **Details**
+     *
      * The stream stops at the first `Result.fail` returned by the filter.
      *
      * @category filtering
@@ -7999,6 +8200,8 @@ export declare const takeWhileFilter: {
      * Takes the longest initial prefix accepted by a `Filter` and emits the
      * filter's success values.
      *
+     * **Details**
+     *
      * The stream stops at the first `Result.fail` returned by the filter.
      *
      * @category filtering
@@ -8223,6 +8426,8 @@ export declare const dropUntil: {
  * Drops all elements of the stream until the specified effectful predicate
  * evaluates to `true`.
  *
+ * **Details**
+ *
  * The first element that satisfies the predicate is also dropped.
  *
  * **Example** (Dropping until an effectful predicate matches)
@@ -8250,6 +8455,8 @@ export declare const dropUntilEffect: {
      * Drops all elements of the stream until the specified effectful predicate
      * evaluates to `true`.
      *
+     * **Details**
+     *
      * The first element that satisfies the predicate is also dropped.
      *
      * **Example** (Dropping until an effectful predicate matches)
@@ -8277,6 +8484,8 @@ export declare const dropUntilEffect: {
      * Drops all elements of the stream until the specified effectful predicate
      * evaluates to `true`.
      *
+     * **Details**
+     *
      * The first element that satisfies the predicate is also dropped.
      *
      * **Example** (Dropping until an effectful predicate matches)
@@ -8472,6 +8681,8 @@ export declare const dropWhileEffect: {
 /**
  * Drops the last specified number of elements from this stream.
  *
+ * **Details**
+ *
  * Keeps the last `n` elements in memory to drop them on completion.
  *
  * **Example** (Dropping values from the right)
@@ -8498,6 +8709,8 @@ export declare const dropRight: {
     /**
      * Drops the last specified number of elements from this stream.
      *
+     * **Details**
+     *
      * Keeps the last `n` elements in memory to drop them on completion.
      *
      * **Example** (Dropping values from the right)
@@ -8524,6 +8737,8 @@ export declare const dropRight: {
     /**
      * Drops the last specified number of elements from this stream.
      *
+     * **Details**
+     *
      * Keeps the last `n` elements in memory to drop them on completion.
      *
      * **Example** (Dropping values from the right)
@@ -8576,6 +8791,8 @@ export declare const chunks: <A, E, R>(self: Stream<A, E, R>) => Stream<Arr.NonE
 /**
  * Re-chunks the stream into arrays of the specified size, preserving element order.
  *
+ * **Details**
+ *
  * The size is clamped to at least 1.
  *
  * **Example** (Rechunking stream elements)
@@ -8603,6 +8820,8 @@ export declare const rechunk: {
     /**
      * Re-chunks the stream into arrays of the specified size, preserving element order.
      *
+     * **Details**
+     *
      * The size is clamped to at least 1.
      *
      * **Example** (Rechunking stream elements)
@@ -8630,6 +8849,8 @@ export declare const rechunk: {
     /**
      * Re-chunks the stream into arrays of the specified size, preserving element order.
      *
+     * **Details**
+     *
      * The size is clamped to at least 1.
      *
      * **Example** (Rechunking stream elements)
@@ -8801,6 +9022,8 @@ export declare const slidingSize: {
 /**
  * Splits the stream into non-empty groups whenever the predicate matches.
  *
+ * **Details**
+ *
  * Matching elements act as delimiters and are not included in the output.
  *
  * **Example** (Splitting on matching values)
@@ -8827,6 +9050,8 @@ export declare const split: {
     /**
      * Splits the stream into non-empty groups whenever the predicate matches.
      *
+     * **Details**
+     *
      * Matching elements act as delimiters and are not included in the output.
      *
      * **Example** (Splitting on matching values)
@@ -8853,6 +9078,8 @@ export declare const split: {
     /**
      * Splits the stream into non-empty groups whenever the predicate matches.
      *
+     * **Details**
+     *
      * Matching elements act as delimiters and are not included in the output.
      *
      * **Example** (Splitting on matching values)
@@ -8879,6 +9106,8 @@ export declare const split: {
     /**
      * Splits the stream into non-empty groups whenever the predicate matches.
      *
+     * **Details**
+     *
      * Matching elements act as delimiters and are not included in the output.
      *
      * **Example** (Splitting on matching values)
@@ -8905,6 +9134,8 @@ export declare const split: {
     /**
      * Splits the stream into non-empty groups whenever the predicate matches.
      *
+     * **Details**
+     *
      * Matching elements act as delimiters and are not included in the output.
      *
      * **Example** (Splitting on matching values)
@@ -8933,6 +9164,8 @@ export declare const split: {
  * Combines elements from this stream and the specified stream by repeatedly
  * applying a stateful function that can pull from either side.
  *
+ * **Details**
+ *
  * Where possible, prefer `Stream.combineArray` for a more efficient
  * implementation.
  *
@@ -8968,6 +9201,8 @@ export declare const combine: {
      * Combines elements from this stream and the specified stream by repeatedly
      * applying a stateful function that can pull from either side.
      *
+     * **Details**
+     *
      * Where possible, prefer `Stream.combineArray` for a more efficient
      * implementation.
      *
@@ -9003,6 +9238,8 @@ export declare const combine: {
      * Combines elements from this stream and the specified stream by repeatedly
      * applying a stateful function that can pull from either side.
      *
+     * **Details**
+     *
      * Where possible, prefer `Stream.combineArray` for a more efficient
      * implementation.
      *
@@ -9239,6 +9476,8 @@ export declare const mapAccum: {
 /**
  * Statefully maps over non-empty chunk arrays, emitting zero or more values per chunk.
  *
+ * **Details**
+ *
  * The mapping function runs once per chunk and the state is threaded across chunks.
  *
  * **Example** (Statefully mapping stream chunks)
@@ -9269,6 +9508,8 @@ export declare const mapAccumArray: {
     /**
      * Statefully maps over non-empty chunk arrays, emitting zero or more values per chunk.
      *
+     * **Details**
+     *
      * The mapping function runs once per chunk and the state is threaded across chunks.
      *
      * **Example** (Statefully mapping stream chunks)
@@ -9301,6 +9542,8 @@ export declare const mapAccumArray: {
     /**
      * Statefully maps over non-empty chunk arrays, emitting zero or more values per chunk.
      *
+     * **Details**
+     *
      * The mapping function runs once per chunk and the state is threaded across chunks.
      *
      * **Example** (Statefully mapping stream chunks)
@@ -9335,6 +9578,8 @@ export declare const mapAccumArray: {
  * Statefully and effectfully maps each element, emitting zero or more output
  * values per input.
  *
+ * **Details**
+ *
  * The mapping effect receives the current state and element, then returns the
  * next state plus the values to emit. The state is threaded through the
  * stream.
@@ -9367,6 +9612,8 @@ export declare const mapAccumEffect: {
      * Statefully and effectfully maps each element, emitting zero or more output
      * values per input.
      *
+     * **Details**
+     *
      * The mapping effect receives the current state and element, then returns the
      * next state plus the values to emit. The state is threaded through the
      * stream.
@@ -9401,6 +9648,8 @@ export declare const mapAccumEffect: {
      * Statefully and effectfully maps each element, emitting zero or more output
      * values per input.
      *
+     * **Details**
+     *
      * The mapping effect receives the current state and element, then returns the
      * next state plus the values to emit. The state is threaded through the
      * stream.
@@ -9436,6 +9685,8 @@ export declare const mapAccumEffect: {
  * Statefully and effectfully maps each non-empty input chunk, emitting zero or
  * more output values per chunk.
  *
+ * **Details**
+ *
  * The mapping effect receives the current state and chunk, then returns the
  * next state plus the values to emit. The state is threaded across chunks.
  *
@@ -9470,6 +9721,8 @@ export declare const mapAccumArrayEffect: {
      * Statefully and effectfully maps each non-empty input chunk, emitting zero or
      * more output values per chunk.
      *
+     * **Details**
+     *
      * The mapping effect receives the current state and chunk, then returns the
      * next state plus the values to emit. The state is threaded across chunks.
      *
@@ -9506,6 +9759,8 @@ export declare const mapAccumArrayEffect: {
      * Statefully and effectfully maps each non-empty input chunk, emitting zero or
      * more output values per chunk.
      *
+     * **Details**
+     *
      * The mapping effect receives the current state and chunk, then returns the
      * next state plus the values to emit. The state is threaded across chunks.
      *
@@ -9761,6 +10016,8 @@ export declare const debounce: {
  * allowing the bucket to accumulate tokens up to a `units + burst` threshold.
  * The weight of each array is determined by the effectful `cost` function.
  *
+ * **Details**
+ *
  * If using the "enforce" strategy, arrays that do not meet the bandwidth
  * constraints are dropped. If using the "shape" strategy, arrays are delayed
  * until they can be emitted without exceeding the bandwidth constraints.
@@ -9799,6 +10056,8 @@ export declare const throttleEffect: {
      * allowing the bucket to accumulate tokens up to a `units + burst` threshold.
      * The weight of each array is determined by the effectful `cost` function.
      *
+     * **Details**
+     *
      * If using the "enforce" strategy, arrays that do not meet the bandwidth
      * constraints are dropped. If using the "shape" strategy, arrays are delayed
      * until they can be emitted without exceeding the bandwidth constraints.
@@ -9843,6 +10102,8 @@ export declare const throttleEffect: {
      * allowing the bucket to accumulate tokens up to a `units + burst` threshold.
      * The weight of each array is determined by the effectful `cost` function.
      *
+     * **Details**
+     *
      * If using the "enforce" strategy, arrays that do not meet the bandwidth
      * constraints are dropped. If using the "shape" strategy, arrays are delayed
      * until they can be emitted without exceeding the bandwidth constraints.
@@ -9887,6 +10148,8 @@ export declare const throttleEffect: {
  * Allows bursts by letting the bucket accumulate up to a `units + burst`
  * threshold. The weight of each array is determined by the `cost` function.
  *
+ * **Details**
+ *
  * If using the "enforce" strategy, arrays that do not meet the bandwidth
  * constraints are dropped. If using the "shape" strategy, arrays are delayed
  * until they can be emitted without exceeding the bandwidth constraints.
@@ -9924,6 +10187,8 @@ export declare const throttle: {
      * Allows bursts by letting the bucket accumulate up to a `units + burst`
      * threshold. The weight of each array is determined by the `cost` function.
      *
+     * **Details**
+     *
      * If using the "enforce" strategy, arrays that do not meet the bandwidth
      * constraints are dropped. If using the "shape" strategy, arrays are delayed
      * until they can be emitted without exceeding the bandwidth constraints.
@@ -9967,6 +10232,8 @@ export declare const throttle: {
      * Allows bursts by letting the bucket accumulate up to a `units + burst`
      * threshold. The weight of each array is determined by the `cost` function.
      *
+     * **Details**
+     *
      * If using the "enforce" strategy, arrays that do not meet the bandwidth
      * constraints are dropped. If using the "shape" strategy, arrays are delayed
      * until they can be emitted without exceeding the bandwidth constraints.
@@ -10009,6 +10276,8 @@ export declare const throttle: {
 /**
  * Partitions the stream into non-empty arrays of the specified size.
  *
+ * **Details**
+ *
  * The final array may be smaller if there are not enough elements to fill it.
  *
  * **Example** (Grouping elements by size)
@@ -10035,6 +10304,8 @@ export declare const grouped: {
     /**
      * Partitions the stream into non-empty arrays of the specified size.
      *
+     * **Details**
+     *
      * The final array may be smaller if there are not enough elements to fill it.
      *
      * **Example** (Grouping elements by size)
@@ -10061,6 +10332,8 @@ export declare const grouped: {
     /**
      * Partitions the stream into non-empty arrays of the specified size.
      *
+     * **Details**
+     *
      * The final array may be smaller if there are not enough elements to fill it.
      *
      * **Example** (Grouping elements by size)
@@ -10370,6 +10643,8 @@ export declare const groupByKey: {
 /**
  * Groups consecutive elements that have equal keys into non-empty arrays.
  *
+ * **Details**
+ *
  * The key is computed with `f`; adjacent elements whose keys are equal by
  * `Equal.equals` are emitted as one `[key, group]`. Later non-adjacent runs
  * with the same key are emitted separately.
@@ -10381,6 +10656,8 @@ export declare const groupAdjacentBy: {
     /**
      * Groups consecutive elements that have equal keys into non-empty arrays.
      *
+     * **Details**
+     *
      * The key is computed with `f`; adjacent elements whose keys are equal by
      * `Equal.equals` are emitted as one `[key, group]`. Later non-adjacent runs
      * with the same key are emitted separately.
@@ -10392,6 +10669,8 @@ export declare const groupAdjacentBy: {
     /**
      * Groups consecutive elements that have equal keys into non-empty arrays.
      *
+     * **Details**
+     *
      * The key is computed with `f`; adjacent elements whose keys are equal by
      * `Equal.equals` are emitted as one `[key, group]`. Later non-adjacent runs
      * with the same key are emitted separately.
@@ -10427,6 +10706,8 @@ export declare const transduce: (<A2, A, E2, R2>(sink: Sink.Sink<A2, A, A, E2, R
 /**
  * Aggregates elements using the provided sink and emits each sink result as a stream element.
  *
+ * **Details**
+ *
  * The stream runs the upstream and downstream in separate fibers, so the sink can keep
  * consuming input while downstream is busy processing the previous output.
  *
@@ -10455,6 +10736,8 @@ export declare const aggregate: {
     /**
      * Aggregates elements using the provided sink and emits each sink result as a stream element.
      *
+     * **Details**
+     *
      * The stream runs the upstream and downstream in separate fibers, so the sink can keep
      * consuming input while downstream is busy processing the previous output.
      *
@@ -10483,6 +10766,8 @@ export declare const aggregate: {
     /**
      * Aggregates elements using the provided sink and emits each sink result as a stream element.
      *
+     * **Details**
+     *
      * The stream runs the upstream and downstream in separate fibers, so the sink can keep
      * consuming input while downstream is busy processing the previous output.
      *
@@ -10512,6 +10797,8 @@ export declare const aggregate: {
 /**
  * Aggregates elements with a sink, emitting each result when the sink completes or the schedule triggers.
  *
+ * **Details**
+ *
  * The schedule can flush the current aggregation even if the sink has not finished.
  *
  * **Example** (Aggregating with a sink and schedule)
@@ -10540,6 +10827,8 @@ export declare const aggregateWithin: {
     /**
      * Aggregates elements with a sink, emitting each result when the sink completes or the schedule triggers.
      *
+     * **Details**
+     *
      * The schedule can flush the current aggregation even if the sink has not finished.
      *
      * **Example** (Aggregating with a sink and schedule)
@@ -10568,6 +10857,8 @@ export declare const aggregateWithin: {
     /**
      * Aggregates elements with a sink, emitting each result when the sink completes or the schedule triggers.
      *
+     * **Details**
+     *
      * The schedule can flush the current aggregation even if the sink has not finished.
      *
      * **Example** (Aggregating with a sink and schedule)
@@ -10598,6 +10889,8 @@ export declare const aggregateWithin: {
  * Fan out the stream, producing a fixed-size tuple of streams that each emit
  * the same elements as the source stream.
  *
+ * **Details**
+ *
  * The source stream starts after all downstream streams have been subscribed.
  * With the default suspend strategy, the source can only advance `capacity`
  * chunks ahead of the slowest downstream stream. If a downstream stream is
@@ -10636,6 +10929,8 @@ export declare const broadcastN: {
      * Fan out the stream, producing a fixed-size tuple of streams that each emit
      * the same elements as the source stream.
      *
+     * **Details**
+     *
      * The source stream starts after all downstream streams have been subscribed.
      * With the default suspend strategy, the source can only advance `capacity`
      * chunks ahead of the slowest downstream stream. If a downstream stream is
@@ -10683,6 +10978,8 @@ export declare const broadcastN: {
      * Fan out the stream, producing a fixed-size tuple of streams that each emit
      * the same elements as the source stream.
      *
+     * **Details**
+     *
      * The source stream starts after all downstream streams have been subscribed.
      * With the default suspend strategy, the source can only advance `capacity`
      * chunks ahead of the slowest downstream stream. If a downstream stream is
@@ -10730,6 +11027,8 @@ export declare const broadcastN: {
 /**
  * Creates a PubSub-backed stream that multicasts the source to all subscribers.
  *
+ * **Details**
+ *
  * The returned stream is scoped and uses the provided PubSub capacity and replay settings.
  *
  * **Example** (Broadcasting a stream)
@@ -10764,6 +11063,8 @@ export declare const broadcast: {
     /**
      * Creates a PubSub-backed stream that multicasts the source to all subscribers.
      *
+     * **Details**
+     *
      * The returned stream is scoped and uses the provided PubSub capacity and replay settings.
      *
      * **Example** (Broadcasting a stream)
@@ -10805,6 +11106,8 @@ export declare const broadcast: {
     /**
      * Creates a PubSub-backed stream that multicasts the source to all subscribers.
      *
+     * **Details**
+     *
      * The returned stream is scoped and uses the provided PubSub capacity and replay settings.
      *
      * **Example** (Broadcasting a stream)
@@ -10847,6 +11150,8 @@ export declare const broadcast: {
 /**
  * Returns a new Stream that multicasts the original stream, subscribing when the first consumer starts.
  *
+ * **Details**
+ *
  * The upstream continues running while there is at least one consumer and is finalized after the last one exits.
  * If `idleTimeToLive` is set, the upstream is kept alive for that duration so a later subscriber can continue from
  * the next element instead of restarting.
@@ -10880,6 +11185,8 @@ export declare const share: {
     /**
      * Returns a new Stream that multicasts the original stream, subscribing when the first consumer starts.
      *
+     * **Details**
+     *
      * The upstream continues running while there is at least one consumer and is finalized after the last one exits.
      * If `idleTimeToLive` is set, the upstream is kept alive for that duration so a later subscriber can continue from
      * the next element instead of restarting.
@@ -10922,6 +11229,8 @@ export declare const share: {
     /**
      * Returns a new Stream that multicasts the original stream, subscribing when the first consumer starts.
      *
+     * **Details**
+     *
      * The upstream continues running while there is at least one consumer and is finalized after the last one exits.
      * If `idleTimeToLive` is set, the upstream is kept alive for that duration so a later subscriber can continue from
      * the next element instead of restarting.
@@ -10965,6 +11274,8 @@ export declare const share: {
 /**
  * Pipes this stream through a channel that consumes and emits chunked elements.
  *
+ * **Details**
+ *
  * The channel receives `NonEmptyReadonlyArray` chunks and can transform both the
  * output elements and error type.
  *
@@ -10999,6 +11310,8 @@ export declare const pipeThroughChannel: {
     /**
      * Pipes this stream through a channel that consumes and emits chunked elements.
      *
+     * **Details**
+     *
      * The channel receives `NonEmptyReadonlyArray` chunks and can transform both the
      * output elements and error type.
      *
@@ -11033,6 +11346,8 @@ export declare const pipeThroughChannel: {
     /**
      * Pipes this stream through a channel that consumes and emits chunked elements.
      *
+     * **Details**
+     *
      * The channel receives `NonEmptyReadonlyArray` chunks and can transform both the
      * output elements and error type.
      *
@@ -11069,6 +11384,8 @@ export declare const pipeThroughChannel: {
  * Pipes values through the provided channel while preserving this stream's
  * failures alongside any channel failures.
  *
+ * **Details**
+ *
  * Upstream failures are not passed to the channel, so the resulting stream can
  * fail with either the original stream error or the channel error.
  *
@@ -11103,6 +11420,8 @@ export declare const pipeThroughChannelOrFail: {
      * Pipes values through the provided channel while preserving this stream's
      * failures alongside any channel failures.
      *
+     * **Details**
+     *
      * Upstream failures are not passed to the channel, so the resulting stream can
      * fail with either the original stream error or the channel error.
      *
@@ -11137,6 +11456,8 @@ export declare const pipeThroughChannelOrFail: {
      * Pipes values through the provided channel while preserving this stream's
      * failures alongside any channel failures.
      *
+     * **Details**
+     *
      * Upstream failures are not passed to the channel, so the resulting stream can
      * fail with either the original stream error or the channel error.
      *
@@ -11171,6 +11492,8 @@ export declare const pipeThroughChannelOrFail: {
 /**
  * Pipes the stream through `Sink.toChannel`, emitting only the sink leftovers.
  *
+ * **Details**
+ *
  * If the sink completes mid-chunk, the remaining elements become the output stream.
  *
  * **Example** (Piping through a sink)
@@ -11198,6 +11521,8 @@ export declare const pipeThrough: {
     /**
      * Pipes the stream through `Sink.toChannel`, emitting only the sink leftovers.
      *
+     * **Details**
+     *
      * If the sink completes mid-chunk, the remaining elements become the output stream.
      *
      * **Example** (Piping through a sink)
@@ -11225,6 +11550,8 @@ export declare const pipeThrough: {
     /**
      * Pipes the stream through `Sink.toChannel`, emitting only the sink leftovers.
      *
+     * **Details**
+     *
      * If the sink completes mid-chunk, the remaining elements become the output stream.
      *
      * **Example** (Piping through a sink)
@@ -11403,6 +11730,8 @@ export declare const changesWith: {
 /**
  * Emits only elements that differ from the previous element, using an effectful equality check.
  *
+ * **Details**
+ *
  * The predicate runs for each element after the first; returning `true` treats it as equal and skips it.
  *
  * **Example** (Effectfully emitting changed values)
@@ -11429,6 +11758,8 @@ export declare const changesWithEffect: {
     /**
      * Emits only elements that differ from the previous element, using an effectful equality check.
      *
+     * **Details**
+     *
      * The predicate runs for each element after the first; returning `true` treats it as equal and skips it.
      *
      * **Example** (Effectfully emitting changed values)
@@ -11455,6 +11786,8 @@ export declare const changesWithEffect: {
     /**
      * Emits only elements that differ from the previous element, using an effectful equality check.
      *
+     * **Details**
+     *
      * The predicate runs for each element after the first; returning `true` treats it as equal and skips it.
      *
      * **Example** (Effectfully emitting changed values)
@@ -11630,6 +11963,8 @@ export declare const intersperse: {
 /**
  * Intersperse stream elements with a middle value, adding a start and end value.
  *
+ * **Details**
+ *
  * The start and end values are always emitted, even when the stream is empty.
  *
  * **Example** (Interspersing stream affixes)
@@ -11657,6 +11992,8 @@ export declare const intersperseAffixes: {
     /**
      * Intersperse stream elements with a middle value, adding a start and end value.
      *
+     * **Details**
+     *
      * The start and end values are always emitted, even when the stream is empty.
      *
      * **Example** (Interspersing stream affixes)
@@ -11688,6 +12025,8 @@ export declare const intersperseAffixes: {
     /**
      * Intersperse stream elements with a middle value, adding a start and end value.
      *
+     * **Details**
+     *
      * The start and end values are always emitted, even when the stream is empty.
      *
      * **Example** (Interspersing stream affixes)
@@ -11740,6 +12079,7 @@ export declare const intersperseAffixes: {
  * Effect.runPromise(program)
  * // [2, 5, 3, 6, 7]
  * ```
+ *
  * @category Merging
  * @since 2.0.0
  */
@@ -11767,6 +12107,7 @@ export declare const interleave: {
      * Effect.runPromise(program)
      * // [2, 5, 3, 6, 7]
      * ```
+     *
      * @category Merging
      * @since 2.0.0
      */
@@ -11794,6 +12135,7 @@ export declare const interleave: {
      * Effect.runPromise(program)
      * // [2, 5, 3, 6, 7]
      * ```
+     *
      * @category Merging
      * @since 2.0.0
      */
@@ -11802,6 +12144,8 @@ export declare const interleave: {
 /**
  * Interleaves two streams deterministically by following a boolean decider stream.
  *
+ * **Details**
+ *
  * The decider controls how many elements are pulled; if one side ends, pulls for
  * that side are ignored.
  *
@@ -11833,6 +12177,8 @@ export declare const interleaveWith: {
     /**
      * Interleaves two streams deterministically by following a boolean decider stream.
      *
+     * **Details**
+     *
      * The decider controls how many elements are pulled; if one side ends, pulls for
      * that side are ignored.
      *
@@ -11864,6 +12210,8 @@ export declare const interleaveWith: {
     /**
      * Interleaves two streams deterministically by following a boolean decider stream.
      *
+     * **Details**
+     *
      * The decider controls how many elements are pulled; if one side ends, pulls for
      * that side are ignored.
      *
@@ -11899,6 +12247,8 @@ export declare const interleaveWith: {
  * success will be discarded. This combinator will also interrupt any
  * in-progress element being pulled from upstream.
  *
+ * **Details**
+ *
  * If the effect completes with a failure before the stream completes, the
  * returned stream will emit that failure.
  *
@@ -11936,6 +12286,8 @@ export declare const interruptWhen: {
      * success will be discarded. This combinator will also interrupt any
      * in-progress element being pulled from upstream.
      *
+     * **Details**
+     *
      * If the effect completes with a failure before the stream completes, the
      * returned stream will emit that failure.
      *
@@ -11973,6 +12325,8 @@ export declare const interruptWhen: {
      * success will be discarded. This combinator will also interrupt any
      * in-progress element being pulled from upstream.
      *
+     * **Details**
+     *
      * If the effect completes with a failure before the stream completes, the
      * returned stream will emit that failure.
      *
@@ -12172,6 +12526,8 @@ export declare const onExit: {
 /**
  * Runs the provided effect when the stream fails, passing the failure cause.
  *
+ * **Gotchas**
+ *
  * Note: Unlike `Effect.onError` there is no guarantee that the provided
  * effect will not be interrupted.
  *
@@ -12201,6 +12557,8 @@ export declare const onError: {
     /**
      * Runs the provided effect when the stream fails, passing the failure cause.
      *
+     * **Gotchas**
+     *
      * Note: Unlike `Effect.onError` there is no guarantee that the provided
      * effect will not be interrupted.
      *
@@ -12230,6 +12588,8 @@ export declare const onError: {
     /**
      * Runs the provided effect when the stream fails, passing the failure cause.
      *
+     * **Gotchas**
+     *
      * Note: Unlike `Effect.onError` there is no guarantee that the provided
      * effect will not be interrupted.
      *
@@ -14158,6 +14518,8 @@ export declare const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect
 /**
  * Returns a scoped pull for manually consuming the stream's output chunks.
  *
+ * **Details**
+ *
  * The pull fails with `Cause.Done` when the stream ends and with the stream
  * error on failure.
  *
@@ -14231,6 +14593,8 @@ export declare const mkUint8Array: <E, R>(self: Stream<Uint8Array, E, R>) => Eff
 /**
  * Converts the stream to a `ReadableStream` using the provided services.
  *
+ * **Details**
+ *
  * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
  *
  * **Example** (Converting to a ReadableStream with services)
@@ -14253,6 +14617,8 @@ export declare const toReadableStreamWith: (<A, XR>(context: Context.Context<XR>
 /**
  * Converts a stream to a `ReadableStream`.
  *
+ * **Details**
+ *
  * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
  *
  * **Example** (Converting a stream to a ReadableStream)
@@ -14271,6 +14637,8 @@ export declare const toReadableStream: {
     /**
      * Converts a stream to a `ReadableStream`.
      *
+     * **Details**
+     *
      * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
      *
      * **Example** (Converting a stream to a ReadableStream)
@@ -14291,6 +14659,8 @@ export declare const toReadableStream: {
     /**
      * Converts a stream to a `ReadableStream`.
      *
+     * **Details**
+     *
      * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
      *
      * **Example** (Converting a stream to a ReadableStream)
@@ -14312,6 +14682,8 @@ export declare const toReadableStream: {
 /**
  * Creates an Effect that builds a ReadableStream from the stream.
  *
+ * **Details**
+ *
  * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
  *
  * **Example** (Creating a ReadableStream effect)
@@ -14336,6 +14708,8 @@ export declare const toReadableStreamEffect: {
     /**
      * Creates an Effect that builds a ReadableStream from the stream.
      *
+     * **Details**
+     *
      * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
      *
      * **Example** (Creating a ReadableStream effect)
@@ -14362,6 +14736,8 @@ export declare const toReadableStreamEffect: {
     /**
      * Creates an Effect that builds a ReadableStream from the stream.
      *
+     * **Details**
+     *
      * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
      *
      * **Example** (Creating a ReadableStream effect)
@@ -14528,6 +14904,8 @@ export declare const toAsyncIterable: <A, E>(self: Stream<A, E>) => AsyncIterabl
 /**
  * Runs the stream, publishing elements into the provided PubSub.
  *
+ * **Details**
+ *
  * `shutdownOnEnd` controls whether the PubSub is shut down when the stream ends.
  * It only shuts down when set to `true`.
  *
@@ -14561,6 +14939,8 @@ export declare const runIntoPubSub: {
     /**
      * Runs the stream, publishing elements into the provided PubSub.
      *
+     * **Details**
+     *
      * `shutdownOnEnd` controls whether the PubSub is shut down when the stream ends.
      * It only shuts down when set to `true`.
      *
@@ -14596,6 +14976,8 @@ export declare const runIntoPubSub: {
     /**
      * Runs the stream, publishing elements into the provided PubSub.
      *
+     * **Details**
+     *
      * `shutdownOnEnd` controls whether the PubSub is shut down when the stream ends.
      * It only shuts down when set to `true`.
      *
@@ -14632,6 +15014,8 @@ export declare const runIntoPubSub: {
 /**
  * Converts a stream to a PubSub for concurrent consumption.
  *
+ * **Details**
+ *
  * `shutdownOnEnd` indicates whether the PubSub should be shut down when the
  * stream ends. By default this is `true`.
  *
@@ -14658,6 +15042,8 @@ export declare const toPubSub: {
     /**
      * Converts a stream to a PubSub for concurrent consumption.
      *
+     * **Details**
+     *
      * `shutdownOnEnd` indicates whether the PubSub should be shut down when the
      * stream ends. By default this is `true`.
      *
@@ -14693,6 +15079,8 @@ export declare const toPubSub: {
     /**
      * Converts a stream to a PubSub for concurrent consumption.
      *
+     * **Details**
+     *
      * `shutdownOnEnd` indicates whether the PubSub should be shut down when the
      * stream ends. By default this is `true`.
      *
@@ -14729,6 +15117,8 @@ export declare const toPubSub: {
 /**
  * Converts a stream to a PubSub for concurrent consumption.
  *
+ * **Details**
+ *
  * `Take` values include the stream's end and failure signals.
  *
  * **Example** (Converting to a PubSub of takes)
@@ -14756,6 +15146,8 @@ export declare const toPubSubTake: {
     /**
      * Converts a stream to a PubSub for concurrent consumption.
      *
+     * **Details**
+     *
      * `Take` values include the stream's end and failure signals.
      *
      * **Example** (Converting to a PubSub of takes)
@@ -14790,6 +15182,8 @@ export declare const toPubSubTake: {
     /**
      * Converts a stream to a PubSub for concurrent consumption.
      *
+     * **Details**
+     *
      * `Take` values include the stream's end and failure signals.
      *
      * **Example** (Converting to a PubSub of takes)
@@ -14826,6 +15220,8 @@ export declare const toPubSubTake: {
  * Creates a scoped dequeue that is fed by the stream for concurrent
  * consumption.
  *
+ * **Details**
+ *
  * Elements are offered to the queue as the stream runs. Stream completion is
  * signaled with `Cause.Done`, stream failures fail the queue, and the queue is
  * shut down when the surrounding scope closes.
@@ -14850,6 +15246,8 @@ export declare const toQueue: {
      * Creates a scoped dequeue that is fed by the stream for concurrent
      * consumption.
      *
+     * **Details**
+     *
      * Elements are offered to the queue as the stream runs. Stream completion is
      * signaled with `Cause.Done`, stream failures fail the queue, and the queue is
      * shut down when the surrounding scope closes.
@@ -14879,6 +15277,8 @@ export declare const toQueue: {
      * Creates a scoped dequeue that is fed by the stream for concurrent
      * consumption.
      *
+     * **Details**
+     *
      * Elements are offered to the queue as the stream runs. Stream completion is
      * signaled with `Cause.Done`, stream failures fail the queue, and the queue is
      * shut down when the surrounding scope closes.