The node:stream/iter module provides a streaming API built on iterables\nrather than the event-driven Readable/Writable/Transform class hierarchy,\nor the Web Streams ReadableStream/WritableStream/TransformStream interfaces.
Streams are represented as AsyncIterable (async) or Iterable (sync). There\nare no base classes to extend -- any\nobject implementing the iterable protocol can participate. Transforms are plain\nfunctions or objects with a transform method.
Data flows in batches (Uint8Array[] per iteration) to amortize the cost\nof async operations.
The module implements the WinterTC Iterable Streams API draft. The\nclassic stream interop functions (fromReadable(), fromWritable(),\ntoReadable(), toReadableSync() and toWritable()),\nBroadcast.from(), Share.from(), SyncShare.fromSync() and the\nprotocol symbols exported by Stream are Node.js extensions that are not part\nof the draft.
import { from, pull, text } from 'node:stream/iter';\nimport { compressGzip, decompressGzip } from 'node:zlib/iter';\n\n// Compress and decompress a string\nconst compressed = pull(from('Hello, world!'), compressGzip());\nconst result = await text(pull(compressed, decompressGzip()));\nconsole.log(result); // 'Hello, world!'\nconst { from, pull, text } = require('node:stream/iter');\nconst { compressGzip, decompressGzip } = require('node:zlib/iter');\n\nasync function run() {\n // Compress and decompress a string\n const compressed = pull(from('Hello, world!'), compressGzip());\n const result = await text(pull(compressed, decompressGzip()));\n console.log(result); // 'Hello, world!'\n}\n\nrun().catch(console.error);\nimport { open } from 'node:fs/promises';\nimport { text, pipeTo } from 'node:stream/iter';\nimport { compressGzip, decompressGzip } from 'node:zlib/iter';\n\n// Read a file, compress, write to another file\nconst src = await open('input.txt', 'r');\nconst dst = await open('output.gz', 'w');\nawait pipeTo(src.pull(), compressGzip(), dst.writer({ autoClose: true }));\nawait src.close();\n\n// Read it back\nconst gz = await open('output.gz', 'r');\nconsole.log(await text(gz.pull(decompressGzip(), { autoClose: true })));\nconst { open } = require('node:fs/promises');\nconst { text, pipeTo } = require('node:stream/iter');\nconst { compressGzip, decompressGzip } = require('node:zlib/iter');\n\nasync function run() {\n // Read a file, compress, write to another file\n const src = await open('input.txt', 'r');\n const dst = await open('output.gz', 'w');\n await pipeTo(src.pull(), compressGzip(), dst.writer({ autoClose: true }));\n await src.close();\n\n // Read it back\n const gz = await open('output.gz', 'r');\n console.log(await text(gz.pull(decompressGzip(), { autoClose: true })));\n}\n\nrun().catch(console.error);\nAll data in this API is represented as Uint8Array bytes. Strings\nare automatically UTF-8 encoded when passed to from(), push(), or\npipeTo(). This removes ambiguity around encodings and enables zero-copy\ntransfers between streams and native code.
Each iteration yields a batch -- an Array of Uint8Array chunks\n(Uint8Array[]). Batching amortizes the cost of await and Promise creation\nacross multiple chunks. A consumer that processes one chunk at a time can\nsimply iterate the inner array:
for await (const batch of source) {\n for (const chunk of batch) {\n handle(chunk);\n }\n}\nasync function run() {\n for await (const batch of source) {\n for (const chunk of batch) {\n handle(chunk);\n }\n }\n}\nTransforms come in two forms:
\nStateless -- a function (chunks, options) => result called once per\nbatch. Receives Uint8Array[] (or null as the flush signal) and an\noptions object. Returns Uint8Array[] | null | Iterable.
Stateful -- an object { transform(source, options) } where transform\nis a generator (sync or async) that receives the entire upstream iterable\nand an options object, and yields output. This form is used for\ncompression, encryption, and any transform that needs to buffer across\nbatches.
Both forms receive an options parameter with the following property:
options.signal AbortSignal An AbortSignal that fires when the pipeline\nis cancelled, encounters an error, or the consumer stops reading. Transforms\ncan check signal.aborted or listen for the 'abort' event to perform\nearly cleanup.The flush signal (null) is sent after the source ends, giving transforms\na chance to emit trailing data (e.g., compression footers).
// Stateless: uppercase transform\nconst upper = (chunks) => {\n if (chunks === null) return null; // flush\n return chunks.map((c) => new TextEncoder().encode(\n new TextDecoder().decode(c).toUpperCase(),\n ));\n};\n\n// Stateful: line splitter\nconst lines = {\n transform: async function*(source) {\n let partial = '';\n for await (const chunks of source) {\n if (chunks === null) {\n if (partial) yield [new TextEncoder().encode(partial)];\n continue;\n }\n for (const chunk of chunks) {\n const str = partial + new TextDecoder().decode(chunk);\n const parts = str.split('\\n');\n partial = parts.pop();\n for (const line of parts) {\n yield [new TextEncoder().encode(`${line}\\n`)];\n }\n }\n }\n },\n};\nThe API supports two models:
\nPull -- data flows on demand. pull() and pullSync() create lazy\npipelines that only read from the source when the consumer iterates.
Push -- data is written explicitly. push() creates a writer/readable\npair with backpressure. The writer pushes data in; the readable is consumed\nas an async iterable.
Pull streams have natural backpressure -- the consumer drives the pace, so\nthe source is never read faster than the consumer can process. Push streams\nneed explicit backpressure because the producer and consumer run\nindependently. The budget and backpressure options on push(),\nbroadcast(), and share() control how this works.
Push streams use a two-part buffering system. Think of it like a bucket\n(buffer) being filled through a hose (pending writes), with a float valve\nthat closes when the bucket is full:
\n budget (e.g., 16384)\n |\n Producer v\n | +---------+\n v | |\n [ write() ] ----+ +--->| buffer |---> Consumer pulls\n [ write() ] | | | (bucket)| for await (...)\n [ write() ] v | +---------+\n +--------+ ^\n | pending| |\n | writes | float valve\n | (hose) | (backpressure)\n +--------+\n ^\n |\n 'strict' mode limits this too!\nBuffer (the bucket) -- data ready for the consumer, capped at\nbudget bytes. When the consumer pulls, it drains all buffered data\nat once into a single batch.
Pending writes (the hose) -- writes waiting for buffer space. After\nthe consumer drains, pending writes are promoted into the now-empty\nbuffer and their promises settle.
\nHow each policy uses these buffers:
\n| Policy | \nBuffer limit | \nPending writes limit | \n
|---|---|---|
'strict' | \nbudget | \n1 | \n
'unbounded' | \nbudget | \nUnbounded | \n
'drop-oldest' | \nbudget | \nN/A (never waits) | \n
'drop-newest' | \nbudget | \nN/A (never waits) | \n
Strict mode catches \"fire-and-forget\" patterns where the producer calls\nwrite() without awaiting, which would cause unbounded memory growth.\nIt limits the buffer to budget bytes and the pending writes queue\nto a single entry.
If you properly await each write, you can only ever have one pending\nwrite at a time (yours), so you never hit the pending writes limit.\nUnawaited writes accumulate in the pending queue and throw once it\noverflows:
\nimport { push, text } from 'node:stream/iter';\n\nconst { writer, readable } = push({ budget: 16384 });\n\n// Consumer must run concurrently -- without it, the first write\n// that fills the buffer blocks the producer forever.\nconst consuming = text(readable);\n\n// GOOD: awaited writes. The producer waits for the consumer to\n// make room when the buffer is full.\nfor (const item of dataset) {\n await writer.write(item);\n}\nawait writer.end();\nconsole.log(await consuming);\nconst { push, text } = require('node:stream/iter');\n\nasync function run() {\n const { writer, readable } = push({ budget: 16384 });\n\n // Consumer must run concurrently -- without it, the first write\n // that fills the buffer blocks the producer forever.\n const consuming = text(readable);\n\n // GOOD: awaited writes. The producer waits for the consumer to\n // make room when the buffer is full.\n for (const item of dataset) {\n await writer.write(item);\n }\n await writer.end();\n console.log(await consuming);\n}\n\nrun().catch(console.error);\nForgetting to await will eventually throw:
// BAD: fire-and-forget. Strict mode throws once both buffers fill.\nfor (const item of dataset) {\n writer.write(item); // Not awaited -- queues without bound\n}\n// --> throws \"Backpressure violation: too many pending writes\"\nUnbounded mode caps buffered bytes at budget but places no limit on the\npending writes queue. Awaited writes block until the consumer makes room,\njust like strict mode. The difference is that unawaited writes silently\nqueue forever instead of throwing -- a potential memory leak if the\nproducer forgets to await.
This is the mode that existing Node.js classic streams and Web Streams\ndefault to. Use it when you control the producer and know it awaits\nproperly, or when migrating code from those APIs.
\nimport { push, text } from 'node:stream/iter';\n\nconst { writer, readable } = push({\n budget: 16384,\n backpressure: 'unbounded',\n});\n\nconst consuming = text(readable);\n\n// Safe -- awaited writes block until the consumer reads.\nfor (const item of dataset) {\n await writer.write(item);\n}\nawait writer.end();\nconsole.log(await consuming);\nconst { push, text } = require('node:stream/iter');\n\nasync function run() {\n const { writer, readable } = push({\n budget: 16384,\n backpressure: 'unbounded',\n });\n\n const consuming = text(readable);\n\n // Safe -- awaited writes block until the consumer reads.\n for (const item of dataset) {\n await writer.write(item);\n }\n await writer.end();\n console.log(await consuming);\n}\n\nrun().catch(console.error);\nWrites never wait. When the slots buffer is full, the oldest buffered\nchunk is evicted to make room for the incoming write. The consumer\nalways sees the most recent data. Useful for live feeds, telemetry, or\nany scenario where stale data is less valuable than current data.
\nimport { push } from 'node:stream/iter';\n\n// Keep only the most recent ~16 KB of readings\nconst { writer, readable } = push({\n budget: 16384,\n backpressure: 'drop-oldest',\n});\nconst { push } = require('node:stream/iter');\n\n// Keep only the most recent ~16 KB of readings\nconst { writer, readable } = push({\n budget: 16384,\n backpressure: 'drop-oldest',\n});\nWrites never wait. When the slots buffer is full, the incoming write is\nsilently discarded. The consumer processes what is already buffered\nwithout being overwhelmed by new data. Useful for rate-limiting or\nshedding load under pressure.
\nimport { push } from 'node:stream/iter';\n\n// Accept up to 16 KB of buffered data; discard anything beyond that\nconst { writer, readable } = push({\n budget: 16384,\n backpressure: 'drop-newest',\n});\nconst { push } = require('node:stream/iter');\n\n// Accept up to 16 KB of buffered data; discard anything beyond that\nconst { writer, readable } = push({\n budget: 16384,\n backpressure: 'drop-newest',\n});\nA writer is any object conforming to the Writer interface. Only write() is\nrequired; all other methods are optional.
Writer arguments use Web IDL conversion semantics. A non-Uint8Array chunk is\nconverted to a USVString and then UTF-8 encoded. writev() and\nwritevSync() accept any iterable object whose values can be converted to\nchunks. Writer option dictionaries treat null as an empty dictionary and\nignore unknown members.
Arguments are converted before the write itself starts. If the conversion runs\nuser code (for example a toString() method, or the iterator of a writev()\nargument) that writes to the same writer, those writes are ordered before the\nwrite whose argument is being converted, and they count against the same\nbackpressure limits.
After end() or endSync() has been called, and until all buffered data has\nbeen consumed, the writer is closing. While closing, canWrite is null,\nwrite() and writev() reject with a TypeError, writeSync() and\nwritevSync() return false, endSync() returns -1, and calling end()\nagain returns the same promise as the first call.
Each async method has a synchronous *Sync counterpart designed for a\ntry-fallback pattern: attempt the fast synchronous path first, and fall back\nto the async version only when the synchronous call indicates it could not\ncomplete:
if (!writer.writeSync(chunk)) await writer.write(chunk);\nif (!writer.writevSync(chunks)) await writer.writev(chunks);\nif (writer.endSync() < 0) await writer.end();\nwriter.fail(err); // Always synchronous, no fallback needed\nReturns true if the slots buffer has physical capacity (buffered data is\nbelow the configured byte budget), false if the budget is exhausted, or\nnull if the writer is closed or the consumer has disconnected.
This reports physical capacity independently of the backpressure policy. With\n'drop-oldest' or 'drop-newest', writes still complete when this is false\nby evicting buffered data or discarding the incoming data, respectively.
This is a hint, not a guarantee: the state can change between the check and\nthe write. Use ondrain() to wait for capacity rather than polling.
Signals that no more data will be written. Writes already waiting for buffer\nspace remain ordered before the end of the stream, while later writes fail. If\ndata is outstanding, the returned promise fulfills after the consumer pulls\ndone: true beyond the final batch. If no data is buffered or pending, the\nwriter closes immediately.
Synchronous variant of writer.end(). A return value of -1 only indicates\nthat the operation could not complete synchronously; no assumption can be made\nabout whether closing has started or why it could not complete. Use the\ntry-fallback pattern to await completion:
const result = writer.endSync();\nif (result < 0) {\n writer.end();\n}\nPut the writer into a terminal error state. If the writer is already closed\nor errored, this is a no-op. Unlike write() and end(), fail() is\nunconditionally synchronous because failing a writer is a pure state\ntransition with no async work to perform. The reason is stored and propagated\nwithout modification. If omitted, the reason is undefined.
If the writer is open, calls writer.fail(). If the writer is closing after\nend() or endSync(), waits for buffered data to drain. If the writer is\nalready closed or errored, resolves immediately.
Write a chunk.
" }, { "textRaw": "`writer.writeSync(chunk)`", "name": "writeSync", "type": "method", "signatures": [ { "params": [ { "textRaw": "`chunk` {Uint8Array | string}", "name": "chunk", "type": "Uint8Array | string" } ], "return": { "textRaw": "Returns: {boolean} `true` if the write was accepted, `false` if the buffer is full.", "name": "return", "type": "boolean", "desc": "`true` if the write was accepted, `false` if the buffer is full." } } ], "desc": "Synchronous write. Does not block; returns false if backpressure is active.
Write multiple chunks as a single batch.
" }, { "textRaw": "`writer.writevSync(chunks)`", "name": "writevSync", "type": "method", "signatures": [ { "params": [ { "textRaw": "`chunks` {Iterable} of {Uint8Array | string} values", "name": "chunks", "type": "Iterable", "desc": "of {Uint8Array | string} values" } ], "return": { "textRaw": "Returns: {boolean} `true` if the write was accepted, `false` if the buffer is full.", "name": "return", "type": "boolean", "desc": "`true` if the write was accepted, `false` if the buffer is full." } } ], "desc": "Synchronous batch write.
" } ], "displayName": "Writer interface" } ], "displayName": "Concepts" }, { "textRaw": "The `stream/iter` module", "name": "the_`stream/iter`_module", "type": "module", "desc": "Most functions are available both as named exports and as properties of the\nStream namespace object. The classic stream adapters (fromReadable(),\nfromWritable(), toReadable(), toReadableSync(), and toWritable()) and\nthe static helper objects (Broadcast, Share, and SyncShare) are named\nexports only.
// Named exports\nimport { from, pull, bytes, Stream } from 'node:stream/iter';\n\n// Namespace access\nStream.from('hello');\nOptions dictionaries defined by the Iterable Streams API use Web IDL\nconversion semantics. null is treated as an empty dictionary, unknown\nmembers are ignored, and known members are converted to their declared types\nbefore the operation runs. Conversion failures use Node.js error codes such as\nERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, and ERR_OUT_OF_RANGE.
// Named exports\nconst { from, pull, bytes, Stream } = require('node:stream/iter');\n\n// Namespace access\nStream.from('hello');\nIncluding the node: prefix on the module specifier is optional.
Create an async byte stream from the given input. Strings are UTF-8 encoded.\nArrayBuffer and ArrayBufferView values are wrapped as Uint8Array. Arrays\nand iterables in input are recursively flattened and normalized. Flattened\nvalues may be split across implementation-defined bounded batches.
Objects implementing Symbol.for('Stream.toAsyncStreamable') or\nSymbol.for('Stream.toStreamable') are converted via those protocols. The\ntoAsyncStreamable protocol takes precedence over toStreamable, which takes\nprecedence over the iteration protocols (Symbol.asyncIterator,\nSymbol.iterator).
import { Buffer } from 'node:buffer';\nimport { from, text } from 'node:stream/iter';\n\nconsole.log(await text(from('hello'))); // 'hello'\nconsole.log(await text(from(Buffer.from('hello')))); // 'hello'\nconst { Buffer } = require('node:buffer');\nconst { from, text } = require('node:stream/iter');\n\nasync function run() {\n console.log(await text(from('hello'))); // 'hello'\n console.log(await text(from(Buffer.from('hello')))); // 'hello'\n}\n\nrun().catch(console.error);\nSynchronous version of from(). Returns a sync iterable. Cannot accept\nasync iterables or promises. Objects implementing\nSymbol.for('Stream.toStreamable') are converted via that protocol (takes\nprecedence over Symbol.iterator). The toAsyncStreamable protocol is\nignored entirely.
import { fromSync, textSync } from 'node:stream/iter';\n\nconsole.log(textSync(fromSync('hello'))); // 'hello'\nconst { fromSync, textSync } = require('node:stream/iter');\n\nconsole.log(textSync(fromSync('hello'))); // 'hello'\nPipe a source through transforms into a writer. If the writer has a\nwritev(chunks) method, entire batches are passed in a single call (enabling\nscatter/gather I/O).
If the writer implements the optional *Sync methods (writeSync, writevSync,\nendSync), pipeTo() will attempt to use the synchronous methods\nfirst as a fast path, and fall back to the async versions only when the sync\nmethods indicate they cannot complete (e.g., backpressure or waiting for the\nnext tick). fail() is always called synchronously.
import { from, pipeTo } from 'node:stream/iter';\nimport { compressGzip } from 'node:zlib/iter';\nimport { open } from 'node:fs/promises';\n\nconst fh = await open('output.gz', 'w');\nconst totalBytes = await pipeTo(\n from('Hello, world!'),\n compressGzip(),\n fh.writer({ autoClose: true }),\n);\nconst { from, pipeTo } = require('node:stream/iter');\nconst { compressGzip } = require('node:zlib/iter');\nconst { open } = require('node:fs/promises');\n\nasync function run() {\n const fh = await open('output.gz', 'w');\n const totalBytes = await pipeTo(\n from('Hello, world!'),\n compressGzip(),\n fh.writer({ autoClose: true }),\n );\n}\n\nrun().catch(console.error);\nSynchronous version of pipeTo(). The source, all transforms, and the\nwriter must be synchronous. Cannot accept async iterables or promises.
The writer must have the *Sync methods (writeSync, writevSync,\nendSync) and fail() for this to work.
pipeToSync() never falls back to the asynchronous writer methods. If\nwriter.endSync() returns -1 because the writer cannot close synchronously\n(for example, a push() writer whose consumer has not read all of the data\nyet), pipeToSync() throws ERR_INVALID_STATE. All of the data was accepted\nby then, so by default the writer is not failed: it can still be closed, for\nexample with await writer.end(). If the writer cannot be closed any other\nway (for example, it has no end() method), or the caller will not close it,\nset failOnIncompleteClose to fail it with the thrown error instead.
Create a lazy async pipeline. Source conversion and streamable protocol\ndispatch occur when pull() is called, but data is not read from source\nuntil the returned iterable is consumed. Transforms are applied in order.
When signal aborts, the pending read (or the next one) rejects with\nsignal.reason, and so does every later read. If signal is already aborted,\npull() still returns an iterable; reading from it rejects with\nsignal.reason without reading from source.
import { from, pull, text } from 'node:stream/iter';\n\nconst asciiUpper = (chunks) => {\n if (chunks === null) return null;\n return chunks.map((c) => {\n for (let i = 0; i < c.length; i++) {\n c[i] -= (c[i] >= 97 && c[i] <= 122) * 32;\n }\n return c;\n });\n};\n\nconst result = pull(from('hello'), asciiUpper);\nconsole.log(await text(result)); // 'HELLO'\nconst { from, pull, text } = require('node:stream/iter');\n\nconst asciiUpper = (chunks) => {\n if (chunks === null) return null;\n return chunks.map((c) => {\n for (let i = 0; i < c.length; i++) {\n c[i] -= (c[i] >= 97 && c[i] <= 122) * 32;\n }\n return c;\n });\n};\n\nasync function run() {\n const result = pull(from('hello'), asciiUpper);\n console.log(await text(result)); // 'HELLO'\n}\n\nrun().catch(console.error);\nUsing an AbortSignal:
import { pull } from 'node:stream/iter';\n\nconst ac = new AbortController();\nconst result = pull(source, transform, { signal: ac.signal });\nac.abort(); // Pipeline throws AbortError on next iteration\nconst { pull } = require('node:stream/iter');\n\nconst ac = new AbortController();\nconst result = pull(source, transform, { signal: ac.signal });\nac.abort(); // Pipeline throws AbortError on next iteration\nSynchronous version of pull(). Source conversion and streamable protocol\ndispatch occur when pullSync() is called. All transforms must be synchronous.
Create a push stream with backpressure. The writer pushes data in; the\nreadable side is consumed as an async iterable.
\nimport { push, text } from 'node:stream/iter';\n\nconst { writer, readable } = push();\n\n// Producer and consumer must run concurrently. With strict backpressure\n// (the default), awaited writes block until the consumer reads.\nconst producing = (async () => {\n await writer.write('hello');\n await writer.write(' world');\n await writer.end();\n})();\n\nconsole.log(await text(readable)); // 'hello world'\nawait producing;\nconst { push, text } = require('node:stream/iter');\n\nasync function run() {\n const { writer, readable } = push();\n\n // Producer and consumer must run concurrently. With strict backpressure\n // (the default), awaited writes block until the consumer reads.\n const producing = (async () => {\n await writer.write('hello');\n await writer.write(' world');\n await writer.end();\n })();\n\n console.log(await text(readable)); // 'hello world'\n await producing;\n}\n\nrun().catch(console.error);\nThe writer returned by push() conforms to the [Writer interface][].
Zero-length chunks are accepted without being buffered: they are not delivered\nto the consumer, and writeSync() and write() report success for them even\nwhen backpressure is active.
Create a pair of connected duplex channels for bidirectional communication,\nsimilar to socketpair(). Data written to one channel's writer appears in\nthe other channel's readable.
Each channel has:
\nwriter — a [Writer interface][] object for sending data to the peer.readable — an AsyncIterable for reading data from the peer.close() — close this end of the channel (idempotent).[Symbol.asyncDispose]() — async dispose support for await using.import { duplex, text } from 'node:stream/iter';\n\nconst [client, server] = duplex();\n\n// Server echoes back\nconst serving = (async () => {\n for await (const chunks of server.readable) {\n await server.writer.writev(chunks);\n }\n await server.writer.end();\n})();\n\nawait client.writer.write('hello');\nawait client.writer.end();\n\nconsole.log(await text(client.readable)); // 'hello'\nawait serving;\nconst { duplex, text } = require('node:stream/iter');\n\nasync function run() {\n const [client, server] = duplex();\n\n // Server echoes back\n const serving = (async () => {\n for await (const chunks of server.readable) {\n await server.writer.writev(chunks);\n }\n await server.writer.end();\n })();\n\n await client.writer.write('hello');\n await client.writer.end();\n\n console.log(await text(client.readable)); // 'hello'\n await serving;\n}\n\nrun().catch(console.error);\nCollect all chunks as an array of Uint8Array values (without concatenating).
Collect all bytes into an ArrayBuffer.
Synchronous version of arrayBuffer().
Synchronous version of array().
Collect all bytes from a stream into a single Uint8Array.
import { from, bytes } from 'node:stream/iter';\n\nconst data = await bytes(from('hello'));\nconsole.log(data); // Uint8Array(5) [ 104, 101, 108, 108, 111 ]\nconst { from, bytes } = require('node:stream/iter');\n\nasync function run() {\n const data = await bytes(from('hello'));\n console.log(data); // Uint8Array(5) [ 104, 101, 108, 108, 111 ]\n}\n\nrun().catch(console.error);\nSynchronous version of bytes().
Read a source to completion, discarding every chunk. Unlike the other\nconsumers, dump() retains nothing. Memory tops-out at a single batch no\nmatter how much data the source produces.
Use this to consume a stream when the content doesn't matter. For example, A\nQUIC stream only returns flow-control credit to the peer as its data is\nconsumed, so a receiver that does not want the payload must still read it to\ncompletion.
\nIf the source errors part-way through, the returned promise rejects with that\nerror.
\nThere is no default limit. dump() reads until the source is exhausted\nunless a limit is specified. When a limit is configured and the source exceeds\nit, the promise rejects and the source is cancelled. A partial dump is never\nreported as success.
import { dump, from, pull, tap } from 'node:stream/iter';\n\n// Count the bytes flowing through a stream without retaining any of them.\nlet bytesSeen = 0;\nconst counter = tap((chunks) => {\n for (const chunk of chunks) bytesSeen += chunk.byteLength;\n});\n\nawait dump(pull(from('hello world'), counter));\nconsole.log(bytesSeen); // 11\nconst { dump, from, pull, tap } = require('node:stream/iter');\n\nasync function run() {\n // Count the bytes flowing through a stream without retaining any of them.\n let bytesSeen = 0;\n const counter = tap((chunks) => {\n for (const chunk of chunks) bytesSeen += chunk.byteLength;\n });\n\n await dump(pull(from('hello world'), counter));\n console.log(bytesSeen); // 11\n}\n\nrun().catch(console.error);\nSynchronous version of dump(). Throws ERR_INVALID_ARG_TYPE if source\nis not synchronously iterable.
Collect all bytes and decode as text.
\nimport { from, text } from 'node:stream/iter';\n\nconsole.log(await text(from('hello'))); // 'hello'\nconst { from, text } = require('node:stream/iter');\n\nasync function run() {\n console.log(await text(from('hello'))); // 'hello'\n}\n\nrun().catch(console.error);\nSynchronous version of text().
Wait for a drainable writer to regain physical buffer capacity. Returns null\nif the object does not implement the drainable protocol, or a promise that\nfulfills with true when buffered data falls below the byte budget.
For writers using 'drop-oldest' or 'drop-newest', this waits for physical\ncapacity even though writes do not block. This allows producers to avoid data\nloss by waiting before writing.
import { push, ondrain, text } from 'node:stream/iter';\n\nconst { writer, readable } = push({ budget: 16384 });\nconst chunk = new Uint8Array(8192); // 8 KB\nwriter.writeSync(chunk);\nwriter.writeSync(chunk); // 16 KB total -- buffer full\n\n// Start consuming so the buffer can actually drain\nconst consuming = text(readable);\n\n// Buffer is full -- wait for drain\nconst canWrite = await ondrain(writer);\nif (canWrite) {\n await writer.write('c');\n}\nawait writer.end();\nawait consuming;\nconst { push, ondrain, text } = require('node:stream/iter');\n\nasync function run() {\n const { writer, readable } = push({ budget: 16384 });\n const chunk = new Uint8Array(8192); // 8 KB\n writer.writeSync(chunk);\n writer.writeSync(chunk); // 16 KB total -- buffer full\n\n // Start consuming so the buffer can actually drain\n const consuming = text(readable);\n\n // Buffer is full -- wait for drain\n const canWrite = await ondrain(writer);\n if (canWrite) {\n await writer.write('c');\n }\n await writer.end();\n await consuming;\n}\n\nrun().catch(console.error);\nMerge multiple async iterables by yielding batches in temporal order\n(whichever source produces data first). All sources are consumed\nconcurrently, with at most one pending next() call per source.
If a source fails, the returned iterable rejects with its error. merge()\ncalls return() on the other sources but does not wait for it to settle: an\nasync generator source that is suspended in an await only runs its cleanup\nonce that await completes.
import { from, merge, text } from 'node:stream/iter';\n\nconst merged = merge(from('hello '), from('world'));\nconsole.log(await text(merged)); // Order depends on timing\nconst { from, merge, text } = require('node:stream/iter');\n\nasync function run() {\n const merged = merge(from('hello '), from('world'));\n console.log(await text(merged)); // Order depends on timing\n}\n\nrun().catch(console.error);\nCreate a pass-through transform that observes batches without modifying them.\nUseful for logging, metrics, or debugging.
\nimport { from, pull, text, tap } from 'node:stream/iter';\n\nconst result = pull(\n from('hello'),\n tap((chunks) => {\n if (chunks !== null) console.log('Batch size:', chunks.length);\n }),\n);\nconsole.log(await text(result));\nconst { from, pull, text, tap } = require('node:stream/iter');\n\nasync function run() {\n const result = pull(\n from('hello'),\n tap((chunks) => {\n if (chunks !== null) console.log('Batch size:', chunks.length);\n }),\n );\n console.log(await text(result));\n}\n\nrun().catch(console.error);\ntap() intentionally does not prevent in-place modification of the\nchunks by the tapping callback; but return values are ignored.
Synchronous version of tap().
Create a push-model multi-consumer broadcast channel. A single writer pushes\ndata to multiple consumers. Each consumer has an independent cursor into a\nshared buffer.
\nimport { broadcast, text } from 'node:stream/iter';\n\nconst { writer, broadcast: bc } = broadcast();\n\n// Create consumers before writing\nconst c1 = bc.push(); // Consumer 1\nconst c2 = bc.push(); // Consumer 2\n\n// Producer and consumers must run concurrently. Awaited writes\n// block when the buffer fills until consumers read.\nconst producing = (async () => {\n await writer.write('hello');\n await writer.end();\n})();\n\nconst [r1, r2] = await Promise.all([text(c1), text(c2)]);\nconsole.log(r1); // 'hello'\nconsole.log(r2); // 'hello'\nawait producing;\nconst { broadcast, text } = require('node:stream/iter');\n\nasync function run() {\n const { writer, broadcast: bc } = broadcast();\n\n // Create consumers before writing\n const c1 = bc.push(); // Consumer 1\n const c2 = bc.push(); // Consumer 2\n\n // Producer and consumers must run concurrently. Awaited writes\n // block when the buffer fills until consumers read.\n const producing = (async () => {\n await writer.write('hello');\n await writer.end();\n })();\n\n const [r1, r2] = await Promise.all([text(c1), text(c2)]);\n console.log(r1); // 'hello'\n console.log(r2); // 'hello'\n await producing;\n}\n\nrun().catch(console.error);\nCancel the broadcast. If reason is provided, all consumers reject with that\nexact reason. If it is omitted, consumers complete normally.
Cancelling also closes the paired writer: afterwards its canWrite is null\nand write() rejects with a TypeError. This lets a Broadcast.from()\npump stop pulling from its source.
Create a new consumer. Optional transforms are applied to this consumer's view\nof the data.
" }, { "textRaw": "`broadcast[Symbol.dispose]()`", "name": "[Symbol.dispose]", "type": "method", "signatures": [ { "params": [] } ], "desc": "Alias for broadcast.cancel().
The number of active consumers.
" } ] }, { "textRaw": "`Broadcast.from(input[, options])`", "name": "from", "type": "method", "meta": { "added": [ "v25.9.0", "v24.20.0" ], "changes": [] }, "signatures": [ { "params": [ { "textRaw": "`input` {AsyncIterable | Iterable | BroadcastChannel}", "name": "input", "type": "AsyncIterable | Iterable | BroadcastChannel" }, { "textRaw": "`options` {Object} Same as `broadcast()`.", "name": "options", "type": "Object", "desc": "Same as `broadcast()`.", "optional": true } ], "return": { "textRaw": "Returns: {BroadcastChannel | Object} A `broadcastProtocol` input returns its {BroadcastChannel} directly. Other inputs return `{ writer, broadcast }`.", "name": "return", "type": "BroadcastChannel | Object", "desc": "A `broadcastProtocol` input returns its {BroadcastChannel} directly. Other inputs return `{ writer, broadcast }`." } } ], "desc": "Create a BroadcastChannel from an existing source. The source is consumed\nautomatically and pushed to all subscribers.
Create a pull-model multi-consumer shared stream. Unlike broadcast(), the\nsource is only read when a consumer pulls. Multiple consumers share a single\nbuffer.
A consumer created with share.pull() starts reading at the oldest entry still\nin the buffer. Entries are released once every consumer has read them. When\nevery consumer has detached, the buffered data is kept for consumers that\nattach later, and the source is not closed. Call share.cancel() (or dispose\nthe share) to release the source once it is no longer needed.
With 'strict' backpressure, a consumer that needs to pull from the source\nwhile the buffer is at or above budget is rejected with ERR_OUT_OF_RANGE\nand detached; further reads from that consumer complete with { done: true }.\nDetaching keeps a consumer that is not retried (for example, one read with\nfor await...of, which does not call return() when a read rejects) from\nholding buffered data and blocking the other consumers.
With 'unbounded', such a consumer waits until the slowest consumer releases\nbudget. With 'drop-newest', the entry pulled from the source is discarded\nand the consumer then waits in the same way, so in both cases a stalled\nconsumer also stalls the consumers that are ahead of it. Only 'drop-oldest'\nlets consumers that are ahead continue, by discarding the oldest buffered\nentries that the slowest consumer has not read yet. A batch pulled from the\nsource that is larger than budget is split into smaller entries first, so\neviction keeps the newest chunks that fit within the budget.
import { from, share, text } from 'node:stream/iter';\n\nconst shared = share(from('hello'));\n\nconst c1 = shared.pull();\nconst c2 = shared.pull();\n\n// Consume concurrently to avoid deadlock with small buffers.\nconst [r1, r2] = await Promise.all([text(c1), text(c2)]);\nconsole.log(r1); // 'hello'\nconsole.log(r2); // 'hello'\nconst { from, share, text } = require('node:stream/iter');\n\nasync function run() {\n const shared = share(from('hello'));\n\n const c1 = shared.pull();\n const c2 = shared.pull();\n\n // Consume concurrently to avoid deadlock with small buffers.\n const [r1, r2] = await Promise.all([text(c1), text(c2)]);\n console.log(r1); // 'hello'\n console.log(r2); // 'hello'\n}\n\nrun().catch(console.error);\nSynchronous version of share().
A synchronous consumer cannot wait for the slowest consumer to release budget,\nand the slowest consumer cannot advance while another consumer's read is\nrunning. 'unbounded' and 'drop-newest' are therefore not supported and\nthrow ERR_INVALID_ARG_VALUE.
Create a Share from an existing source.
Cancel the share. If reason is provided, all consumers reject with that exact\nreason. If it is omitted, consumers complete normally.
Create a new consumer of the shared source.
" }, { "textRaw": "`share[Symbol.dispose]()`", "name": "[Symbol.dispose]", "type": "method", "signatures": [ { "params": [] } ], "desc": "Alias for share.cancel().
The number of active consumers.
" } ] }, { "textRaw": "Class: `SyncShare`", "name": "SyncShare", "type": "class", "classMethods": [ { "textRaw": "Static method: `SyncShare.fromSync(input[, options])`", "name": "fromSync", "type": "classMethod", "meta": { "added": [ "v25.9.0", "v24.20.0" ], "changes": [] }, "signatures": [ { "params": [ { "textRaw": "`input` {Iterable | SyncShareable}", "name": "input", "type": "Iterable | SyncShareable" }, { "textRaw": "`options` {Object}", "name": "options", "type": "Object", "optional": true } ], "return": { "textRaw": "Returns: {SyncShare}", "name": "return", "type": "SyncShare" } } ] } ], "methods": [ { "textRaw": "`share.cancel([reason])`", "name": "cancel", "type": "method", "signatures": [ { "params": [ { "textRaw": "`reason` {any}", "name": "reason", "type": "any", "optional": true } ] } ], "desc": "Cancel the share. If reason is provided, all consumers throw that exact\nreason. If it is omitted, consumers complete normally.
Create a new consumer of the shared source.
" }, { "textRaw": "`share[Symbol.dispose]()`", "name": "[Symbol.dispose]", "type": "method", "signatures": [ { "params": [] } ], "desc": "Alias for share.cancel().
The number of active consumers.
" } ] } ], "modules": [ { "textRaw": "Interface: `Shareable`", "name": "interface:_`shareable`", "type": "module", "properties": [ { "textRaw": "{Function} that returns a {Share}.", "name": "[Symbol.for('Stream.shareProtocol')]", "type": "Function", "desc": "that returns a {Share}." } ], "displayName": "Interface: `Shareable`" }, { "textRaw": "Interface: `SyncShareable`", "name": "interface:_`syncshareable`", "type": "module", "properties": [ { "textRaw": "{Function} that returns a {SyncShare}.", "name": "[Symbol.for('Stream.shareSyncProtocol')]", "type": "Function", "desc": "that returns a {SyncShare}." } ], "displayName": "Interface: `SyncShareable`" } ], "displayName": "Multi-consumer" }, { "textRaw": "Compression and decompression transforms", "name": "compression_and_decompression_transforms", "type": "module", "desc": "Compression and decompression transforms for use with pull(), pullSync(),\npipeTo(), and pipeToSync() are available via the node:zlib/iter\nmodule. See the node:zlib/iter documentation for details.
These utility functions bridge between classic\nstream.Readable/stream.Writable streams and the stream/iter\nAPI.
Both fromReadable() and fromWritable() accept duck-typed objects -- they\ndo not require the input to extend stream.Readable or stream.Writable\ndirectly. The minimum contract is described below for each function.
Converts a classic Readable stream (or duck-typed equivalent) into a\nstream/iter async iterable source that can be passed to from(),\npull(), text(), etc.
If the object implements the toAsyncStreamable protocol (as\nstream.Readable does), that protocol is used. Otherwise, the function\nduck-types on read(), pipe(), destroy(), on(), and removeListener()\n(EventEmitter) and wraps the stream with a batched async iterator.
The result is cached per instance -- calling fromReadable() twice with the\nsame stream returns the same iterable.
For object-mode or encoded Readable streams, chunks are automatically\nnormalized to Uint8Array.
import { Readable } from 'node:stream';\nimport { fromReadable, text } from 'node:stream/iter';\n\nconst readable = new Readable({\n read() { this.push('hello world'); this.push(null); },\n});\n\nconst result = await text(fromReadable(readable));\nconsole.log(result); // 'hello world'\nconst { Readable } = require('node:stream');\nconst { fromReadable, text } = require('node:stream/iter');\n\nconst readable = new Readable({\n read() { this.push('hello world'); this.push(null); },\n});\n\nasync function run() {\n const result = await text(fromReadable(readable));\n console.log(result); // 'hello world'\n}\nrun();\nCreates a stream/iter Writer adapter from a classic Writable stream (or\nduck-typed equivalent). The adapter can be passed to pipeTo() as a\ndestination.
Since all writes on a classic Writable are fundamentally asynchronous,\nthe synchronous Writer methods (writeSync, writevSync, endSync) always\nreturn false or -1, deferring to the async path. A queued write() or\nwritev() can be canceled with its options.signal before it reaches the\nclassic Writable.
If writer.fail(reason) receives a non-Error reason, the classic Writable is\ndestroyed with an ERR_FALSY_VALUE_REJECTION or ERR_OPERATION_FAILED error.\nIts reason property contains the original value, which remains the Writer's\nstored failure reason.
The result is cached per instance and backpressure policy -- calling\nfromWritable() twice with the same stream and backpressure option returns\nthe same Writer.
For duck-typed streams that do not expose writableHighWaterMark,\nwritableLength, or similar properties, sensible defaults are used.\nObject-mode writables (if detectable) are rejected since the Writer\ninterface is bytes-only.
import { Writable } from 'node:stream';\nimport { from, fromWritable, pipeTo } from 'node:stream/iter';\n\nconst writable = new Writable({\n write(chunk, encoding, cb) { console.log(chunk.toString()); cb(); },\n});\n\nawait pipeTo(from('hello world'),\n fromWritable(writable, { backpressure: 'unbounded' }));\nconst { Writable } = require('node:stream');\nconst { from, fromWritable, pipeTo } = require('node:stream/iter');\n\nasync function run() {\n const writable = new Writable({\n write(chunk, encoding, cb) { console.log(chunk.toString()); cb(); },\n });\n\n await pipeTo(from('hello world'),\n fromWritable(writable, { backpressure: 'unbounded' }));\n}\nrun();\nCreates a byte-mode stream.Readable from the source\n(the native batch format used by the stream/iter API). Each Uint8Array in a\nyielded batch is pushed as a separate chunk into the Readable.
Classic streams cannot represent arbitrary values as emitted errors. A\nnon-Error reason is wrapped in an ERR_FALSY_VALUE_REJECTION or\nERR_OPERATION_FAILED error whose reason property contains the original\nvalue.
import { createWriteStream } from 'node:fs';\nimport { from, pull, toReadable } from 'node:stream/iter';\nimport { compressGzip } from 'node:zlib/iter';\n\nconst source = pull(from('hello world'), compressGzip());\nconst readable = toReadable(source);\n\nreadable.pipe(createWriteStream('output.gz'));\nconst { createWriteStream } = require('node:fs');\nconst { from, pull, toReadable } = require('node:stream/iter');\nconst { compressGzip } = require('node:zlib/iter');\n\nconst source = pull(from('hello world'), compressGzip());\nconst readable = toReadable(source);\n\nreadable.pipe(createWriteStream('output.gz'));\nCreates a byte-mode stream.Readable from the source.\nThe _read() method pulls from the iterator\nsynchronously, so data is available immediately via readable.read().
import { fromSync, toReadableSync } from 'node:stream/iter';\n\nconst source = fromSync('hello world');\nconst readable = toReadableSync(source);\n\nconsole.log(readable.read().toString()); // 'hello world'\nconst { fromSync, toReadableSync } = require('node:stream/iter');\n\nconst source = fromSync('hello world');\nconst readable = toReadableSync(source);\n\nconsole.log(readable.read().toString()); // 'hello world'\nCreates a classic stream.Writable backed by a stream/iter Writer.
Each _write() / _writev() call attempts the Writer's synchronous method\nfirst (writeSync / writevSync), falling back to the async method if the\nsync path returns false. Similarly, _final() tries endSync()\nbefore end(). When the sync path succeeds, the callback is deferred via\nqueueMicrotask to preserve the async resolution contract.
Classic stream callbacks cannot represent arbitrary values as errors. A\nnon-Error reason is wrapped in an ERR_FALSY_VALUE_REJECTION or\nERR_OPERATION_FAILED error before it is passed to the callback. The error's\nreason property contains the original value.
Destroying the Writable before successful completion calls writer.fail().\nIf fail() is unavailable, Symbol.dispose or Symbol.asyncDispose is used\nwhen implemented by the Writer.
The Writable uses the default classic stream highWaterMark. Classic stream\nbackpressure bounds writes waiting to reach the underlying Writer, while the\nWriter controls completion of the active _write() or _writev() operation.
import { push, toWritable } from 'node:stream/iter';\n\nconst { writer, readable } = push();\nconst writable = toWritable(writer);\n\nwritable.write('hello');\nwritable.end();\nconst { push, toWritable } = require('node:stream/iter');\n\nconst { writer, readable } = push();\nconst writable = toWritable(writer);\n\nwritable.write('hello');\nwritable.end();\nThese well-known symbols allow third-party objects to participate in the\nstreaming protocol without importing from node:stream/iter directly.
Symbol.for('Stream.broadcastProtocol')The value must be a function. When called by Broadcast.from(), it receives\nthe options passed to Broadcast.from() and must return an object conforming\nto the BroadcastChannel interface. The implementation is fully custom -- it can\nmanage consumers, buffering, and backpressure however it wants.
import {\n broadcast as createBroadcast,\n Broadcast,\n text,\n} from 'node:stream/iter';\n\n// This example defers to the built-in Broadcast, but a custom\n// implementation could use any mechanism.\nclass MessageBus {\n #broadcast;\n #writer;\n\n constructor() {\n const { writer, broadcast } = createBroadcast();\n this.#writer = writer;\n this.#broadcast = broadcast;\n }\n\n [Symbol.for('Stream.broadcastProtocol')](options) {\n return this.#broadcast;\n }\n\n send(data) {\n this.#writer.write(new TextEncoder().encode(data));\n }\n\n close() {\n this.#writer.end();\n }\n}\n\nconst bus = new MessageBus();\nconst broadcast = Broadcast.from(bus);\nconst consumer = broadcast.push();\nbus.send('hello');\nbus.close();\nconsole.log(await text(consumer)); // 'hello'\nconst {\n broadcast: createBroadcast,\n Broadcast,\n text,\n} = require('node:stream/iter');\n\n// This example defers to the built-in Broadcast, but a custom\n// implementation could use any mechanism.\nclass MessageBus {\n #broadcast;\n #writer;\n\n constructor() {\n const { writer, broadcast } = createBroadcast();\n this.#writer = writer;\n this.#broadcast = broadcast;\n }\n\n [Symbol.for('Stream.broadcastProtocol')](options) {\n return this.#broadcast;\n }\n\n send(data) {\n this.#writer.write(new TextEncoder().encode(data));\n }\n\n close() {\n this.#writer.end();\n }\n}\n\nconst bus = new MessageBus();\nconst broadcast = Broadcast.from(bus);\nconst consumer = broadcast.push();\nbus.send('hello');\nbus.close();\ntext(consumer).then(console.log); // 'hello'\nSymbol.for('Stream.drainableProtocol')Implement to make a writer compatible with ondrain(). The method should\nreturn null if no backpressure, or a promise that fulfills with a truthy value\nwhen backpressure clears.
import { ondrain } from 'node:stream/iter';\n\nclass CustomWriter {\n #queue = [];\n #drain = null;\n #closed = false;\n [Symbol.for('Stream.drainableProtocol')]() {\n if (this.#closed) return null;\n if (this.#queue.length < 3) return Promise.resolve(true);\n this.#drain ??= Promise.withResolvers();\n return this.#drain.promise;\n }\n write(chunk) {\n this.#queue.push(chunk);\n }\n flush() {\n this.#queue.length = 0;\n this.#drain?.resolve(true);\n this.#drain = null;\n }\n close() {\n this.#closed = true;\n }\n}\nconst writer = new CustomWriter();\nconst ready = ondrain(writer);\nconsole.log(ready); // Promise { true } -- no backpressure\nconst { ondrain } = require('node:stream/iter');\n\nclass CustomWriter {\n #queue = [];\n #drain = null;\n #closed = false;\n\n [Symbol.for('Stream.drainableProtocol')]() {\n if (this.#closed) return null;\n if (this.#queue.length < 3) return Promise.resolve(true);\n this.#drain ??= Promise.withResolvers();\n return this.#drain.promise;\n }\n\n write(chunk) {\n this.#queue.push(chunk);\n }\n\n flush() {\n this.#queue.length = 0;\n this.#drain?.resolve(true);\n this.#drain = null;\n }\n\n close() {\n this.#closed = true;\n }\n}\n\nconst writer = new CustomWriter();\nconst ready = ondrain(writer);\nconsole.log(ready); // Promise { true } -- no backpressure\nSymbol.for('Stream.shareProtocol')The value must be a function. When called by Share.from(), it receives the\noptions passed to Share.from() and must return an object conforming to the\nShare interface. The implementation is fully custom -- it can manage the shared\nsource, consumers, buffering, and backpressure however it wants.
import { share, Share, text } from 'node:stream/iter';\n\n// This example defers to the built-in share(), but a custom\n// implementation could use any mechanism.\nclass DataPool {\n #share;\n\n constructor(source) {\n this.#share = share(source);\n }\n\n [Symbol.for('Stream.shareProtocol')](options) {\n return this.#share;\n }\n}\n\nconst pool = new DataPool(\n (async function* () {\n yield 'hello';\n })(),\n);\n\nconst shared = Share.from(pool);\nconst consumer = shared.pull();\nconsole.log(await text(consumer)); // 'hello'\nconst { share, Share, text } = require('node:stream/iter');\n\n// This example defers to the built-in share(), but a custom\n// implementation could use any mechanism.\nclass DataPool {\n #share;\n\n constructor(source) {\n this.#share = share(source);\n }\n\n [Symbol.for('Stream.shareProtocol')](options) {\n return this.#share;\n }\n}\n\nconst pool = new DataPool(\n (async function* () {\n yield 'hello';\n })(),\n);\n\nconst shared = Share.from(pool);\nconst consumer = shared.pull();\ntext(consumer).then(console.log); // 'hello'\nSymbol.for('Stream.shareSyncProtocol')The value must be a function. When called by SyncShare.fromSync(), it receives\nthe options passed to SyncShare.fromSync() and must return an object conforming\nto the SyncShare interface. The implementation is fully custom -- it can manage\nthe shared source, consumers, and buffering however it wants.
import { shareSync, SyncShare, textSync } from 'node:stream/iter';\n\n// This example defers to the built-in shareSync(), but a custom\n// implementation could use any mechanism.\nclass SyncDataPool {\n #share;\n\n constructor(source) {\n this.#share = shareSync(source);\n }\n\n [Symbol.for('Stream.shareSyncProtocol')](options) {\n return this.#share;\n }\n}\n\nconst encoder = new TextEncoder();\nconst pool = new SyncDataPool(\n function* () {\n yield [encoder.encode('hello')];\n }(),\n);\n\nconst shared = SyncShare.fromSync(pool);\nconst consumer = shared.pull();\nconsole.log(textSync(consumer)); // 'hello'\nconst { shareSync, SyncShare, textSync } = require('node:stream/iter');\n\n// This example defers to the built-in shareSync(), but a custom\n// implementation could use any mechanism.\nclass SyncDataPool {\n #share;\n\n constructor(source) {\n this.#share = shareSync(source);\n }\n\n [Symbol.for('Stream.shareSyncProtocol')](options) {\n return this.#share;\n }\n}\n\nconst encoder = new TextEncoder();\nconst pool = new SyncDataPool(\n function* () {\n yield [encoder.encode('hello')];\n }(),\n);\n\nconst shared = SyncShare.fromSync(pool);\nconst consumer = shared.pull();\nconsole.log(textSync(consumer)); // 'hello'\nSymbol.for('Stream.toAsyncStreamable')The value must be a function that converts the object into a streamable value.\nWhen the object is passed to from(), this method is called to produce the\nactual data. It may return any value that resolves to a string, Uint8Array,\nAsyncIterable, Iterable, or another streamable object.
import { from, text } from 'node:stream/iter';\n\nclass Greeting {\n #name;\n\n constructor(name) {\n this.#name = name;\n }\n\n [Symbol.for('Stream.toAsyncStreamable')]() {\n return `hello ${this.#name}`;\n }\n}\n\nconst stream = from(new Greeting('world'));\nconsole.log(await text(stream)); // 'hello world'\nconst { from, text } = require('node:stream/iter');\n\nclass Greeting {\n #name;\n\n constructor(name) {\n this.#name = name;\n }\n\n [Symbol.for('Stream.toAsyncStreamable')]() {\n return `hello ${this.#name}`;\n }\n}\n\nconst stream = from(new Greeting('world'));\ntext(stream).then(console.log); // 'hello world'\nSymbol.for('Stream.toStreamable')The value must be a function that synchronously converts the object into a\nstreamable value. When the object is passed to fromSync(), this method is\ncalled to produce the actual data. It must synchronously return a streamable\nvalue: a string, Uint8Array, or Iterable.
import { fromSync, textSync } from 'node:stream/iter';\n\nclass Greeting {\n #name;\n\n constructor(name) {\n this.#name = name;\n }\n\n [Symbol.for('Stream.toStreamable')]() {\n return `hello ${this.#name}`;\n }\n}\n\nconst stream = fromSync(new Greeting('world'));\nconsole.log(textSync(stream)); // 'hello world'\nconst { fromSync, textSync } = require('node:stream/iter');\n\nclass Greeting {\n #name;\n\n constructor(name) {\n this.#name = name;\n }\n\n [Symbol.for('Stream.toStreamable')]() {\n return `hello ${this.#name}`;\n }\n}\n\nconst stream = fromSync(new Greeting('world'));\nconsole.log(textSync(stream)); // 'hello world'\n