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

package/dist/Stream.js

@@ -366,6 +366,8 @@ export const tick = interval => fromPull(Effect.sync(() => {
 /**
  * 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.
  *
@@ -420,6 +422,8 @@ export const transformPull = (self, f) => fromChannel(Channel.fromTransform((_,
 /**
  * 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.
  *
@@ -479,6 +483,8 @@ export const toChannel = stream => stream.channel;
 /**
  * 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.
  *
@@ -582,6 +588,8 @@ export const make = (...values) => fromArray(values);
 /**
  * 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)
@@ -605,6 +613,8 @@ export const sync = evaluate => fromChannel(Channel.sync(() => Arr.of(evaluate()
 /**
  * Creates a lazily constructed stream.
  *
+ * **Details**
+ *
  * The stream factory is evaluated each time the stream is run.
  *
  * **Example** (Creating a lazily constructed stream)
@@ -757,6 +767,8 @@ export const failCauseSync = evaluate => fromChannel(Channel.failCauseSync(evalu
 /**
  * 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)
@@ -788,7 +800,7 @@ export const fromIteratorSucceed = (iterator, maxChunkSize) => fromChannel(Chann
 /**
  * Creates a new `Stream` from an iterable collection of values.
  *
- * **Options**
+ * **Details**
  *
  * - `chunkSize`: Maximum number of values emitted per chunk.
  *
@@ -942,6 +954,8 @@ export const fromArrays = (...arrays) => fromChannel(Channel.fromArray(Arr.filte
 /**
  * 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.
  *
@@ -1006,6 +1020,8 @@ export const fromPubSub = pubsub => fromChannel(Channel.fromPubSubArray(pubsub))
 /**
  * Creates a stream from a PubSub of `Take` values.
  *
+ * **Details**
+ *
  * `Take` values include end and failure signals.
  *
  * **Example** (Creating a stream from PubSub takes)
@@ -1037,6 +1053,8 @@ export const fromPubSubTake = pubsub => fromChannel(Channel.fromPubSubTake(pubsu
 /**
  * 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.
@@ -1142,6 +1160,8 @@ export const fromSchedule = schedule => fromPull(Effect.map(Schedule.toStepWithS
 /**
  * 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.
  *
@@ -1215,6 +1235,8 @@ export const fromEventListener = (target, type, options) => callback(queue => {
  * 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.
  *
@@ -1311,6 +1333,8 @@ export const iterate = (value, next) => unfold(value, a => Effect.succeed([a, ne
 /**
  * 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.
  *
@@ -1327,6 +1351,7 @@ export const iterate = (value, next) => unfold(value, a => Effect.succeed([a, ne
  * Effect.runPromise(program)
  * // Output: [ 1, 2, 3, 4, 5 ]
  * ```
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -1593,6 +1618,8 @@ export const mapArrayEffect = /*#__PURE__*/dual(2, (self, f) => fromChannel(Chan
 /**
  * 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)
@@ -1767,6 +1794,8 @@ export const tapSink = /*#__PURE__*/dual(2, (self, sink) => transformPullBracket
 /**
  * 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
@@ -1821,6 +1850,8 @@ export const switchMap = /*#__PURE__*/dual(args => isStream(args[0]), (self, f,
 /**
  * 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
@@ -2005,6 +2036,8 @@ export const timeout = /*#__PURE__*/dual(2, (self, duration) => timeoutOrElse(se
  * 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.
@@ -2214,6 +2247,8 @@ export const prepend = /*#__PURE__*/dual(2, (self, values) => concat(fromIterabl
 /**
  * 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.
  *
@@ -2241,6 +2276,8 @@ export const merge = /*#__PURE__*/dual(args => isStream(args[0]) && isStream(arg
 /**
  * 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.
  *
@@ -2305,6 +2342,8 @@ export const mergeResult = /*#__PURE__*/dual(2, (self, that) => merge(map(self,
 /**
  * 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.
@@ -2333,6 +2372,8 @@ export const mergeLeft = /*#__PURE__*/dual(2, (left, right) => mergeEffect(left,
  * 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.
  *
@@ -2393,6 +2434,8 @@ export const mergeAll = /*#__PURE__*/dual(2, (streams, options) => flatten(fromI
  * 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)
@@ -2418,6 +2461,8 @@ export const cross = /*#__PURE__*/dual(2, (left, right) => crossWith(left, right
 /**
  * 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.
@@ -2480,6 +2525,8 @@ const zipArrays = f => (leftArr, rightArr) => {
 /**
  * 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)
@@ -2573,6 +2620,8 @@ export const zip = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, (a,
  * 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)
@@ -2636,6 +2685,8 @@ export const zipRight = /*#__PURE__*/dual(2, (left, right) => zipWithArray(left,
  * 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)
@@ -2821,6 +2872,8 @@ export const zipWithPreviousAndNext = self => mapAccumArray(self, () => ({
  * 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.
@@ -2870,6 +2923,8 @@ export const zipLatestAll = (...streams) => fromChannel(Channel.suspend(() => {
 /**
  * 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.
@@ -2898,6 +2953,8 @@ export const zipLatest = /*#__PURE__*/dual(2, (left, right) => zipLatestAll(left
  * 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.
@@ -2930,13 +2987,12 @@ export const zipLatestWith = /*#__PURE__*/dual(3, (left, right, f) => map(zipLat
  * 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
@@ -2953,6 +3009,9 @@ export const zipLatestWith = /*#__PURE__*/dual(3, (left, right, f) => map(zipLat
  * Effect.runPromise(program)
  * // Output: [ 0, 1, 2 ]
  * ```
+ *
+ * @category Racing
+ * @since 3.5.0
  */
 export const raceAll = (...streams) => fromChannel(Channel.fromTransform((_, scope) => Effect.sync(() => {
   let winner;
@@ -2975,6 +3034,8 @@ export const raceAll = (...streams) => fromChannel(Channel.fromTransform((_, sco
  * 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.
@@ -3067,6 +3128,8 @@ export const filterMapEffect = /*#__PURE__*/dual(2, (self, filter) => fromChanne
  * 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.
@@ -3145,6 +3208,8 @@ export const partitionQueue = /*#__PURE__*/dual(args => isStream(args[0]), /*#__
  * 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.
@@ -3157,13 +3222,12 @@ export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  * 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
@@ -3182,6 +3246,9 @@ export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  *   // Output: [ 2, 4 ]
  * })
  * ```
+ *
+ * @category filtering
+ * @since 2.0.0
  */
 export const partition = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(self, filter, {
   capacity: options?.bufferSize ?? 16
@@ -3214,6 +3281,8 @@ export const when = /*#__PURE__*/dual(2, (self, test) => test.pipe(Effect.map(pa
  * 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)
@@ -3256,6 +3325,8 @@ export const peel = /*#__PURE__*/dual(2, /*#__PURE__*/Effect.fnUntraced(function
  * 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`
@@ -3286,6 +3357,8 @@ export const buffer = /*#__PURE__*/dual(2, (self, options) => fromChannel(Channe
  * 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
@@ -3432,6 +3505,8 @@ export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Chan
 /**
  * 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.
@@ -3474,7 +3549,7 @@ export const catchFilter = /*#__PURE__*/dual(args => isStream(args[0]), (self, f
  * 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.
@@ -3555,6 +3630,8 @@ export const catchTags = /*#__PURE__*/dual(args => isStream(args[0]), (self, cas
 /**
  * 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.
  *
@@ -3787,6 +3864,8 @@ export const orDie = self => fromChannel(Channel.orDie(self.channel));
 /**
  * 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)
@@ -3830,6 +3909,8 @@ export const ignore = /*#__PURE__*/dual(args => isStream(args[0]), (self, option
 /**
  * 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)
@@ -3856,6 +3937,8 @@ export const ignoreCause = /*#__PURE__*/dual(args => isStream(args[0]), (self, o
 /**
  * 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.
  *
@@ -3890,6 +3973,8 @@ export const retry = /*#__PURE__*/dual(2, (self, policy) => fromChannel(Channel.
  * 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.
@@ -4039,6 +4124,8 @@ export const takeRight = /*#__PURE__*/dual(2, (self, n) => mapAccumArray(self, M
 /**
  * Takes elements until the predicate matches.
  *
+ * **Details**
+ *
  * When `excludeLast` is `true`, the matching element is dropped.
  *
  * **Example** (Taking until a predicate matches)
@@ -4165,6 +4252,8 @@ export const takeWhile = /*#__PURE__*/dual(2, (self, predicate) => transformPull
  * 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
@@ -4271,6 +4360,8 @@ export const dropUntil = /*#__PURE__*/dual(2, (self, predicate) => drop(dropWhil
  * 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)
@@ -4386,6 +4477,8 @@ export const dropWhileEffect = /*#__PURE__*/dual(2, (self, predicate) => transfo
 /**
  * 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)
@@ -4449,6 +4542,8 @@ export const chunks = self => self.channel.pipe(Channel.map(Arr.of), fromChannel
 /**
  * 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)
@@ -4594,6 +4689,8 @@ export const slidingSize = /*#__PURE__*/dual(3, (self, chunkSize, stepSize) => t
 /**
  * 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)
@@ -4638,6 +4735,8 @@ export const split = /*#__PURE__*/dual(2, (self, predicate) => mapAccumArray(sel
  * 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.
  *
@@ -4750,6 +4849,8 @@ export const mapAccum = /*#__PURE__*/dual(args => isStream(args[0]), (self, init
 /**
  * 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)
@@ -4791,6 +4892,8 @@ const emptyArr = /*#__PURE__*/Arr.empty();
  * 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.
@@ -4828,6 +4931,8 @@ export const mapAccumEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self
  * 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.
  *
@@ -5008,6 +5113,8 @@ export const debounce = /*#__PURE__*/dual(2, (self, duration) => transformPull(s
  * 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.
@@ -5105,6 +5212,8 @@ const throttleShapeEffect = (self, cost, units, duration, burst) => transformPul
  * 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.
@@ -5143,6 +5252,8 @@ export const throttle = /*#__PURE__*/dual(2, (self, options) => throttleEffect(s
 /**
  * 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)
@@ -5309,6 +5420,8 @@ const groupByImpl = (self, f, options) => transformPullBracket(self, Effect.fnUn
 /**
  * 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.
@@ -5396,6 +5509,8 @@ export const transduce = /*#__PURE__*/dual(2, (self, sink) => transformPull(self
 /**
  * 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.
  *
@@ -5424,6 +5539,8 @@ export const aggregate = /*#__PURE__*/dual(2, (self, sink) => aggregateWithin(se
 /**
  * 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)
@@ -5508,6 +5625,8 @@ export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fr
  * 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
@@ -5557,6 +5676,8 @@ const makePubSub = options => Effect.acquireRelease(options.capacity === "unboun
 /**
  * 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)
@@ -5591,6 +5712,8 @@ export const broadcast = /*#__PURE__*/dual(2, (self, options) => Effect.map(toPu
 /**
  * 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.
@@ -5627,6 +5750,8 @@ export const share = /*#__PURE__*/dual(2, (self, options) => Effect.map(RcRef.ma
 /**
  * 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.
  *
@@ -5662,6 +5787,8 @@ export const pipeThroughChannel = /*#__PURE__*/dual(2, (self, channel) => fromCh
  * 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.
  *
@@ -5695,6 +5822,8 @@ export const pipeThroughChannelOrFail = /*#__PURE__*/dual(2, (self, channel) =>
 /**
  * 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)
@@ -5844,6 +5973,8 @@ export const changesWith = /*#__PURE__*/dual(2, (self, f) => transformPull(self,
 /**
  * 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)
@@ -6006,6 +6137,8 @@ export const intersperse = /*#__PURE__*/dual(2, (self, element) => mapArray(self
 /**
  * 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)
@@ -6053,6 +6186,7 @@ export const intersperseAffixes = /*#__PURE__*/dual(2, (self, options) => succee
  * Effect.runPromise(program)
  * // [2, 5, 3, 6, 7]
  * ```
+ *
  * @category Merging
  * @since 2.0.0
  */
@@ -6060,6 +6194,8 @@ export const interleave = /*#__PURE__*/dual(2, (self, that) => interleaveWith(se
 /**
  * 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.
  *
@@ -6120,6 +6256,8 @@ export const interleaveWith = /*#__PURE__*/dual(3, (self, that, decider) => from
  * 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.
  *
@@ -6208,6 +6346,8 @@ export const onExit = /*#__PURE__*/dual(2, (self, finalizer) => fromChannel(Chan
 /**
  * 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.
  *
@@ -7032,6 +7172,8 @@ export const runDrain = self => Channel.runDrain(self.channel);
 /**
  * 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.
  *
@@ -7126,6 +7268,8 @@ export const mkUint8Array = self => Effect.map(Channel.runFold(self.channel, ()
 /**
  * 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)
@@ -7177,6 +7321,8 @@ export const toReadableStreamWith = /*#__PURE__*/dual(args => isStream(args[0]),
 /**
  * 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)
@@ -7195,6 +7341,8 @@ export const toReadableStream = /*#__PURE__*/dual(args => isStream(args[0]), (se
 /**
  * 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)
@@ -7338,6 +7486,8 @@ export const toAsyncIterable = self => toAsyncIterableWith(self, Context.empty()
 /**
  * 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`.
  *
@@ -7371,6 +7521,8 @@ export const runIntoPubSub = /*#__PURE__*/dual(args => isStream(args[0]), (self,
 /**
  * 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`.
  *
@@ -7397,6 +7549,8 @@ export const toPubSub = /*#__PURE__*/dual(2, (self, options) => Channel.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)
@@ -7425,6 +7579,8 @@ export const toPubSubTake = /*#__PURE__*/dual(2, (self, options) => Channel.toPu
  * 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.