The discriminant. Narrow on this, never on instanceof.

Structured payload supplied by the throw site.

Serializes to plain JSON so console.log(JSON.stringify(failure)) is not {}.

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'.

Allowlist mapper from the typed payload to span/log attributes, consumed by attributes. Deliberately not a redaction filter: only what the mapper returns is ever exposed, so sensitive fields are private by omission, not by scrubbing.

The literal code this factory produces. Useful as a switch case and in registries.

Cross-realm type guard narrowing to this exact failure — the flat rethrow line's guard after a Result.try.

The error this failure was derived from. Preserved verbatim and walked by causes().

The function to truncate the stack at, so the top frame is the code that reported the failure rather than the plumbing that built it. Defaults to the constructor.

Skips stack capture. Only worth setting for failures produced in a hot loop and consumed immediately — the capture, not the allocation, is what a Failure costs. See the performance section of the docs before reaching for it.

The serialized cause chain: a nested Failure, or a plain error's identifying fields.

The discriminant. Survives the wire, unlike a prototype.

The structured payload, JSON round-tripped by toJSON so it cannot fail later.

Wire marker. Symbol.for keys survive neither JSON.stringify nor structuredClone, so the serialized form carries an explicit field in the brand's place.

The human-readable sentence, already interpolated from data.

The producing process's stack. Frameless — the header line alone — when the failure was built { stackless: true }; the field itself is absent only if stack was never set.