effect 4.0.0-beta.71 → 4.0.0-beta.73

package/dist/Stream.d.ts

@@ -111,7 +111,7 @@ import type * as Unify from "./Unify.ts";
 /**
  * String literal type used as the unique brand for `Stream` values.
  *
- * @category Type Identifiers
+ * @category type IDs
  * @since 4.0.0
  */
 export type TypeId = "~effect/Stream";
@@ -119,14 +119,14 @@ export type TypeId = "~effect/Stream";
  * Runtime identifier stored on `Stream` values and used by `isStream` to
  * recognize them.
  *
- * **When to use**
+ * **Details**
  *
- * Use when implementing low-level `Stream` integrations that need direct access
- * to the runtime brand checked by `isStream`.
+ * This marker is part of the runtime representation of `Stream` values. Prefer
+ * `isStream` when narrowing unknown values.
  *
  * @see {@link isStream} for the public guard that checks this identifier
  *
- * @category Type Identifiers
+ * @category type IDs
  * @since 4.0.0
  */
 export declare const TypeId: TypeId;
@@ -366,8 +366,7 @@ export type HaltStrategy = Channel.HaltStrategy;
  */
 export declare const fromChannel: <Arr extends Arr.NonEmptyReadonlyArray<any>, E, R>(channel: Channel.Channel<Arr, E, void, unknown, unknown, unknown, R>) => Stream<Arr extends Arr.NonEmptyReadonlyArray<infer A> ? A : never, E, R>;
 /**
- * Either emits the success value of this effect or terminates the stream
- * with the failure value of this effect.
+ * Creates a stream from an effect.
  *
  * **Example** (Creating a stream from an effect)
  *
@@ -425,6 +424,11 @@ export declare const service: <I, S>(service: Context.Key<I, S>) => Stream<S, ne
  * Optionally accesses a service from the context and emits the result as a
  * single element.
  *
+ * **When to use**
+ *
+ * Use to emit an optional dependency as a stream element without requiring that
+ * dependency to be present.
+ *
  * **Example** (Accessing an optional service as a stream)
  *
  * ```ts
@@ -589,7 +593,7 @@ export declare const tick: (interval: Duration.Input) => Stream<void>;
  */
 export declare const fromPull: <A, E, R, EX, RX>(pull: Effect.Effect<Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E, void, R>, EX, RX>) => Stream<A, Pull.ExcludeDone<E> | EX, R | RX>;
 /**
- * Derive a stream by transforming its pull effect.
+ * Derives a stream by transforming its pull effect.
  *
  * **Example** (Transforming a pull effect)
  *
@@ -1468,9 +1472,17 @@ export declare const fromEventListener: <A = unknown>(target: EventListener<A>,
  */
 export declare const unfold: <S, A, E, R>(s: S, f: (s: S) => Effect.Effect<readonly [A, S] | undefined, E, R>) => Stream<A, E, R>;
 /**
- * Like `Stream.unfold`, but allows the emission of values to end one step further
- * than the unfolding of the state. This is useful for embedding paginated APIs,
- * hence the name.
+ * Creates a stream by repeatedly evaluating an effectful page function.
+ *
+ * **When to use**
+ *
+ * Use to consume paginated APIs where each step returns a batch of values
+ * together with an optional next state.
+ *
+ * **Details**
+ *
+ * This is similar to {@link unfold}, but each step can emit zero or more values
+ * and independently decide whether another state should be requested.
  *
  * **Example** (Paginating stream state)
  *
@@ -2020,7 +2032,7 @@ export declare const flattenEffect: <Arg extends Stream<Effect.Effect<any, any,
     readonly unordered?: boolean | undefined;
 } | undefined) => [Arg] extends [Stream<Effect.Effect<infer _A, infer _EX, infer _RX>, infer _E, infer _R>] ? Stream<_A, _EX | _E, _RX | _R> : <A, EX, RX, E, R>(self: Stream<Effect.Effect<A, EX, RX>, E, R>) => Stream<A, EX | E, RX | R>;
 /**
- * Effectfully maps over non-empty array chunks emitted by the stream.
+ * Maps over non-empty array chunks emitted by the stream effectfully.
  *
  * **Example** (Effectfully mapping stream chunks)
  *
@@ -2047,7 +2059,7 @@ export declare const flattenEffect: <Arg extends Stream<Effect.Effect<any, any,
  */
 export declare const mapArrayEffect: {
     /**
-     * Effectfully maps over non-empty array chunks emitted by the stream.
+     * Maps over non-empty array chunks emitted by the stream effectfully.
      *
      * **Example** (Effectfully mapping stream chunks)
      *
@@ -2074,7 +2086,7 @@ export declare const mapArrayEffect: {
      */
     <A, B, E2, R2>(f: (a: Arr.NonEmptyReadonlyArray<A>, i: number) => Effect.Effect<Arr.NonEmptyReadonlyArray<B>, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<B, E | E2, R | R2>;
     /**
-     * Effectfully maps over non-empty array chunks emitted by the stream.
+     * Maps over non-empty array chunks emitted by the stream effectfully.
      *
      * **Example** (Effectfully mapping stream chunks)
      *
@@ -2350,8 +2362,7 @@ export declare const tapBoth: {
     }): Stream<A, E | E2 | E3, R | R2 | R3>;
 };
 /**
- * Sends all elements emitted by this stream to the specified sink in addition
- * to emitting them.
+ * Runs a sink for all stream elements while still emitting them downstream.
  *
  * **Example** (Tapping values with a sink)
  *
@@ -2382,8 +2393,7 @@ export declare const tapBoth: {
  */
 export declare const tapSink: {
     /**
-     * Sends all elements emitted by this stream to the specified sink in addition
-     * to emitting them.
+     * Runs a sink for all stream elements while still emitting them downstream.
      *
      * **Example** (Tapping values with a sink)
      *
@@ -2414,8 +2424,7 @@ export declare const tapSink: {
      */
     <A, E2, R2>(sink: Sink.Sink<unknown, A, unknown, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
     /**
-     * Sends all elements emitted by this stream to the specified sink in addition
-     * to emitting them.
+     * Runs a sink for all stream elements while still emitting them downstream.
      *
      * **Example** (Tapping values with a sink)
      *
@@ -2880,7 +2889,7 @@ export declare const repeat: {
     <A, E, R, B, E2, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, void, E2, R2> | (($: <SO, SE, SR>(_: Schedule.Schedule<SO, void, SE, SR>) => Schedule.Schedule<SO, void, SE, SR>) => Schedule.Schedule<B, void, E2, R2>)): Stream<A, E | E2, R | R2>;
 };
 /**
- * Spaces the stream's elements according to the provided `schedule`.
+ * Schedules the stream's elements according to the provided schedule.
  *
  * **Example** (Scheduling stream elements)
  *
@@ -2900,12 +2909,12 @@ export declare const repeat: {
  * // Output: [ 1, 2, 3 ]
  * ```
  *
- * @category Rate Limiting
+ * @category rate limiting
  * @since 2.0.0
  */
 export declare const schedule: {
     /**
-     * Spaces the stream's elements according to the provided `schedule`.
+     * Schedules the stream's elements according to the provided schedule.
      *
      * **Example** (Scheduling stream elements)
      *
@@ -2925,12 +2934,12 @@ export declare const schedule: {
      * // Output: [ 1, 2, 3 ]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     <X, E2, R2, A>(schedule: Schedule.Schedule<X, NoInfer<A>, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>;
     /**
-     * Spaces the stream's elements according to the provided `schedule`.
+     * Schedules the stream's elements according to the provided schedule.
      *
      * **Example** (Scheduling stream elements)
      *
@@ -2950,7 +2959,7 @@ export declare const schedule: {
      * // Output: [ 1, 2, 3 ]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     <A, E, R, X, E2, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<X, NoInfer<A>, E2, R2>): Stream<A, E | E2, R | R2>;
@@ -2976,7 +2985,7 @@ export declare const schedule: {
  * // Output: [ 1 ]
  * ```
  *
- * @category Rate Limiting
+ * @category rate limiting
  * @since 2.0.0
  */
 export declare const timeout: {
@@ -3001,7 +3010,7 @@ export declare const timeout: {
      * // Output: [ 1 ]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
@@ -3026,7 +3035,7 @@ export declare const timeout: {
      * // Output: [ 1 ]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>;
@@ -3052,7 +3061,7 @@ export declare const timeout: {
  *
  * @see {@link timeout} for ending the stream instead of switching to a fallback stream
  *
- * @category Rate Limiting
+ * @category rate limiting
  * @since 4.0.0
  */
 export declare const timeoutOrElse: {
@@ -3077,7 +3086,7 @@ export declare const timeoutOrElse: {
      *
      * @see {@link timeout} for ending the stream instead of switching to a fallback stream
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 4.0.0
      */
     <B, E2, R2>(options: {
@@ -3105,7 +3114,7 @@ export declare const timeoutOrElse: {
      *
      * @see {@link timeout} for ending the stream instead of switching to a fallback stream
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 4.0.0
      */
     <A, E, R, B, E2, R2>(self: Stream<A, E, R>, options: {
@@ -3216,7 +3225,7 @@ export declare const repeatElements: {
  */
 export declare const forever: <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
 /**
- * Submerges the iterables emitted by this stream into the stream's structure.
+ * Flattens the iterables emitted by this stream into the stream's structure.
  *
  * **Example** (Flattening iterable values)
  *
@@ -5378,7 +5387,7 @@ export declare const filterMap: {
     <A, E, R, B, X>(self: Stream<A, E, R>, filter: Filter.Filter<A, B, X>): Stream<B, E, R>;
 };
 /**
- * Effectfully filters elements in a single pass.
+ * Filters elements in a single pass effectfully.
  *
  * **Example** (Effectfully filtering stream values)
  *
@@ -5401,7 +5410,7 @@ export declare const filterMap: {
  */
 export declare const filterEffect: {
     /**
-     * Effectfully filters elements in a single pass.
+     * Filters elements in a single pass effectfully.
      *
      * **Example** (Effectfully filtering stream values)
      *
@@ -5424,7 +5433,7 @@ export declare const filterEffect: {
      */
     <A, EX, RX>(predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<A, E | EX, R | RX>;
     /**
-     * Effectfully filters elements in a single pass.
+     * Filters elements in a single pass effectfully.
      *
      * **Example** (Effectfully filtering stream values)
      *
@@ -5448,7 +5457,7 @@ export declare const filterEffect: {
     <A, E, R, EX, RX>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, EX, RX>): Stream<A, E | EX, R | RX>;
 };
 /**
- * Effectfully filters and maps elements in one pass using a `FilterEffect`.
+ * Filters and maps elements in one pass effectfully using a `FilterEffect`.
  *
  * **When to use**
  *
@@ -5469,7 +5478,7 @@ export declare const filterEffect: {
  */
 export declare const filterMapEffect: {
     /**
-     * Effectfully filters and maps elements in one pass using a `FilterEffect`.
+     * Filters and maps elements in one pass effectfully using a `FilterEffect`.
      *
      * **When to use**
      *
@@ -5490,7 +5499,7 @@ export declare const filterMapEffect: {
      */
     <A, B, X, EX, RX>(filter: Filter.FilterEffect<NoInfer<A>, B, X, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<B, E | EX, R | RX>;
     /**
-     * Effectfully filters and maps elements in one pass using a `FilterEffect`.
+     * Filters and maps elements in one pass effectfully using a `FilterEffect`.
      *
      * **When to use**
      *
@@ -6020,7 +6029,7 @@ export declare const peel: {
  * // Output: [ 1, 2, 3 ]
  * ```
  *
- * @category Rate Limiting
+ * @category rate limiting
  * @since 2.0.0
  */
 export declare const buffer: {
@@ -6052,7 +6061,7 @@ export declare const buffer: {
      * // Output: [ 1, 2, 3 ]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     (options: {
@@ -6089,7 +6098,7 @@ export declare const buffer: {
      * // Output: [ 1, 2, 3 ]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, options: {
@@ -6126,7 +6135,7 @@ export declare const buffer: {
  * // Output: [ 1, 2, 3, 4 ]
  * ```
  *
- * @category Rate Limiting
+ * @category rate limiting
  * @since 4.0.0
  */
 export declare const bufferArray: {
@@ -6157,7 +6166,7 @@ export declare const bufferArray: {
      * // Output: [ 1, 2, 3, 4 ]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 4.0.0
      */
     (options: {
@@ -6193,7 +6202,7 @@ export declare const bufferArray: {
      * // Output: [ 1, 2, 3, 4 ]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 4.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, options: {
@@ -6420,7 +6429,7 @@ export {
  */
 catch_ as catch };
 /**
- * Effectfully peeks at errors without changing the stream unless the tap fails.
+ * Peeks at errors effectfully without changing the stream unless the tap fails.
  *
  * **Example** (Effectfully peeking at errors)
  *
@@ -6449,7 +6458,7 @@ catch_ as catch };
  */
 export declare const tapError: {
     /**
-     * Effectfully peeks at errors without changing the stream unless the tap fails.
+     * Peeks at errors effectfully without changing the stream unless the tap fails.
      *
      * **Example** (Effectfully peeking at errors)
      *
@@ -6478,7 +6487,7 @@ export declare const tapError: {
      */
     <E, A2, E2, R2>(f: (error: E) => Effect.Effect<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>;
     /**
-     * Effectfully peeks at errors without changing the stream unless the tap fails.
+     * Peeks at errors effectfully without changing the stream unless the tap fails.
      *
      * **Example** (Effectfully peeking at errors)
      *
@@ -7795,7 +7804,7 @@ export declare const ignoreCause: <Arg extends Stream<any, any, any> | {
     readonly log?: boolean | Severity | undefined;
 } | undefined) => [Arg] extends [Stream<infer A, infer _E, infer R>] ? Stream<A, never, R> : <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R>;
 /**
- * When the stream fails, retry it according to the given schedule.
+ * Retries the stream according to the given schedule when it fails.
  *
  * **Details**
  *
@@ -7830,7 +7839,7 @@ export declare const ignoreCause: <Arg extends Stream<any, any, any> | {
  */
 export declare const retry: {
     /**
-     * When the stream fails, retry it according to the given schedule.
+     * Retries the stream according to the given schedule when it fails.
      *
      * **Details**
      *
@@ -7865,7 +7874,7 @@ export declare const retry: {
      */
     <E, X, E2, R2>(policy: Schedule.Schedule<X, NoInfer<E>, E2, R2> | (($: <SO, SE, SR>(_: Schedule.Schedule<SO, NoInfer<E>, SE, SR>) => Schedule.Schedule<SO, E, SE, SR>) => Schedule.Schedule<X, NoInfer<E>, E2, R2>)): <A, R>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>;
     /**
-     * When the stream fails, retry it according to the given schedule.
+     * Retries the stream according to the given schedule when it fails.
      *
      * **Details**
      *
@@ -7901,7 +7910,7 @@ export declare const retry: {
     <A, E, R, X, E2, R2>(self: Stream<A, E, R>, policy: Schedule.Schedule<X, NoInfer<E>, E2, R2> | (($: <SO, SE, SR>(_: Schedule.Schedule<SO, NoInfer<E>, SE, SR>) => Schedule.Schedule<SO, E, SE, SR>) => Schedule.Schedule<X, NoInfer<E>, E2, R2>)): Stream<A, E | E2, R2 | R>;
 };
 /**
- * Apply an `ExecutionPlan` to a stream, retrying with step-provided resources
+ * Applies an `ExecutionPlan` to a stream, retrying with step-provided resources
  * until it succeeds or the plan is exhausted.
  *
  * **Details**
@@ -7945,7 +7954,7 @@ export declare const retry: {
  */
 export declare const withExecutionPlan: {
     /**
-     * Apply an `ExecutionPlan` to a stream, retrying with step-provided resources
+     * Applies an `ExecutionPlan` to a stream, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
      *
      * **Details**
@@ -7996,7 +8005,7 @@ export declare const withExecutionPlan: {
         readonly preventFallbackOnPartialStream?: boolean | undefined;
     }): <A, E extends Input, R>(self: Stream<A, E, R>) => Stream<A, E | PolicyE, R2 | Exclude<R, Provides>>;
     /**
-     * Apply an `ExecutionPlan` to a stream, retrying with step-provided resources
+     * Applies an `ExecutionPlan` to a stream, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
      *
      * **Details**
@@ -8304,7 +8313,7 @@ export declare const takeUntil: {
     }): Stream<A, E, R>;
 };
 /**
- * Effectful predicate version of `takeUntil`.
+ * Takes stream elements until an effectful predicate returns `true`.
  *
  * **Example** (Taking until an effectful predicate matches)
  *
@@ -8328,7 +8337,7 @@ export declare const takeUntil: {
  */
 export declare const takeUntilEffect: {
     /**
-     * Effectful predicate version of `takeUntil`.
+     * Takes stream elements until an effectful predicate returns `true`.
      *
      * **Example** (Taking until an effectful predicate matches)
      *
@@ -8354,7 +8363,7 @@ export declare const takeUntilEffect: {
         readonly excludeLast?: boolean | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
     /**
-     * Effectful predicate version of `takeUntil`.
+     * Takes stream elements until an effectful predicate returns `true`.
      *
      * **Example** (Taking until an effectful predicate matches)
      *
@@ -9190,12 +9199,12 @@ export declare const dropRight: {
  * // Output: [ [ 1, 2 ], [ 3, 4 ] ]
  * ```
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const chunks: <A, E, R>(self: Stream<A, E, R>) => Stream<Arr.NonEmptyReadonlyArray<A>, E, R>;
 /**
- * Re-chunks the stream into arrays of the specified size, preserving element order.
+ * Groups the stream into arrays of the specified size, preserving element order.
  *
  * **Details**
  *
@@ -9219,12 +9228,12 @@ export declare const chunks: <A, E, R>(self: Stream<A, E, R>) => Stream<Arr.NonE
  * // Output: [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]
  * ```
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const rechunk: {
     /**
-     * Re-chunks the stream into arrays of the specified size, preserving element order.
+     * Groups the stream into arrays of the specified size, preserving element order.
      *
      * **Details**
      *
@@ -9248,12 +9257,12 @@ export declare const rechunk: {
      * // Output: [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     (size: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
-     * Re-chunks the stream into arrays of the specified size, preserving element order.
+     * Groups the stream into arrays of the specified size, preserving element order.
      *
      * **Details**
      *
@@ -9277,7 +9286,7 @@ export declare const rechunk: {
      * // Output: [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, size: number): Stream<A, E, R>;
@@ -9301,7 +9310,7 @@ export declare const rechunk: {
  * // Output: [ [1, 2], [2, 3], [3, 4], [4, 5] ]
  * ```
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const sliding: {
@@ -9324,7 +9333,7 @@ export declare const sliding: {
      * // Output: [ [1, 2], [2, 3], [3, 4], [4, 5] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     (chunkSize: number): <A, E, R>(self: Stream<A, E, R>) => Stream<Arr.NonEmptyReadonlyArray<A>, E, R>;
@@ -9347,7 +9356,7 @@ export declare const sliding: {
      * // Output: [ [1, 2], [2, 3], [3, 4], [4, 5] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, chunkSize: number): Stream<Arr.NonEmptyReadonlyArray<A>, E, R>;
@@ -9372,7 +9381,7 @@ export declare const sliding: {
  * // Output: [ [ 1, 2, 3 ], [ 3, 4, 5 ] ]
  * ```
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const slidingSize: {
@@ -9396,7 +9405,7 @@ export declare const slidingSize: {
      * // Output: [ [ 1, 2, 3 ], [ 3, 4, 5 ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     (chunkSize: number, stepSize: number): <A, E, R>(self: Stream<A, E, R>) => Stream<Arr.NonEmptyReadonlyArray<A>, E, R>;
@@ -9420,7 +9429,7 @@ export declare const slidingSize: {
      * // Output: [ [ 1, 2, 3 ], [ 3, 4, 5 ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, chunkSize: number, stepSize: number): Stream<Arr.NonEmptyReadonlyArray<A>, E, R>;
@@ -9449,7 +9458,7 @@ export declare const slidingSize: {
  * // Output: [ [1, 2, 3], [5, 6, 7], [9] ]
  * ```
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const split: {
@@ -9477,7 +9486,7 @@ export declare const split: {
      * // Output: [ [1, 2, 3], [5, 6, 7], [9] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: Stream<A, E, R>) => Stream<Arr.NonEmptyReadonlyArray<Exclude<A, B>>, E, R>;
@@ -9505,7 +9514,7 @@ export declare const split: {
      * // Output: [ [1, 2, 3], [5, 6, 7], [9] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<Arr.NonEmptyReadonlyArray<A>, E, R>;
@@ -9533,7 +9542,7 @@ export declare const split: {
      * // Output: [ [1, 2, 3], [5, 6, 7], [9] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<Arr.NonEmptyReadonlyArray<Exclude<A, B>>, E, R>;
@@ -9561,7 +9570,7 @@ export declare const split: {
      * // Output: [ [1, 2, 3], [5, 6, 7], [9] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<Arr.NonEmptyReadonlyArray<A>, E, R>;
@@ -9679,11 +9688,18 @@ export declare const combine: {
     <A, E, R, A2, E2, R2, S, A3, E3, R3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, s: LazyArg<S>, f: (s: S, pullLeft: Pull.Pull<A, E, void>, pullRight: Pull.Pull<A2, E2, void>) => Effect.Effect<readonly [A3, S], E3, R3>): Stream<A3, E3, R | R2 | R3>;
 };
 /**
- * Combines the arrays (chunks) from this stream and the specified stream by
- * repeatedly applying the function `f` to extract an array using both sides and
- * conceptually "offer" it to the destination stream. `f` can maintain some
- * internal state to control the combining process, with the initial state
- * being specified by `s`.
+ * Combines two streams chunk-by-chunk with a stateful pull function.
+ *
+ * **When to use**
+ *
+ * Use to coordinate pulling chunks from two streams when each emitted chunk
+ * depends on both sides and local state.
+ *
+ * **Details**
+ *
+ * The combining function receives the current state and pull functions for the
+ * left and right streams. It returns the next non-empty chunk together with the
+ * next state.
  *
  * **Example** (Combining stream chunks with state)
  *
@@ -9716,11 +9732,18 @@ export declare const combine: {
  */
 export declare const combineArray: {
     /**
-     * Combines the arrays (chunks) from this stream and the specified stream by
-     * repeatedly applying the function `f` to extract an array using both sides and
-     * conceptually "offer" it to the destination stream. `f` can maintain some
-     * internal state to control the combining process, with the initial state
-     * being specified by `s`.
+     * Combines two streams chunk-by-chunk with a stateful pull function.
+     *
+     * **When to use**
+     *
+     * Use to coordinate pulling chunks from two streams when each emitted chunk
+     * depends on both sides and local state.
+     *
+     * **Details**
+     *
+     * The combining function receives the current state and pull functions for the
+     * left and right streams. It returns the next non-empty chunk together with the
+     * next state.
      *
      * **Example** (Combining stream chunks with state)
      *
@@ -9753,11 +9776,18 @@ export declare const combineArray: {
      */
     <A2, E2, R2, S, E, A, A3, E3, R3>(that: Stream<A2, E2, R2>, s: LazyArg<S>, f: (s: S, pullLeft: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E, void>, pullRight: Pull.Pull<Arr.NonEmptyReadonlyArray<A2>, E2, void>) => Effect.Effect<readonly [Arr.NonEmptyReadonlyArray<A3>, S], E3, R3>): <R>(self: Stream<A, E, R>) => Stream<A3, Pull.ExcludeDone<E3>, R2 | R3 | R>;
     /**
-     * Combines the arrays (chunks) from this stream and the specified stream by
-     * repeatedly applying the function `f` to extract an array using both sides and
-     * conceptually "offer" it to the destination stream. `f` can maintain some
-     * internal state to control the combining process, with the initial state
-     * being specified by `s`.
+     * Combines two streams chunk-by-chunk with a stateful pull function.
+     *
+     * **When to use**
+     *
+     * Use to coordinate pulling chunks from two streams when each emitted chunk
+     * depends on both sides and local state.
+     *
+     * **Details**
+     *
+     * The combining function receives the current state and pull functions for the
+     * left and right streams. It returns the next non-empty chunk together with the
+     * next state.
      *
      * **Example** (Combining stream chunks with state)
      *
@@ -9791,7 +9821,7 @@ export declare const combineArray: {
     <R, A2, E2, R2, S, E, A, A3, E3, R3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, s: LazyArg<S>, f: (s: S, pullLeft: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E, void>, pullRight: Pull.Pull<Arr.NonEmptyReadonlyArray<A2>, E2, void>) => Effect.Effect<readonly [Arr.NonEmptyReadonlyArray<A3>, S], E3, R3>): Stream<A3, Pull.ExcludeDone<E3>, R | R2 | R3>;
 };
 /**
- * Statefully maps elements, emitting zero or more outputs per input.
+ * Maps elements statefully, emitting zero or more outputs per input.
  *
  * **Example** (Statefully mapping stream values)
  *
@@ -9819,7 +9849,7 @@ export declare const combineArray: {
  */
 export declare const mapAccum: {
     /**
-     * Statefully maps elements, emitting zero or more outputs per input.
+     * Maps elements statefully, emitting zero or more outputs per input.
      *
      * **Example** (Statefully mapping stream values)
      *
@@ -9849,7 +9879,7 @@ export declare const mapAccum: {
         readonly onHalt?: ((state: S) => ReadonlyArray<B>) | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
     /**
-     * Statefully maps elements, emitting zero or more outputs per input.
+     * Maps elements statefully, emitting zero or more outputs per input.
      *
      * **Example** (Statefully mapping stream values)
      *
@@ -9880,7 +9910,7 @@ export declare const mapAccum: {
     }): Stream<B, E, R>;
 };
 /**
- * Statefully maps over non-empty chunk arrays, emitting zero or more values per chunk.
+ * Maps over non-empty chunk arrays statefully, emitting zero or more values per chunk.
  *
  * **Details**
  *
@@ -9912,7 +9942,7 @@ export declare const mapAccum: {
  */
 export declare const mapAccumArray: {
     /**
-     * Statefully maps over non-empty chunk arrays, emitting zero or more values per chunk.
+     * Maps over non-empty chunk arrays statefully, emitting zero or more values per chunk.
      *
      * **Details**
      *
@@ -9946,7 +9976,7 @@ export declare const mapAccumArray: {
         readonly onHalt?: ((state: S) => ReadonlyArray<B>) | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
     /**
-     * Statefully maps over non-empty chunk arrays, emitting zero or more values per chunk.
+     * Maps over non-empty chunk arrays statefully, emitting zero or more values per chunk.
      *
      * **Details**
      *
@@ -9981,7 +10011,7 @@ export declare const mapAccumArray: {
     }): Stream<B, E, R>;
 };
 /**
- * Statefully and effectfully maps each element, emitting zero or more output
+ * Maps each element statefully and effectfully, emitting zero or more output
  * values per input.
  *
  * **Details**
@@ -10015,7 +10045,7 @@ export declare const mapAccumArray: {
  */
 export declare const mapAccumEffect: {
     /**
-     * Statefully and effectfully maps each element, emitting zero or more output
+     * Maps each element statefully and effectfully, emitting zero or more output
      * values per input.
      *
      * **Details**
@@ -10051,7 +10081,7 @@ export declare const mapAccumEffect: {
         readonly onHalt?: ((state: S) => ReadonlyArray<B>) | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<B, E | E2, R | R2>;
     /**
-     * Statefully and effectfully maps each element, emitting zero or more output
+     * Maps each element statefully and effectfully, emitting zero or more output
      * values per input.
      *
      * **Details**
@@ -10088,7 +10118,7 @@ export declare const mapAccumEffect: {
     }): Stream<B, E | E2, R | R2>;
 };
 /**
- * Statefully and effectfully maps each non-empty input chunk, emitting zero or
+ * Maps each non-empty input chunk statefully and effectfully, emitting zero or
  * more output values per chunk.
  *
  * **Details**
@@ -10124,7 +10154,7 @@ export declare const mapAccumEffect: {
  */
 export declare const mapAccumArrayEffect: {
     /**
-     * Statefully and effectfully maps each non-empty input chunk, emitting zero or
+     * Maps each non-empty input chunk statefully and effectfully, emitting zero or
      * more output values per chunk.
      *
      * **Details**
@@ -10162,7 +10192,7 @@ export declare const mapAccumArrayEffect: {
         readonly onHalt?: ((state: S) => ReadonlyArray<B>) | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<B, E | E2, R | R2>;
     /**
-     * Statefully and effectfully maps each non-empty input chunk, emitting zero or
+     * Maps each non-empty input chunk statefully and effectfully, emitting zero or
      * more output values per chunk.
      *
      * **Details**
@@ -10274,7 +10304,7 @@ export declare const scan: {
     <A, E, R, S>(self: Stream<A, E, R>, initial: S, f: (s: S, a: A) => S): Stream<S, E, R>;
 };
 /**
- * Effectfully accumulates state and emits the initial state plus each accumulated state.
+ * Accumulates state effectfully and emits the initial state plus each accumulated state.
  *
  * **Example** (Effectfully scanning stream state)
  *
@@ -10296,7 +10326,7 @@ export declare const scan: {
  */
 export declare const scanEffect: {
     /**
-     * Effectfully accumulates state and emits the initial state plus each accumulated state.
+     * Accumulates state effectfully and emits the initial state plus each accumulated state.
      *
      * **Example** (Effectfully scanning stream state)
      *
@@ -10318,7 +10348,7 @@ export declare const scanEffect: {
      */
     <S, A, E2, R2>(initial: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<S, E | E2, R | R2>;
     /**
-     * Effectfully accumulates state and emits the initial state plus each accumulated state.
+     * Accumulates state effectfully and emits the initial state plus each accumulated state.
      *
      * **Example** (Effectfully scanning stream state)
      *
@@ -10361,7 +10391,7 @@ export declare const scanEffect: {
  * })
  * ```
  *
- * @category Rate Limiting
+ * @category rate limiting
  * @since 2.0.0
  */
 export declare const debounce: {
@@ -10386,7 +10416,7 @@ export declare const debounce: {
      * })
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
@@ -10411,19 +10441,23 @@ export declare const debounce: {
      * })
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>;
 };
 /**
- * Delays the arrays of this stream according to the given bandwidth
- * parameters using the token bucket algorithm. Allows for burst processing by
- * allowing the bucket to accumulate tokens up to a `units + burst` threshold.
- * The weight of each array is determined by the effectful `cost` function.
+ * Rate-limits stream chunks with an effectful cost function.
+ *
+ * **When to use**
+ *
+ * Use to throttle chunks when computing each chunk's cost requires an effect.
  *
  * **Details**
  *
+ * Uses a token bucket. The bucket can accumulate up to `units + burst` tokens,
+ * and each chunk consumes the cost returned by the effectful `cost` function.
+ *
  * 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.
@@ -10452,18 +10486,22 @@ export declare const debounce: {
  * // Output: [0, 1, 2, 3, 4, 5]
  * ```
  *
- * @category Rate Limiting
+ * @category rate limiting
  * @since 2.0.0
  */
 export declare const throttleEffect: {
     /**
-     * Delays the arrays of this stream according to the given bandwidth
-     * parameters using the token bucket algorithm. Allows for burst processing by
-     * allowing the bucket to accumulate tokens up to a `units + burst` threshold.
-     * The weight of each array is determined by the effectful `cost` function.
+     * Rate-limits stream chunks with an effectful cost function.
+     *
+     * **When to use**
+     *
+     * Use to throttle chunks when computing each chunk's cost requires an effect.
      *
      * **Details**
      *
+     * Uses a token bucket. The bucket can accumulate up to `units + burst` tokens,
+     * and each chunk consumes the cost returned by the effectful `cost` function.
+     *
      * 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.
@@ -10492,7 +10530,7 @@ export declare const throttleEffect: {
      * // Output: [0, 1, 2, 3, 4, 5]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     <A, E2, R2>(options: {
@@ -10503,13 +10541,17 @@ export declare const throttleEffect: {
         readonly strategy?: "enforce" | "shape" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
     /**
-     * Delays the arrays of this stream according to the given bandwidth
-     * parameters using the token bucket algorithm. Allows for burst processing by
-     * allowing the bucket to accumulate tokens up to a `units + burst` threshold.
-     * The weight of each array is determined by the effectful `cost` function.
+     * Rate-limits stream chunks with an effectful cost function.
+     *
+     * **When to use**
+     *
+     * Use to throttle chunks when computing each chunk's cost requires an effect.
      *
      * **Details**
      *
+     * Uses a token bucket. The bucket can accumulate up to `units + burst` tokens,
+     * and each chunk consumes the cost returned by the effectful `cost` function.
+     *
      * 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.
@@ -10538,7 +10580,7 @@ export declare const throttleEffect: {
      * // Output: [0, 1, 2, 3, 4, 5]
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     <A, E, R, E2, R2>(self: Stream<A, E, R>, options: {
@@ -10550,12 +10592,17 @@ export declare const throttleEffect: {
     }): Stream<A, E | E2, R | R2>;
 };
 /**
- * Delays the arrays of this stream using a token bucket and a per-array cost.
- * Allows bursts by letting the bucket accumulate up to a `units + burst`
- * threshold. The weight of each array is determined by the `cost` function.
+ * Rate-limits stream chunks with a synchronous cost function.
+ *
+ * **When to use**
+ *
+ * Use to throttle chunks when each chunk's cost can be computed synchronously.
  *
  * **Details**
  *
+ * Uses a token bucket. The bucket can accumulate up to `units + burst` tokens,
+ * and each chunk consumes the cost returned by `cost`.
+ *
  * 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.
@@ -10584,17 +10631,22 @@ export declare const throttleEffect: {
  * })
  * ```
  *
- * @category Rate Limiting
+ * @category rate limiting
  * @since 2.0.0
  */
 export declare const throttle: {
     /**
-     * Delays the arrays of this stream using a token bucket and a per-array cost.
-     * Allows bursts by letting the bucket accumulate up to a `units + burst`
-     * threshold. The weight of each array is determined by the `cost` function.
+     * Rate-limits stream chunks with a synchronous cost function.
+     *
+     * **When to use**
+     *
+     * Use to throttle chunks when each chunk's cost can be computed synchronously.
      *
      * **Details**
      *
+     * Uses a token bucket. The bucket can accumulate up to `units + burst` tokens,
+     * and each chunk consumes the cost returned by `cost`.
+     *
      * 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.
@@ -10623,7 +10675,7 @@ export declare const throttle: {
      * })
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     <A>(options: {
@@ -10634,12 +10686,17 @@ export declare const throttle: {
         readonly strategy?: "enforce" | "shape" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
-     * Delays the arrays of this stream using a token bucket and a per-array cost.
-     * Allows bursts by letting the bucket accumulate up to a `units + burst`
-     * threshold. The weight of each array is determined by the `cost` function.
+     * Rate-limits stream chunks with a synchronous cost function.
+     *
+     * **When to use**
+     *
+     * Use to throttle chunks when each chunk's cost can be computed synchronously.
      *
      * **Details**
      *
+     * Uses a token bucket. The bucket can accumulate up to `units + burst` tokens,
+     * and each chunk consumes the cost returned by `cost`.
+     *
      * 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.
@@ -10668,7 +10725,7 @@ export declare const throttle: {
      * })
      * ```
      *
-     * @category Rate Limiting
+     * @category rate limiting
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, options: {
@@ -10703,7 +10760,7 @@ export declare const throttle: {
  * // Output: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8 ] ]
  * ```
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const grouped: {
@@ -10731,7 +10788,7 @@ export declare const grouped: {
      * // Output: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8 ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<Arr.NonEmptyReadonlyArray<A>, E, R>;
@@ -10759,7 +10816,7 @@ export declare const grouped: {
      * // Output: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8 ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, n: number): Stream<Arr.NonEmptyReadonlyArray<A>, E, R>;
@@ -10785,7 +10842,7 @@ export declare const grouped: {
  * // Output: [ [ 1, 2 ], [ 3 ] ]
  * ```
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const groupedWithin: {
@@ -10810,7 +10867,7 @@ export declare const groupedWithin: {
      * // Output: [ [ 1, 2 ], [ 3 ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     (chunkSize: number, duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<Array<A>, E, R>;
@@ -10835,7 +10892,7 @@ export declare const groupedWithin: {
      * // Output: [ [ 1, 2 ], [ 3 ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.Input): Stream<Array<A>, E, R>;
@@ -10869,7 +10926,7 @@ export declare const groupedWithin: {
  * // Output: [ [ "odd", [ 1, 3, 5 ] ], [ "even", [ 2, 4 ] ] ]
  * ```
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const groupBy: {
@@ -10902,7 +10959,7 @@ export declare const groupBy: {
      * // Output: [ [ "odd", [ 1, 3, 5 ] ], [ "even", [ 2, 4 ] ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, K, V, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
@@ -10938,7 +10995,7 @@ export declare const groupBy: {
      * // Output: [ [ "odd", [ 1, 3, 5 ] ], [ "even", [ 2, 4 ] ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R, K, V, E2, R2>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
@@ -10973,7 +11030,7 @@ export declare const groupBy: {
  * // Output: [ [ "odd", [ 1, 3, 5 ] ], [ "even", [ 2, 4 ] ] ]
  * ```
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const groupByKey: {
@@ -11004,7 +11061,7 @@ export declare const groupByKey: {
      * // Output: [ [ "odd", [ 1, 3, 5 ] ], [ "even", [ 2, 4 ] ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, K>(f: (a: NoInfer<A>) => K, options?: {
@@ -11038,7 +11095,7 @@ export declare const groupByKey: {
      * // Output: [ [ "odd", [ 1, 3, 5 ] ], [ "even", [ 2, 4 ] ] ]
      * ```
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R, K>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => K, options?: {
@@ -11064,7 +11121,7 @@ export declare const groupByKey: {
  * @see {@link groupByKey} for grouping all elements with the same key across the stream
  * @see {@link groupBy} for custom grouped stream construction
  *
- * @category Grouping
+ * @category grouping
  * @since 2.0.0
  */
 export declare const groupAdjacentBy: {
@@ -11086,7 +11143,7 @@ export declare const groupAdjacentBy: {
      * @see {@link groupByKey} for grouping all elements with the same key across the stream
      * @see {@link groupBy} for custom grouped stream construction
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, K>(f: (a: NoInfer<A>) => K): <E, R>(self: Stream<A, E, R>) => Stream<readonly [K, Arr.NonEmptyArray<A>], E, R>;
@@ -11108,7 +11165,7 @@ export declare const groupAdjacentBy: {
      * @see {@link groupByKey} for grouping all elements with the same key across the stream
      * @see {@link groupBy} for custom grouped stream construction
      *
-     * @category Grouping
+     * @category grouping
      * @since 2.0.0
      */
     <A, E, R, K>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => K): Stream<readonly [K, Arr.NonEmptyArray<A>], E, R>;
@@ -11319,7 +11376,7 @@ export declare const aggregateWithin: {
     <A, E, R, B, A2, E2, R2, C, E3, R3>(self: Stream<A, E, R>, sink: Sink.Sink<B, A | A2, A2, E2, R2>, schedule: Schedule.Schedule<C, Option.Option<B>, E3, R3>): Stream<B, E | E2 | E3, R | R2 | R3>;
 };
 /**
- * Fan out the stream, producing a fixed-size tuple of streams that each emit
+ * Creates a fixed-size tuple of streams that each emit
  * the same elements as the source stream.
  *
  * **Details**
@@ -11359,7 +11416,7 @@ export declare const aggregateWithin: {
  */
 export declare const broadcastN: {
     /**
-     * Fan out the stream, producing a fixed-size tuple of streams that each emit
+     * Creates a fixed-size tuple of streams that each emit
      * the same elements as the source stream.
      *
      * **Details**
@@ -11408,7 +11465,7 @@ export declare const broadcastN: {
         readonly replay?: number | undefined;
     }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>;
     /**
-     * Fan out the stream, producing a fixed-size tuple of streams that each emit
+     * Creates a fixed-size tuple of streams that each emit
      * the same elements as the source stream.
      *
      * **Details**
@@ -12394,7 +12451,7 @@ export declare const intersperse: {
     <A, E, R, A2>(self: Stream<A, E, R>, element: A2): Stream<A | A2, E, R>;
 };
 /**
- * Intersperse stream elements with a middle value, adding a start and end value.
+ * Adds a start value, middle value, and end value around stream elements.
  *
  * **Details**
  *
@@ -12423,7 +12480,7 @@ export declare const intersperse: {
  */
 export declare const intersperseAffixes: {
     /**
-     * Intersperse stream elements with a middle value, adding a start and end value.
+     * Adds a start value, middle value, and end value around stream elements.
      *
      * **Details**
      *
@@ -12456,7 +12513,7 @@ export declare const intersperseAffixes: {
         readonly end: A4;
     }): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A3 | A4 | A, E, R>;
     /**
-     * Intersperse stream elements with a middle value, adding a start and end value.
+     * Adds a start value, middle value, and end value around stream elements.
      *
      * **Details**
      *
@@ -12793,7 +12850,21 @@ export declare const interruptWhen: {
     <A, E, R, X, E2, R2>(self: Stream<A, E, R>, effect: Effect.Effect<X, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
- * Halts evaluation after the current element once the provided effect completes; the effect is forked, its success is discarded, failures fail the stream, and it does not interrupt an in-progress pull (use `interruptWhen` for that).
+ * Stops a stream after the current element when an effect completes.
+ *
+ * **When to use**
+ *
+ * Use to stop before the next pull after an external signal completes.
+ *
+ * **Details**
+ *
+ * The effect is forked, its success value is discarded, and its failure fails
+ * the stream.
+ *
+ * **Gotchas**
+ *
+ * This does not interrupt an in-progress pull. Use {@link interruptWhen} when
+ * the stream should be interrupted immediately.
  *
  * **Example** (Halting a stream after an effect completes)
  *
@@ -12820,7 +12891,21 @@ export declare const interruptWhen: {
  */
 export declare const haltWhen: {
     /**
-     * Halts evaluation after the current element once the provided effect completes; the effect is forked, its success is discarded, failures fail the stream, and it does not interrupt an in-progress pull (use `interruptWhen` for that).
+     * Stops a stream after the current element when an effect completes.
+     *
+     * **When to use**
+     *
+     * Use to stop before the next pull after an external signal completes.
+     *
+     * **Details**
+     *
+     * The effect is forked, its success value is discarded, and its failure fails
+     * the stream.
+     *
+     * **Gotchas**
+     *
+     * This does not interrupt an in-progress pull. Use {@link interruptWhen} when
+     * the stream should be interrupted immediately.
      *
      * **Example** (Halting a stream after an effect completes)
      *
@@ -12847,7 +12932,21 @@ export declare const haltWhen: {
      */
     <X, E2, R2>(effect: Effect.Effect<X, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
     /**
-     * Halts evaluation after the current element once the provided effect completes; the effect is forked, its success is discarded, failures fail the stream, and it does not interrupt an in-progress pull (use `interruptWhen` for that).
+     * Stops a stream after the current element when an effect completes.
+     *
+     * **When to use**
+     *
+     * Use to stop before the next pull after an external signal completes.
+     *
+     * **Details**
+     *
+     * The effect is forked, its success value is discarded, and its failure fails
+     * the stream.
+     *
+     * **Gotchas**
+     *
+     * This does not interrupt an in-progress pull. Use {@link interruptWhen} when
+     * the stream should be interrupted immediately.
      *
      * **Example** (Halting a stream after an effect completes)
      *
@@ -15463,7 +15562,7 @@ export declare const runIntoPubSub: {
     } | undefined): Effect.Effect<void, never, R>;
 };
 /**
- * Converts a stream to a PubSub for concurrent consumption.
+ * Converts a stream to a PubSub of emitted values for concurrent consumption.
  *
  * **Details**
  *
@@ -15491,7 +15590,7 @@ export declare const runIntoPubSub: {
  */
 export declare const toPubSub: {
     /**
-     * Converts a stream to a PubSub for concurrent consumption.
+     * Converts a stream to a PubSub of emitted values for concurrent consumption.
      *
      * **Details**
      *
@@ -15528,7 +15627,7 @@ export declare const toPubSub: {
         readonly shutdownOnEnd?: boolean | undefined;
     }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<A>, never, R | Scope.Scope>;
     /**
-     * Converts a stream to a PubSub for concurrent consumption.
+     * Converts a stream to a PubSub of emitted values for concurrent consumption.
      *
      * **Details**
      *
@@ -15566,7 +15665,7 @@ export declare const toPubSub: {
     }): Effect.Effect<PubSub.PubSub<A>, never, R | Scope.Scope>;
 };
 /**
- * Converts a stream to a PubSub for concurrent consumption.
+ * Converts a stream to a PubSub of `Take` values for concurrent consumption.
  *
  * **Details**
  *
@@ -15595,7 +15694,7 @@ export declare const toPubSub: {
  */
 export declare const toPubSubTake: {
     /**
-     * Converts a stream to a PubSub for concurrent consumption.
+     * Converts a stream to a PubSub of `Take` values for concurrent consumption.
      *
      * **Details**
      *
@@ -15631,7 +15730,7 @@ export declare const toPubSubTake: {
         readonly replay?: number | undefined;
     }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, R | Scope.Scope>;
     /**
-     * Converts a stream to a PubSub for concurrent consumption.
+     * Converts a stream to a PubSub of `Take` values for concurrent consumption.
      *
      * **Details**
      *