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

package/src/Stream.ts

@@ -116,6 +116,8 @@ export const TypeId: TypeId = "~effect/Stream"
  * 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.
@@ -192,6 +194,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.
  *
@@ -206,6 +210,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
@@ -595,6 +601,8 @@ export 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.
  *
@@ -665,6 +673,8 @@ export const transformPull = <A, E, R, B, E2, R2, EX, RX>(
 /**
  * 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.
  *
@@ -744,6 +754,8 @@ export const toChannel = <A, E, R>(
 /**
  * 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.
  *
@@ -857,6 +869,8 @@ export const make = <const As extends ReadonlyArray<any>>(...values: As): Stream
 /**
  * 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)
@@ -881,6 +895,8 @@ export const sync = <A>(evaluate: LazyArg<A>): Stream<A> => fromChannel(Channel.
 /**
  * Creates a lazily constructed stream.
  *
+ * **Details**
+ *
  * The stream factory is evaluated each time the stream is run.
  *
  * **Example** (Creating a lazily constructed stream)
@@ -1041,6 +1057,8 @@ export const failCauseSync = <E>(evaluate: LazyArg<Cause.Cause<E>>): Stream<neve
 /**
  * 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)
@@ -1074,7 +1092,7 @@ export const fromIteratorSucceed = <A>(iterator: IterableIterator<A>, maxChunkSi
 /**
  * Creates a new `Stream` from an iterable collection of values.
  *
- * **Options**
+ * **Details**
  *
  * - `chunkSize`: Maximum number of values emitted per chunk.
  *
@@ -1250,6 +1268,8 @@ export 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.
  *
@@ -1317,6 +1337,8 @@ export const fromPubSub = <A>(pubsub: PubSub.PubSub<A>): Stream<A> => fromChanne
 /**
  * Creates a stream from a PubSub of `Take` values.
  *
+ * **Details**
+ *
  * `Take` values include end and failure signals.
  *
  * **Example** (Creating a stream from PubSub takes)
@@ -1350,6 +1372,8 @@ export const fromPubSubTake = <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>): St
 /**
  * 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.
@@ -1479,6 +1503,8 @@ export const fromSchedule = <O, E, R>(schedule: Schedule.Schedule<O, unknown, E,
 /**
  * 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.
  *
@@ -1592,6 +1618,8 @@ export const fromEventListener = <A = unknown>(
  * 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.
  *
@@ -1702,6 +1730,8 @@ export 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.
  *
@@ -1718,6 +1748,7 @@ export 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
  */
@@ -2383,6 +2414,8 @@ export 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)
@@ -2831,6 +2864,8 @@ export 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
@@ -2860,6 +2895,8 @@ export 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
@@ -2895,6 +2932,8 @@ export 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
@@ -3047,6 +3086,8 @@ export 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
@@ -3512,6 +3553,8 @@ export 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.
@@ -3524,6 +3567,8 @@ export 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.
@@ -3541,6 +3586,8 @@ export 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.
@@ -3985,6 +4032,8 @@ export 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.
  *
@@ -4012,6 +4061,8 @@ export 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.
    *
@@ -4044,6 +4095,8 @@ export 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.
    *
@@ -4088,6 +4141,8 @@ export 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.
  *
@@ -4117,6 +4172,8 @@ export 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.
    *
@@ -4146,6 +4203,8 @@ export 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.
    *
@@ -4301,6 +4360,8 @@ export 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.
@@ -4328,6 +4389,8 @@ export 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.
@@ -4355,6 +4418,8 @@ export 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.
@@ -4389,6 +4454,8 @@ export 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.
  *
@@ -4421,6 +4488,8 @@ export 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.
    *
@@ -4453,6 +4522,8 @@ export 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.
    *
@@ -4594,6 +4665,8 @@ export 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)
@@ -4620,6 +4693,8 @@ export 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)
@@ -4646,6 +4721,8 @@ export 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)
@@ -4676,6 +4753,8 @@ export 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.
@@ -4704,6 +4783,8 @@ export 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.
@@ -4732,6 +4813,8 @@ export 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.
@@ -4875,6 +4958,8 @@ const zipArrays = <AL, AR, A>(
 /**
  * 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)
@@ -4908,6 +4993,8 @@ export 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)
@@ -4951,6 +5038,8 @@ export 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)
@@ -5139,6 +5228,8 @@ export 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)
@@ -5166,6 +5257,8 @@ export 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)
@@ -5193,6 +5286,8 @@ export 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)
@@ -5324,6 +5419,8 @@ export 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)
@@ -5355,6 +5452,8 @@ export 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)
@@ -5386,6 +5485,8 @@ export 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)
@@ -5588,6 +5689,8 @@ export const zipWithPreviousAndNext = <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.
@@ -5657,6 +5760,8 @@ export 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.
@@ -5684,6 +5789,8 @@ export 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.
@@ -5711,6 +5818,8 @@ export 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.
@@ -5747,6 +5856,8 @@ export 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.
@@ -5779,6 +5890,8 @@ export 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.
@@ -5811,6 +5924,8 @@ export 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.
@@ -5856,13 +5971,12 @@ export 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
@@ -5879,6 +5993,9 @@ export const zipLatestWith: {
  * Effect.runPromise(program)
  * // Output: [ 0, 1, 2 ]
  * ```
+ *
+ * @category Racing
+ * @since 3.5.0
  */
 export const raceAll = <S extends ReadonlyArray<Stream<any, any, any>>>(
   ...streams: S
@@ -5913,6 +6030,8 @@ export const raceAll = <S extends ReadonlyArray<Stream<any, any, any>>>(
  * 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.
@@ -5944,6 +6063,8 @@ export 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.
@@ -5975,6 +6096,8 @@ export 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.
@@ -6277,6 +6400,8 @@ export 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.
@@ -6311,6 +6436,8 @@ export 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.
@@ -6357,6 +6484,8 @@ export 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.
@@ -6424,6 +6553,8 @@ export 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.
@@ -6457,6 +6588,8 @@ export 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.
@@ -6491,6 +6624,8 @@ export 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.
@@ -6524,6 +6659,8 @@ export 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.
@@ -6601,6 +6738,8 @@ export 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.
@@ -6613,6 +6752,8 @@ export 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.
@@ -6638,6 +6779,8 @@ export 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.
@@ -6682,6 +6825,8 @@ export 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.
@@ -6693,6 +6838,8 @@ export 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.
@@ -6704,6 +6851,8 @@ export 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.
@@ -6715,6 +6864,8 @@ export 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.
@@ -6726,6 +6877,8 @@ export 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.
@@ -6746,13 +6899,12 @@ export 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
@@ -6771,19 +6923,21 @@ export const partitionEffect: {
  *   // Output: [ 2, 4 ]
  * })
  * ```
+ *
+ * @category filtering
+ * @since 2.0.0
  */
 export 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
@@ -6802,6 +6956,9 @@ export const partition: {
    *   // Output: [ 2, 4 ]
    * })
    * ```
+   *
+   * @category filtering
+   * @since 2.0.0
    */
   <A, Pass, Fail>(
     filter: Filter.Filter<NoInfer<A>, Pass, Fail>,
@@ -6817,13 +6974,12 @@ export 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
@@ -6842,6 +6998,9 @@ export const partition: {
    *   // Output: [ 2, 4 ]
    * })
    * ```
+   *
+   * @category filtering
+   * @since 2.0.0
    */
   <A, E, R, Pass, Fail>(
     self: Stream<A, E, R>,
@@ -6954,6 +7113,8 @@ export 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)
@@ -6984,6 +7145,8 @@ export 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)
@@ -7014,6 +7177,8 @@ export 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)
@@ -7069,6 +7234,8 @@ export 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`
@@ -7099,6 +7266,8 @@ export 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`
@@ -7134,6 +7303,8 @@ export 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`
@@ -7178,6 +7349,8 @@ export 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
@@ -7207,6 +7380,8 @@ export 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
@@ -7241,6 +7416,8 @@ export 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
@@ -7625,6 +7802,8 @@ export 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.
@@ -7658,6 +7837,8 @@ export 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.
@@ -7695,6 +7876,8 @@ export 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.
@@ -7732,6 +7915,8 @@ export 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.
@@ -7770,6 +7955,8 @@ export 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.
@@ -7894,7 +8081,7 @@ export 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.
@@ -7929,7 +8116,7 @@ export 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.
@@ -7983,7 +8170,7 @@ export 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.
@@ -8249,6 +8436,8 @@ export 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.
  *
@@ -8294,6 +8483,8 @@ export 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.
    *
@@ -8364,6 +8555,8 @@ export 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.
    *
@@ -9111,6 +9304,8 @@ export const orDie = <A, E, R>(self: Stream<A, E, R>): Stream<A, never, R> => fr
 /**
  * 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)
@@ -9173,6 +9368,8 @@ export const ignore: <
 /**
  * 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)
@@ -9216,6 +9413,8 @@ export const ignoreCause: <
 /**
  * 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.
  *
@@ -9249,6 +9448,8 @@ export 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.
    *
@@ -9288,6 +9489,8 @@ export 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.
    *
@@ -9341,6 +9544,8 @@ export 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.
@@ -9383,6 +9588,8 @@ export 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.
@@ -9428,6 +9635,8 @@ export 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.
@@ -9503,6 +9712,8 @@ export 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.
@@ -9759,6 +9970,8 @@ export const takeRight: {
 /**
  * Takes elements until the predicate matches.
  *
+ * **Details**
+ *
  * When `excludeLast` is `true`, the matching element is dropped.
  *
  * **Example** (Taking until a predicate matches)
@@ -9792,6 +10005,8 @@ export const takeUntil: {
   /**
    * Takes elements until the predicate matches.
    *
+   * **Details**
+   *
    * When `excludeLast` is `true`, the matching element is dropped.
    *
    * **Example** (Taking until a predicate matches)
@@ -9830,6 +10045,8 @@ export const takeUntil: {
   /**
    * Takes elements until the predicate matches.
    *
+   * **Details**
+   *
    * When `excludeLast` is `true`, the matching element is dropped.
    *
    * **Example** (Taking until a predicate matches)
@@ -10156,6 +10373,8 @@ export 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
@@ -10166,6 +10385,8 @@ export 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
@@ -10176,6 +10397,8 @@ export 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
@@ -10463,6 +10686,8 @@ export 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)
@@ -10490,6 +10715,8 @@ export 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)
@@ -10519,6 +10746,8 @@ export 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)
@@ -10790,6 +11019,8 @@ export 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)
@@ -10816,6 +11047,8 @@ export 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)
@@ -10842,6 +11075,8 @@ export 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)
@@ -10874,6 +11109,8 @@ export const dropRight: {
         const list = MutableList.make</**
          * 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)
@@ -10941,6 +11178,8 @@ export const chunks = <A, E, R>(self: Stream<A, E, R>): Stream<Arr.NonEmptyReado
 /**
  * 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)
@@ -10968,6 +11207,8 @@ export 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)
@@ -10995,6 +11236,8 @@ export 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)
@@ -11026,6 +11269,8 @@ export const rechunk: {
       let chunk = Arr.empty</**
        * 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)
@@ -11307,6 +11552,8 @@ export 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)
@@ -11333,6 +11580,8 @@ export 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)
@@ -11359,6 +11608,8 @@ export 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)
@@ -11385,6 +11636,8 @@ export 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)
@@ -11411,6 +11664,8 @@ export 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)
@@ -11442,6 +11697,8 @@ export const split: {
     const out = Arr.empty</**
      * 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)
@@ -11486,6 +11743,8 @@ export 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.
  *
@@ -11521,6 +11780,8 @@ export 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.
    *
@@ -11564,6 +11825,8 @@ export 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.
    *
@@ -11926,6 +12189,8 @@ export 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)
@@ -11956,6 +12221,8 @@ export 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)
@@ -11992,6 +12259,8 @@ export 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)
@@ -12058,6 +12327,8 @@ const emptyArr = Arr.empty<never>()
  * 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.
@@ -12090,6 +12361,8 @@ export 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.
@@ -12128,6 +12401,8 @@ export 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.
@@ -12184,6 +12459,8 @@ export 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.
@@ -12230,6 +12507,8 @@ export 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.
  *
@@ -12264,6 +12543,8 @@ export 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.
    *
@@ -12304,6 +12585,8 @@ export 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.
    *
@@ -12721,6 +13004,8 @@ export 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.
@@ -12759,6 +13044,8 @@ export 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.
@@ -12805,6 +13092,8 @@ export 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.
@@ -12954,6 +13243,8 @@ const throttleShapeEffect = <A, E, R, E2, R2>(
  * 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.
@@ -12991,6 +13282,8 @@ export 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.
@@ -13036,6 +13329,8 @@ export 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.
@@ -13098,6 +13393,8 @@ export 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)
@@ -13124,6 +13421,8 @@ export 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)
@@ -13150,6 +13449,8 @@ export 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)
@@ -13654,6 +13955,8 @@ const groupByImpl = <A, E, R, K, V, E2, R2>(
 /**
  * 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.
@@ -13665,6 +13968,8 @@ export 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.
@@ -13676,6 +13981,8 @@ export 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.
@@ -13695,6 +14002,8 @@ export const groupAdjacentBy: {
       let toEmit = Arr.empty</**
        * 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.
@@ -13851,6 +14160,8 @@ export const transduce = dual<
 /**
  * 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.
  *
@@ -13879,6 +14190,8 @@ export 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.
    *
@@ -13907,6 +14220,8 @@ export 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.
    *
@@ -13940,6 +14255,8 @@ export 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)
@@ -13968,6 +14285,8 @@ export 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)
@@ -13999,6 +14318,8 @@ export 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)
@@ -14041,6 +14362,8 @@ export const aggregateWithin: {
     const buffer = yield* Queue.make</**
      * 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)
@@ -14068,6 +14391,8 @@ export const aggregateWithin: {
     Arr.NonEmptyReadonlyArray<A> | typeof scheduleStep, /**
      * 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)
@@ -14112,6 +14437,8 @@ export const aggregateWithin: {
     let lastOutput = Option.none</**
      * 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)
@@ -14196,6 +14523,8 @@ export 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
@@ -14234,6 +14563,8 @@ export 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
@@ -14283,6 +14614,8 @@ export 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
@@ -14348,6 +14681,8 @@ export 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
@@ -14426,6 +14761,8 @@ const makePubSub = <A>(
 /**
  * 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)
@@ -14460,6 +14797,8 @@ export 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)
@@ -14503,6 +14842,8 @@ export 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)
@@ -14559,6 +14900,8 @@ export 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.
@@ -14592,6 +14935,8 @@ export 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.
@@ -14636,6 +14981,8 @@ export 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.
@@ -14702,6 +15049,8 @@ export 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.
  *
@@ -14736,6 +15085,8 @@ export 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.
    *
@@ -14772,6 +15123,8 @@ export 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.
    *
@@ -14815,6 +15168,8 @@ export 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.
  *
@@ -14849,6 +15204,8 @@ export 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.
    *
@@ -14885,6 +15242,8 @@ export 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.
    *
@@ -14926,6 +15285,8 @@ export 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)
@@ -14953,6 +15314,8 @@ export 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)
@@ -14980,6 +15343,8 @@ export 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)
@@ -15200,6 +15565,8 @@ export 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)
@@ -15226,6 +15593,8 @@ export 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)
@@ -15252,6 +15621,8 @@ export 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)
@@ -15502,6 +15873,8 @@ export 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)
@@ -15529,6 +15902,8 @@ export 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)
@@ -15556,6 +15931,8 @@ export 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)
@@ -15615,6 +15992,7 @@ export const intersperseAffixes: {
  * Effect.runPromise(program)
  * // [2, 5, 3, 6, 7]
  * ```
+ *
  * @category Merging
  * @since 2.0.0
  */
@@ -15642,6 +16020,7 @@ export const interleave: {
    * Effect.runPromise(program)
    * // [2, 5, 3, 6, 7]
    * ```
+   *
    * @category Merging
    * @since 2.0.0
    */
@@ -15669,6 +16048,7 @@ export const interleave: {
    * Effect.runPromise(program)
    * // [2, 5, 3, 6, 7]
    * ```
+   *
    * @category Merging
    * @since 2.0.0
    */
@@ -15686,6 +16066,8 @@ export 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.
  *
@@ -15717,6 +16099,8 @@ export 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.
    *
@@ -15748,6 +16132,8 @@ export 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.
    *
@@ -15800,6 +16186,8 @@ export const interleaveWith: {
         return Effect.succeed</**
          * 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.
          *
@@ -15839,6 +16227,8 @@ export const interleaveWith: {
         return Effect.succeed</**
          * 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.
          *
@@ -15891,6 +16281,8 @@ export 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.
  *
@@ -15928,6 +16320,8 @@ export 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.
    *
@@ -15965,6 +16359,8 @@ export 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.
    *
@@ -16183,6 +16579,8 @@ export 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.
  *
@@ -16212,6 +16610,8 @@ export 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.
    *
@@ -16241,6 +16641,8 @@ export 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.
    *
@@ -18425,6 +18827,8 @@ export const runDrain = <A, E, R>(self: Stream<A, E, R>): Effect.Effect<void, E,
 /**
  * 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.
  *
@@ -18537,6 +18941,8 @@ export const mkUint8Array = <E, R>(self: Stream<Uint8Array, E, R>): Effect.Effec
 /**
  * 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)
@@ -18555,6 +18961,8 @@ export const toReadableStreamWith = dual<
   /**
    * 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)
@@ -18576,6 +18984,8 @@ export const toReadableStreamWith = dual<
   /**
    * 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)
@@ -18645,6 +19055,8 @@ export const toReadableStreamWith = dual<
 /**
  * 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)
@@ -18663,6 +19075,8 @@ export 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)
@@ -18683,6 +19097,8 @@ export 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)
@@ -18712,6 +19128,8 @@ export 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)
@@ -18736,6 +19154,8 @@ export 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)
@@ -18762,6 +19182,8 @@ export 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)
@@ -18796,6 +19218,8 @@ export const toReadableStreamEffect: {
       Effect.context</**
        * 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)
@@ -19009,6 +19433,8 @@ export const toAsyncIterable = <A, E>(self: Stream<A, E>): AsyncIterable<A> =>
 /**
  * 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`.
  *
@@ -19042,6 +19468,8 @@ export 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`.
    *
@@ -19080,6 +19508,8 @@ export 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`.
    *
@@ -19127,6 +19557,8 @@ export 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`.
  *
@@ -19153,6 +19585,8 @@ export 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`.
    *
@@ -19190,6 +19624,8 @@ export 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`.
    *
@@ -19245,6 +19681,8 @@ export 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)
@@ -19272,6 +19710,8 @@ export 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)
@@ -19308,6 +19748,8 @@ export 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)
@@ -19362,6 +19804,8 @@ export 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.
@@ -19386,6 +19830,8 @@ export 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.
@@ -19417,6 +19863,8 @@ export 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.