Elixir's Task.async_stream/3, living at its JS-idiomatic home: maps fn over the source with at most maxConcurrency invocations in flight, lazily — nothing starts until a consumer pulls, and the window refills only as results are taken. Results keep source order by default (ordered: false yields completion order — faster when element durations vary). Each element may deadline (timeoutMs) into a declared Failure('AsyncTimeout') element — the railway, not a crash; the element's signal fires so cancellation-aware work stops. A throw from fn stays a bug. Failure elements from the source pass through unmapped.

The one push source: a handle whose producer emits whenever it likes, and a Stream that consumes what it emitted. Every other builder pulls — unfold, resource and iterate all ask for the next element — but the most common real source in JS cannot be asked: an EventEmitter, a WebSocket, fs.watch, SSE, a browser running tests.

StreamClass#chunkBy as a static: Stream.chunkBy(source, …) is Stream.from(source).chunkBy(…).

StreamClass#chunkEvery as a static: Stream.chunkEvery(source, …) is Stream.from(source).chunkEvery(…).

StreamClass#chunkWhile as a static: Stream.chunkWhile(source, …) is Stream.from(source).chunkWhile(…).

StreamClass#collect as a static: Stream.collect(source, …) is Stream.from(source).collect(…).

Concatenates sources in order — Elixir's Stream.concat, variadic.

Repeats a re-iterable source forever — always bound it (take, takeWhile).

StreamClass#dedup as a static: Stream.dedup(source, …) is Stream.from(source).dedup(…).

StreamClass#dedupBy as a static: Stream.dedupBy(source, …) is Stream.from(source).dedupBy(…).

StreamClass#drop as a static: Stream.drop(source, …) is Stream.from(source).drop(…).

StreamClass#dropEvery as a static: Stream.dropEvery(source, …) is Stream.from(source).dropEvery(…).

StreamClass#dropWhile as a static: Stream.dropWhile(source, …) is Stream.from(source).dropWhile(…).

count copies of one value.

StreamClass#every as a static: Stream.every(source, …) is Stream.from(source).every(…).

StreamClass#filter as a static: Stream.filter(source, …) is Stream.from(source).filter(…).

StreamClass#find as a static: Stream.find(source, …) is Stream.from(source).find(…).

StreamClass#flatMap as a static: Stream.flatMap(source, …) is Stream.from(source).flatMap(…).

StreamClass#forEach as a static: Stream.forEach(source, …) is Stream.from(source).forEach(…).

Lifts a source into a Stream. Elements that are Failures are the E channel from the start; everything else is T.

The infinite integers offset, offset + 1, … — Elixir's Stream.from_index/1.

StreamClass#intersperse as a static: Stream.intersperse(source, …) is Stream.from(source).intersperse(…).

Emits 0, 1, 2, … every ms milliseconds, forever — Elixir's Stream.interval/1, on setTimeout (universal). Infinite: always bound it.

StreamClass#into as a static: Stream.into(source, …) is Stream.from(source).into(…).

seed, fn(seed), fn(fn(seed)), … — Elixir's Stream.iterate/2, infinite.

Decodes a byte stream into text lines — the front door for NDJSON, logs, and SSE-ish feeds. Handles multi-byte characters and lines split across chunk boundaries; the final unterminated line is flushed.

StreamClass#map as a static: Stream.map(source, …) is Stream.from(source).map(…).

StreamClass#mapConcurrent as a static: Stream.mapConcurrent(source, …) is Stream.from(source).mapConcurrent(…).

StreamClass#mapEvery as a static: Stream.mapEvery(source, …) is Stream.from(source).mapEvery(…).

StreamClass#partition as a static: Stream.partition(source, …) is Stream.from(source).partition(…).

StreamClass#reduce as a static: Stream.reduce(source, …) is Stream.from(source).reduce(…).

StreamClass#reject as a static: Stream.reject(source, …) is Stream.from(source).reject(…).

Calls fn for each pull, forever — Elixir's Stream.repeatedly/1.

unfold with lifecycle hooks — Elixir's Stream.resource/3: start runs on first pull, next is unfold's step, and after ALWAYS runs — normal end, early take, or a throw. (Plain generators already get this via try/finally; resource is for when the setup/teardown pair deserves to be explicit.)

StreamClass#results as a static: Stream.results(source, …) is Stream.from(source).results(…).

StreamClass#run as a static: Stream.run(source, …) is Stream.from(source).run(…).

Emits the running fold of the values — Elixir's Stream.scan; without initial the first value seeds the accumulator. Failures pass through and leave the accumulator untouched.

StreamClass#some as a static: Stream.some(source, …) is Stream.from(source).some(…).

StreamClass#take as a static: Stream.take(source, …) is Stream.from(source).take(…).

StreamClass#takeEvery as a static: Stream.takeEvery(source, …) is Stream.from(source).takeEvery(…).

StreamClass#takeWhile as a static: Stream.takeWhile(source, …) is Stream.from(source).takeWhile(…).

StreamClass#tap as a static: Stream.tap(source, …) is Stream.from(source).tap(…).

StreamClass#through as a static: Stream.through(source, …) is Stream.from(source).through(…).

Emits a single 0 after ms milliseconds, then ends — Elixir's Stream.timer/1.

Elixir's Stream.unfold/2: grow a lazy stream from a seed. next(state) returns [element, nextState] to emit and continue, or null to end; return [failure, null] to emit a declared failure and stop. Nothing runs until a consumer pulls — pagination only fetches the pages the consumer actually reaches.

StreamClass#uniq as a static: Stream.uniq(source, …) is Stream.from(source).uniq(…).

StreamClass#uniqBy as a static: Stream.uniqBy(source, …) is Stream.from(source).uniqBy(…).

StreamClass#withIndex as a static: Stream.withIndex(source, …) is Stream.from(source).withIndex(…).

Zips sources in lockstep, ending at the shortest (Elixir's Stream.zip) and closing the longer sources so their cleanup runs. JS divergences: sources are pulled sequentially per slot, and a failure element passes through bare without consuming from the other sources — failures cannot pair.

zip plus a combiner — Elixir's Stream.zip_with; the tuple arrives spread.

Rejects the consuming Task with reason — the two-tier rule's bug tier. Idempotent.

Elements buffered for a consumer that has not taken them yet.

Ends the stream once the buffer drains. Idempotent.

Whether the channel has been closed, aborted, or abandoned by its consumer.

How many elements the buffer has lost to overflow. 0 unless a consumer fell behind.

Offers a value. Returns false when there is no room left — Node's write() convention: advisory for a producer that can slow down, ignorable for one that cannot.

Offers a declared failure as an element — the railway, not a rejection.

Resolves once there is room to emit again — Web Streams' writer.ready, and the promise form of Node's 'drain'.

The consuming half. One consumer only; a second pass throws.

How many elements to buffer for a consumer that has not taken them yet. Default 10_000.

Called once, when a consumer first attaches. A producer that can defer starting should start here: it is the difference between a buffer that stays near empty and one that races ahead of a consumer that has not arrived.

Called with each element the buffer actually lost, and the depth after the loss. The only place overflow is observable — make it fatal from here by calling fail or abort.

What to do once capacity is reached: drop from either end, or 'fail' — end the stream with a ChannelOverflowFailure element instead of losing anything quietly. Default 'dropOldest'.