# process

Stand-ins for a process's terminal, standard streams and child processes, for testing command-line tools and interactive prompts.

## Usage

### Interactive prompts

[`createTtyInput`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-createTtyInput) returns a stdin that reports itself as a terminal and accepts raw mode. [`createCapturedOutput`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-createCapturedOutput) returns a stdout that keeps what it was given. [`Keys`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-Keys) holds the byte sequences a terminal sends for Enter, the arrows, Ctrl+C and the other keys prompts react to:

```typescript
import { expect, it } from '@hyperfrontend/testing'
import { Keys, createCapturedOutput, createTtyInput } from '@hyperfrontend/testing/process'
import { askName } from './ask-name'

it('answers with what was typed', async () => {
  const input = createTtyInput()
  const output = createCapturedOutput({ tty: true, columns: 60 })
  const answer = askName({ input, output })

  await input.sendKeys('a', 'd', 'a', Keys.Enter)

  expect(await answer).toBe('ada')
})
```

Keys arrive one per turn of the event loop, so the prompt handles and redraws after each one before the next arrives. Keys sent before anything listens are buffered rather than lost, and [`paste`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-TtyInput) sends text wrapped in bracketed-paste markers. As a terminal, the captured output reports a size, which [`resize`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-CapturedOutput) changes while emitting the event a real terminal emits, and a one-bit colour depth by default, so colour-aware code writes plain text that is easy to assert on.

### Standard streams

[`captureStdio`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-captureStdio) records what the process writes to stdout and stderr, console output included, and silences the real streams unless asked to pass writes through. The capture is a spy, so [`jest.restoreAllMocks`](https://www.hyperfrontend.dev/docs/libraries/testing/#api-JestApi) ends it as well as its own [`restore`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-CapturedStdio). Under `node --test`, a spec file reports its results to the runner as serialized messages on that same stdout; the capture recognises those and lets them through, so holding it across an `await` never drops a test from the report.

Code that takes its streams as arguments needs no capture: hand it a [`createCapturedOutput`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-createCapturedOutput), or read a `PassThrough` afterwards with [`readAll`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-readAll).

### Child processes

[`createFakeChildProcess`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-createFakeChildProcess) is what a mocked [`spawn`](https://nodejs.org/api/child_process.html#child_processspawncommand-args-options) or [`fork`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options) returns. The test writes its output and decides when, and how, it ends:

```typescript
import { spawn } from 'node:child_process'
import { expect, it, jest } from '@hyperfrontend/testing'
import { createFakeChildProcess } from '@hyperfrontend/testing/process'
import { runWorker } from './run-worker'

jest.mock('node:child_process', () => ({ spawn: jest.fn() }))

it('resolves with what the worker printed', async () => {
  const child = createFakeChildProcess()
  jest.mocked(spawn).mockReturnValue(child as never)

  const result = runWorker()
  child.writeStdout('{"ok":true}\n')
  child.exit(0)

  expect(await result).toEqual({ ok: true })
})
```

| Call                                     | Effect                                                                                                |
| ---------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| `exit(code, signal)`                     | Ends stdout and stderr, emits the exit event, then the close event on the next turn of the event loop |
| `kill(signal)`                           | Marks the child killed and exits it with the signal; reports false once it has exited                 |
| `fail(error)`                            | Emits the error event, as a child that could not start does                                           |
| `writeStdout(text)`, `writeStderr(text)` | Writes to the child's output streams                                                                  |

[`kill`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-FakeChildProcess-prop-kill) is a mock function, so a test can assert on the signals sent. [`spawnSyncResult`](https://www.hyperfrontend.dev/docs/libraries/testing/process/#api-spawnSyncResult) builds the complete object a mocked [`spawnSync`](https://nodejs.org/api/child_process.html#child_processspawnsynccommand-args-options) returns, from only the fields that differ from a clean exit with no output.

## API Reference

### Functions

#### captureStdio

```typescript
function captureStdio(options: CaptureStdioOptions): CapturedStdio
```

Records what the process writes to stdout and stderr, silencing the real streams unless
told to pass the writes through.

`console` writes through the same streams, so its output is captured too. The takeover
is a spy, so `jest.restoreAllMocks` and the runner's `restoreMocks` option end it as well
as `restore`. The test runner's own result messages, which share stdout with the code
under test, are recognised and passed through, so a capture held across an `await` never
drops a test from the report.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `options` | `CaptureStdioOptions` | Which streams to capture, and whether they still print. (default: `{}`) |

**Returns** `CapturedStdio`: Readers for what was written, and a restore.

**Example: Asserting on a warning without printing it**

```ts
const stdio = captureStdio()
build({ strict: false })
stdio.restore()
expect(stdio.stderr()).toContain('strict mode is off')
```

#### createCapturedOutput

```typescript
function createCapturedOutput(options: CapturedOutputOptions): CapturedOutput
```

Creates a stand-in for stdout or stderr that keeps everything written to it.

Writes complete synchronously, so `text()` reflects a write as soon as it returns. As a
terminal, the stream reports a size and a colour depth, and `resize` emits the event a
terminal emits when its window changes.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `options` | `CapturedOutputOptions` | Whether it is a terminal, and its size and colour depth. (default: `{}`) |

**Returns** `CapturedOutput`: The output stream.

**Example: Reading what a command printed**

```ts
const stderr = createCapturedOutput()
const code = await runCli({ argv: ['--bad'], stderr })
expect({ code, message: stderr.text() }).toEqual({ code: 1, message: 'unknown option --bad\n' })
```

#### createFakeChildProcess

```typescript
function createFakeChildProcess(options: FakeChildProcessOptions): FakeChildProcess
```

Creates a child process for a mocked `spawn` to return, whose output, exit and failure
the test controls.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `options` | `FakeChildProcessOptions` | The process identifier, when a test asserts on it. (default: `{}`) |

**Returns** `FakeChildProcess`: A child with no output and no exit, until the test supplies them.

**Example: Returning a scripted child from a mocked spawn**

```ts
jest.mock('node:child_process', () => ({ spawn: jest.fn() }))

it('reports what the worker printed', async () => {
  const child = createFakeChildProcess()
  jest.mocked(spawn).mockReturnValue(child as never)
  const result = runWorker()
  child.writeStdout('{"ok":true}\n')
  child.exit(0)
  expect(await result).toEqual({ ok: true })
})
```

#### createTtyInput

```typescript
function createTtyInput(): TtyInput
```

Creates a stand-in for a terminal's stdin that a test types into.

Keys are written into the stream one per turn of the event loop, so a prompt's read loop
handles each key, and re-renders, before the next arrives. Keys sent before anything
listens are buffered rather than lost. Calls queue behind one another, so two `sendKeys`
calls without an `await` between them still arrive in order.

**Returns** `TtyInput`: The input stream.

**Example: Answering a text prompt**

```ts
const input = createTtyInput()
const output = createCapturedOutput({ tty: true })
const answer = text({ message: 'Name?', input, output })
await input.sendKeys('a', 'd', 'a', Keys.Enter)
expect(await answer).toBe('ada')
```

#### readAll

```typescript
function readAll(stream: Readable): string
```

Reads everything a readable stream has buffered right now, without waiting for more.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `stream` | `Readable` | A stream holding data nothing has consumed, such as a `PassThrough` handed to code that wrote to it. |

**Returns** `string`: The buffered data decoded as UTF-8, or an empty string when nothing is buffered.

**Example: Reading what a command wrote to a plain stream**

```ts
const stdout = new PassThrough()
printSummary(stdout)
expect(readAll(stdout)).toBe('3 packages\n')
```

#### spawnSyncResult

```typescript
function spawnSyncResult(options: SpawnSyncResultOptions): SpawnSyncReturns<string>
```

Builds what `spawnSync` returns with `encoding: 'utf8'`, for a mocked `spawnSync` to hand
back.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `options` | `SpawnSyncResultOptions` | The fields that differ from a clean exit with no output. (default: `{}`) |

**Returns** `SpawnSyncReturns<string>`: A complete result.

**Example: Scripting a failed command**

```ts
jest.mocked(spawnSync).mockReturnValue(spawnSyncResult({ status: 1, stderr: 'not signed' }))
expect(() => verifySignature('app')).toThrow('not signed')
```

### Interfaces

#### CapturedOutput

A writable stream that keeps everything written to it, standing in for stdout or stderr.

**Properties**

| Name | Type | Description |
| --- | --- | --- |
| `isTTY` | `boolean` | Whether the stream reports itself as a terminal. |
| `columns` | `number` | Terminal width, or undefined when not a terminal. |
| `rows` | `number` | Terminal height, or undefined when not a terminal. |
| `writable` | `boolean` | Is `true` if it is safe to call `writable.write()`, which means the stream has not been destroyed, errored, or ended. |
| `readonly writableAborted` | `boolean` | Returns whether the stream was destroyed or errored before emitting `'finish'`. |
| `readonly writableEnded` | `boolean` | Is `true` after `writable.end()` has been called. This property does not indicate whether the data has been flushed, for this use `writable.writableFinished` instead. |
| `readonly writableFinished` | `boolean` | Is set to `true` immediately before the `'finish'` event is emitted. |
| `readonly writableHighWaterMark` | `number` | Return the value of `highWaterMark` passed when creating this `Writable`. |
| `readonly writableLength` | `number` | This property contains the number of bytes (or objects) in the queue ready to be written. The value provides introspection data regarding the status of the `highWaterMark`. |
| `readonly writableObjectMode` | `boolean` | Getter for the property `objectMode` of a given `Writable` stream. |
| `readonly writableCorked` | `number` | Number of times `writable.uncork()` needs to be called in order to fully uncork the stream. |
| `destroyed` | `boolean` | Is `true` after `writable.destroy()` has been called. |
| `readonly closed` | `boolean` | Is `true` after `'close'` has been emitted. |
| `readonly errored` | `Error` | Returns error if the stream has been destroyed with an error. |
| `readonly writableNeedDrain` | `boolean` | Is `true` if the stream's buffer has been full and stream will emit `'drain'`. |

##### _construct

```typescript
_construct(callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `callback` | `(error?: Error) => void` |  |

##### _destroy

```typescript
_destroy(error: Error, callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `error` | `Error` |  |
| `callback` | `(error?: Error) => void` |  |

##### _final

```typescript
_final(callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `callback` | `(error?: Error) => void` |  |

##### _write

```typescript
_write(chunk: any, encoding: BufferEncoding, callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` |  |
| `encoding` | `BufferEncoding` |  |
| `callback` | `(error?: Error) => void` |  |

##### _writev

```typescript
_writev(chunks: { chunk: any; encoding: BufferEncoding }[], callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunks` | `{ chunk: any; encoding: BufferEncoding }[]` |  |
| `callback` | `(error?: Error) => void` |  |

##### [asyncDispose]

```typescript
[asyncDispose](): Promise<void>
```

Calls `writable.destroy()` with an `AbortError` and returns
a promise that fulfills when the stream is finished.

##### [captureRejectionSymbol]

```typescript
[captureRejectionSymbol](error: Error, event: string | symbol, ...args: any[]): void
```

The `Symbol.for('nodejs.rejection')` method is called in case a
promise rejection happens when emitting an event and
`captureRejections` is enabled on the emitter.
It is possible to use `events.captureRejectionSymbol` in
place of `Symbol.for('nodejs.rejection')`.

```js
import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `error` | `Error` |  |
| `event` | `string \| symbol` |  |
| `...args` | `any[]` |  |

##### addListener

```typescript
addListener<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Alias for `emitter.on(eventName, listener)`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |
| `listener` | `(args: indexedAccess) => void` |  |

```typescript
addListener(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### clear

```typescript
clear(): void
```

Forgets what has been written so far.

##### cork

```typescript
cork(): void
```

The `writable.cork()` method forces all written data to be buffered in memory.
The buffered data will be flushed when either the uncork or end methods are called.

The primary intent of `writable.cork()` is to accommodate a situation in which
several small chunks are written to the stream in rapid succession. Instead of
immediately forwarding them to the underlying destination, `writable.cork()` buffers all the chunks until `writable.uncork()` is called, which will pass them
all to `writable._writev()`, if present. This prevents a head-of-line blocking
situation where data is being buffered while waiting for the first small chunk
to be processed. However, use of `writable.cork()` without implementing `writable._writev()` may have an adverse effect on throughput.

See also: `writable.uncork()`, `writable._writev()`.

##### destroy

```typescript
destroy(error?: Error): this
```

Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'` event (unless `emitClose` is set to `false`). After this call, the writable
stream has ended and subsequent calls to `write()` or `end()` will result in
an `ERR_STREAM_DESTROYED` error.
This is a destructive and immediate way to destroy a stream. Previous calls to `write()` may not have drained, and may trigger an `ERR_STREAM_DESTROYED` error.
Use `end()` instead of destroy if data should flush before close, or wait for
the `'drain'` event before destroying the stream.

Once `destroy()` has been called any further calls will be a no-op and no
further errors except from `_destroy()` may be emitted as `'error'`.

Implementors should not override this method,
but instead implement `writable._destroy()`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `error?` | `Error` | Optional, an error to emit with `'error'` event. |

##### emit

```typescript
emit<E>(eventName: E, ...args: indexedAccess): boolean
```

Synchronously calls each of the listeners registered for the event named
`eventName`, in the order they were registered, passing the supplied arguments
to each.

Returns `true` if the event had listeners, `false` otherwise.

```js
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |
| `...args` | `indexedAccess` |  |

```typescript
emit(eventName: string | symbol, ...args: any[]): boolean
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `...args` | `any[]` |  |

##### end

```typescript
end(cb?: () => void): this
```

Calling the `writable.end()` method signals that no more data will be written
to the `Writable`. The optional `chunk` and `encoding` arguments allow one
final additional chunk of data to be written immediately before closing the
stream.

Calling the write method after calling end will raise an error.

```js
// Write 'hello, ' and then end with 'world!'.
import fs from 'node:fs';
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed!
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `cb?` | `() => void` | Callback for when the stream is finished. |

```typescript
end(chunk: any, cb?: () => void): this
```

Signals that no more data will be written, with one final chunk of data.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` | Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`. |
| `cb?` | `() => void` | Callback for when the stream is finished. |

```typescript
end(chunk: any, encoding: BufferEncoding, cb?: () => void): this
```

Signals that no more data will be written, with one final chunk of data.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` | Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`. |
| `encoding` | `BufferEncoding` | The encoding if `chunk` is a string |
| `cb?` | `() => void` | Callback for when the stream is finished. |

##### eventNames

```typescript
eventNames(): (string | symbol)[]
```

Returns an array listing the events for which the emitter has registered
listeners.

```js
import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
```

##### getColorDepth

```typescript
getColorDepth(): number
```

Reports the colour depth, as a terminal's `WriteStream` does.

##### getMaxListeners

```typescript
getMaxListeners(): number
```

Returns the current max listener value for the `EventEmitter` which is either
set by `emitter.setMaxListeners(n)` or defaults to
`events.defaultMaxListeners`.

##### hasColors

```typescript
hasColors(count?: number): boolean
```

Reports whether at least `count` colours are available, as a terminal's `WriteStream` does.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `count?` | `number` |  |

##### listenerCount

```typescript
listenerCount<E>(eventName: E, listener?: (args: indexedAccess) => void): number
```

Returns the number of listeners listening for the event named `eventName`.
If `listener` is provided, it will return how many times the listener is found
in the list of the listeners of the event.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event being listened for |
| `listener?` | `(args: indexedAccess) => void` | The event handler function |

```typescript
listenerCount(eventName: string | symbol, listener?: (args: any[]) => void): number
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener?` | `(args: any[]) => void` |  |

##### listeners

```typescript
listeners<E>(eventName: E): (args: indexedAccess) => void[]
```

Returns a copy of the array of listeners for the event named `eventName`.

```js
server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |

```typescript
listeners(eventName: string | symbol): (args: any[]) => void[]
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |

##### off

```typescript
off<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Alias for `emitter.removeListener()`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |
| `listener` | `(args: indexedAccess) => void` |  |

```typescript
off(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### on

```typescript
on<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Adds the `listener` function to the end of the listeners array for the
event named `eventName`. No checks are made to see if the `listener` has
already been added. Multiple calls passing the same combination of `eventName`
and `listener` will result in the `listener` being added, and called, multiple
times.

```js
server.on('connection', (stream) => {
  console.log('someone connected!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The
`emitter.prependListener()` method can be used as an alternative to add the
event listener to the beginning of the listeners array.

```js
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event. |
| `listener` | `(args: indexedAccess) => void` | The callback function |

```typescript
on(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### once

```typescript
once<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Adds a **one-time** `listener` function for the event named `eventName`. The
next time `eventName` is triggered, this listener is removed and then invoked.

```js
server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The
`emitter.prependOnceListener()` method can be used as an alternative to add the
event listener to the beginning of the listeners array.

```js
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event. |
| `listener` | `(args: indexedAccess) => void` | The callback function |

```typescript
once(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### pipe

```typescript
pipe<T>(destination: T, options?: PipeOptions): T
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `destination` | `T` |  |
| `options?` | `PipeOptions` |  |

##### prependListener

```typescript
prependListener<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Adds the `listener` function to the _beginning_ of the listeners array for the
event named `eventName`. No checks are made to see if the `listener` has
already been added. Multiple calls passing the same combination of `eventName`
and `listener` will result in the `listener` being added, and called, multiple
times.

```js
server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event. |
| `listener` | `(args: indexedAccess) => void` | The callback function |

```typescript
prependListener(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### prependOnceListener

```typescript
prependOnceListener<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Adds a **one-time** `listener` function for the event named `eventName` to the
_beginning_ of the listeners array. The next time `eventName` is triggered, this
listener is removed, and then invoked.

```js
server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event. |
| `listener` | `(args: indexedAccess) => void` | The callback function |

```typescript
prependOnceListener(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### rawListeners

```typescript
rawListeners<E>(eventName: E): (args: indexedAccess) => void[]
```

Returns a copy of the array of listeners for the event named `eventName`,
including any wrappers (such as those created by `.once()`).

```js
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |

```typescript
rawListeners(eventName: string | symbol): (args: any[]) => void[]
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |

##### removeAllListeners

```typescript
removeAllListeners<E>(eventName?: E): this
```

Removes all listeners, or those of the specified `eventName`.

It is bad practice to remove listeners added elsewhere in the code,
particularly when the `EventEmitter` instance was created by some other
component or module (e.g. sockets or file streams).

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName?` | `E` |  |

```typescript
removeAllListeners(eventName?: string | symbol): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName?` | `string \| symbol` |  |

##### removeListener

```typescript
removeListener<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Removes the specified `listener` from the listener array for the event named
`eventName`.

```js
const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
```

`removeListener()` will remove, at most, one instance of a listener from the
listener array. If any single listener has been added multiple times to the
listener array for the specified `eventName`, then `removeListener()` must be
called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the
time of emitting are called in order. This implies that any
`removeListener()` or `removeAllListeners()` calls _after_ emitting and
_before_ the last listener finishes execution will not remove them from
`emit()` in progress. Subsequent events behave as expected.

```js
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A
```

Because listeners are managed using an internal array, calling this will
change the position indexes of any listener registered _after_ the listener
being removed. This will not impact the order in which listeners are called,
but it means that any copies of the listener array as returned by
the `emitter.listeners()` method will need to be recreated.

When a single function has been added as a handler multiple times for a single
event (as in the example below), `removeListener()` will remove the most
recently added instance. In the example the `once('ping')`
listener is removed:

```js
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |
| `listener` | `(args: indexedAccess) => void` |  |

```typescript
removeListener(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### resize

```typescript
resize(columns: number, rows?: number): void
```

Changes the terminal size and emits `resize`, as a terminal does when its window changes.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `columns` | `number` |  |
| `rows?` | `number` |  |

##### setDefaultEncoding

```typescript
setDefaultEncoding(encoding: BufferEncoding): this
```

The `writable.setDefaultEncoding()` method sets the default `encoding` for a `Writable` stream.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `encoding` | `BufferEncoding` | The new default encoding |

##### setMaxListeners

```typescript
setMaxListeners(n: number): this
```

By default `EventEmitter`s will print a warning if more than `10` listeners are
added for a particular event. This is a useful default that helps finding
memory leaks. The `emitter.setMaxListeners()` method allows the limit to be
modified for this specific `EventEmitter` instance. The value can be set to
`Infinity` (or `0`) to indicate an unlimited number of listeners.

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `n` | `number` |  |

##### text

```typescript
text(): string
```

Everything written so far, decoded as UTF-8.

##### uncork

```typescript
uncork(): void
```

The `writable.uncork()` method flushes all data buffered since cork was called.

When using `writable.cork()` and `writable.uncork()` to manage the buffering
of writes to a stream, defer calls to `writable.uncork()` using `process.nextTick()`. Doing so allows batching of all `writable.write()` calls that occur within a given Node.js event
loop phase.

```js
stream.cork();
stream.write('some ');
stream.write('data ');
process.nextTick(() => stream.uncork());
```

If the `writable.cork()` method is called multiple times on a stream, the
same number of calls to `writable.uncork()` must be called to flush the buffered
data.

```js
stream.cork();
stream.write('some ');
stream.cork();
stream.write('data ');
process.nextTick(() => {
  stream.uncork();
  // The data will not be flushed until uncork() is called a second time.
  stream.uncork();
});
```

See also: `writable.cork()`.

##### write

```typescript
write(chunk: any, callback?: (error: Error) => void): boolean
```

The `writable.write()` method writes some data to the stream, and calls the
supplied `callback` once the data has been fully handled. If an error
occurs, the `callback` will be called with the error as its
first argument. The `callback` is called asynchronously and before `'error'` is
emitted.

The return value is `true` if the internal buffer is less than the `highWaterMark` configured when the stream was created after admitting `chunk`.
If `false` is returned, further attempts to write data to the stream should
stop until the `'drain'` event is emitted.

While a stream is not draining, calls to `write()` will buffer `chunk`, and
return false. Once all currently buffered chunks are drained (accepted for
delivery by the operating system), the `'drain'` event will be emitted.
Once `write()` returns false, do not write more chunks
until the `'drain'` event is emitted. While calling `write()` on a stream that
is not draining is allowed, Node.js will buffer all written chunks until
maximum memory usage occurs, at which point it will abort unconditionally.
Even before it aborts, high memory usage will cause poor garbage collector
performance and high RSS (which is not typically released back to the system,
even after the memory is no longer required). Since TCP sockets may never
drain if the remote peer does not read the data, writing a socket that is
not draining may lead to a remotely exploitable vulnerability.

Writing data while the stream is not draining is particularly
problematic for a `Transform`, because the `Transform` streams are paused
by default until they are piped or a `'data'` or `'readable'` event handler
is added.

If the data to be written can be generated or fetched on demand, it is
recommended to encapsulate the logic into a `Readable` and use pipe. However, if calling `write()` is preferred, it is
possible to respect backpressure and avoid memory issues using the `'drain'` event:

```js
function write(data, cb) {
  if (!stream.write(data)) {
    stream.once('drain', cb);
  } else {
    process.nextTick(cb);
  }
}

// Wait for cb to be called before doing any other write.
write('hello', () => {
  console.log('Write completed, do more writes now.');
});
```

A `Writable` stream in object mode will always ignore the `encoding` argument.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` | Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`. |
| `callback?` | `(error: Error) => void` | Callback for when this chunk of data is flushed. |

**Returns** `boolean`: `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.

```typescript
write(chunk: any, encoding: BufferEncoding, callback?: (error: Error) => void): boolean
```

Writes data to the stream, with an explicit encoding for string data.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` | Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`. |
| `encoding` | `BufferEncoding` | The encoding, if `chunk` is a string. |
| `callback?` | `(error: Error) => void` | Callback for when this chunk of data is flushed. |

**Returns** `boolean`: `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.

#### FakeChildProcess

A stand-in for the `ChildProcess` that `spawn`, `fork` and `exec` return, which a test
drives by hand.

**Properties**

| Name | Type | Description |
| --- | --- | --- |
| `pid` | `number` | Process identifier, or undefined as for a child the system never started. Assign undefined to model one. |
| `stdin` | `CapturedOutput` | What the parent wrote to the child's stdin. |
| `stdout` | `PassThrough` | The child's stdout, fed by `writeStdout`. |
| `stderr` | `PassThrough` | The child's stderr, fed by `writeStderr`. |
| `exitCode` | `number` | Exit code once exited normally, otherwise null. |
| `signalCode` | `Signals` | Signal that ended the child, otherwise null. |
| `killed` | `boolean` | Whether `kill` has been called. |
| `kill` | `MockFn<[unknown], boolean>` | Sends a signal. By default it marks the child killed and exits it with the signal on the next turn of the event loop; a child that already exited reports false. |

##### [captureRejectionSymbol]

```typescript
[captureRejectionSymbol](error: Error, event: string | symbol, ...args: any[]): void
```

The `Symbol.for('nodejs.rejection')` method is called in case a
promise rejection happens when emitting an event and
`captureRejections` is enabled on the emitter.
It is possible to use `events.captureRejectionSymbol` in
place of `Symbol.for('nodejs.rejection')`.

```js
import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `error` | `Error` |  |
| `event` | `string \| symbol` |  |
| `...args` | `any[]` |  |

##### addListener

```typescript
addListener<E>(eventName: string | symbol, listener: (args: any[]) => void): this
```

Alias for `emitter.on(eventName, listener)`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### emit

```typescript
emit<E>(eventName: string | symbol, ...args: any[]): boolean
```

Synchronously calls each of the listeners registered for the event named
`eventName`, in the order they were registered, passing the supplied arguments
to each.

Returns `true` if the event had listeners, `false` otherwise.

```js
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `...args` | `any[]` |  |

##### eventNames

```typescript
eventNames(): (string | symbol)[]
```

Returns an array listing the events for which the emitter has registered
listeners.

```js
import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
```

##### exit

```typescript
exit(code?: number, signal?: Signals): void
```

Ends the child: closes its output streams, emits `exit`, then `close` on the next turn of the event loop.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `code?` | `number` |  |
| `signal?` | `Signals` |  |

##### fail

```typescript
fail(error: Error): void
```

Emits `error`, as a child that failed to start does.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `error` | `Error` |  |

##### getMaxListeners

```typescript
getMaxListeners(): number
```

Returns the current max listener value for the `EventEmitter` which is either
set by `emitter.setMaxListeners(n)` or defaults to
`events.defaultMaxListeners`.

##### listenerCount

```typescript
listenerCount<E>(eventName: string | symbol, listener?: (args: any[]) => void): number
```

Returns the number of listeners listening for the event named `eventName`.
If `listener` is provided, it will return how many times the listener is found
in the list of the listeners of the event.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` | The name of the event being listened for |
| `listener?` | `(args: any[]) => void` | The event handler function |

##### listeners

```typescript
listeners<E>(eventName: string | symbol): (args: any[]) => void[]
```

Returns a copy of the array of listeners for the event named `eventName`.

```js
server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |

##### off

```typescript
off<E>(eventName: string | symbol, listener: (args: any[]) => void): this
```

Alias for `emitter.removeListener()`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### on

```typescript
on<E>(eventName: string | symbol, listener: (args: any[]) => void): this
```

Adds the `listener` function to the end of the listeners array for the
event named `eventName`. No checks are made to see if the `listener` has
already been added. Multiple calls passing the same combination of `eventName`
and `listener` will result in the `listener` being added, and called, multiple
times.

```js
server.on('connection', (stream) => {
  console.log('someone connected!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The
`emitter.prependListener()` method can be used as an alternative to add the
event listener to the beginning of the listeners array.

```js
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` | The name of the event. |
| `listener` | `(args: any[]) => void` | The callback function |

##### once

```typescript
once<E>(eventName: string | symbol, listener: (args: any[]) => void): this
```

Adds a **one-time** `listener` function for the event named `eventName`. The
next time `eventName` is triggered, this listener is removed and then invoked.

```js
server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The
`emitter.prependOnceListener()` method can be used as an alternative to add the
event listener to the beginning of the listeners array.

```js
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` | The name of the event. |
| `listener` | `(args: any[]) => void` | The callback function |

##### prependListener

```typescript
prependListener<E>(eventName: string | symbol, listener: (args: any[]) => void): this
```

Adds the `listener` function to the _beginning_ of the listeners array for the
event named `eventName`. No checks are made to see if the `listener` has
already been added. Multiple calls passing the same combination of `eventName`
and `listener` will result in the `listener` being added, and called, multiple
times.

```js
server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` | The name of the event. |
| `listener` | `(args: any[]) => void` | The callback function |

##### prependOnceListener

```typescript
prependOnceListener<E>(eventName: string | symbol, listener: (args: any[]) => void): this
```

Adds a **one-time** `listener` function for the event named `eventName` to the
_beginning_ of the listeners array. The next time `eventName` is triggered, this
listener is removed, and then invoked.

```js
server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` | The name of the event. |
| `listener` | `(args: any[]) => void` | The callback function |

##### rawListeners

```typescript
rawListeners<E>(eventName: string | symbol): (args: any[]) => void[]
```

Returns a copy of the array of listeners for the event named `eventName`,
including any wrappers (such as those created by `.once()`).

```js
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |

##### removeAllListeners

```typescript
removeAllListeners<E>(eventName?: string | symbol): this
```

Removes all listeners, or those of the specified `eventName`.

It is bad practice to remove listeners added elsewhere in the code,
particularly when the `EventEmitter` instance was created by some other
component or module (e.g. sockets or file streams).

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName?` | `string \| symbol` |  |

##### removeListener

```typescript
removeListener<E>(eventName: string | symbol, listener: (args: any[]) => void): this
```

Removes the specified `listener` from the listener array for the event named
`eventName`.

```js
const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
```

`removeListener()` will remove, at most, one instance of a listener from the
listener array. If any single listener has been added multiple times to the
listener array for the specified `eventName`, then `removeListener()` must be
called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the
time of emitting are called in order. This implies that any
`removeListener()` or `removeAllListeners()` calls _after_ emitting and
_before_ the last listener finishes execution will not remove them from
`emit()` in progress. Subsequent events behave as expected.

```js
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A
```

Because listeners are managed using an internal array, calling this will
change the position indexes of any listener registered _after_ the listener
being removed. This will not impact the order in which listeners are called,
but it means that any copies of the listener array as returned by
the `emitter.listeners()` method will need to be recreated.

When a single function has been added as a handler multiple times for a single
event (as in the example below), `removeListener()` will remove the most
recently added instance. In the example the `once('ping')`
listener is removed:

```js
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### setMaxListeners

```typescript
setMaxListeners(n: number): this
```

By default `EventEmitter`s will print a warning if more than `10` listeners are
added for a particular event. This is a useful default that helps finding
memory leaks. The `emitter.setMaxListeners()` method allows the limit to be
modified for this specific `EventEmitter` instance. The value can be set to
`Infinity` (or `0`) to indicate an unlimited number of listeners.

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `n` | `number` |  |

##### writeStderr

```typescript
writeStderr(text: string): void
```

Writes text to the child's stderr.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `text` | `string` |  |

##### writeStdout

```typescript
writeStdout(text: string): void
```

Writes text to the child's stdout.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `text` | `string` |  |

#### TtyInput

A readable stream standing in for a terminal's stdin, which a test types into.

**Properties**

| Name | Type | Description |
| --- | --- | --- |
| `isTTY` | `true` | Always true, so code that checks for a terminal treats the stream as one. |
| `isRaw` | `boolean` | Whether raw mode is on, as last set through `setRawMode`. |
| `readonly readableAborted` | `boolean` | Returns whether the stream was destroyed or errored before emitting `'end'`. |
| `readable` | `boolean` | Is `true` if it is safe to call read, which means the stream has not been destroyed or emitted `'error'` or `'end'`. |
| `readonly readableDidRead` | `boolean` | Returns whether `'data'` has been emitted. |
| `readonly readableEncoding` | `BufferEncoding` | Getter for the property `encoding` of a given `Readable` stream. The `encoding` property can be set using the setEncoding method. |
| `readonly readableEnded` | `boolean` | Becomes `true` when [`'end'`](https://nodejs.org/docs/latest-v25.x/api/stream.html#event-end) event is emitted. |
| `readableFlowing` | `boolean` | This property reflects the current state of a `Readable` stream as described in the [Three states](https://nodejs.org/docs/latest-v25.x/api/stream.html#three-states) section. |
| `readonly readableHighWaterMark` | `number` | Returns the value of `highWaterMark` passed when creating this `Readable`. |
| `readonly readableLength` | `number` | This property contains the number of bytes (or objects) in the queue ready to be read. The value provides introspection data regarding the status of the `highWaterMark`. |
| `readonly readableObjectMode` | `boolean` | Getter for the property `objectMode` of a given `Readable` stream. |
| `destroyed` | `boolean` | Is `true` after `readable.destroy()` has been called. |
| `readonly closed` | `boolean` | Is `true` after `'close'` has been emitted. |
| `readonly errored` | `Error` | Returns error if the stream has been destroyed with an error. |
| `writable` | `boolean` | Is `true` if it is safe to call `writable.write()`, which means the stream has not been destroyed, errored, or ended. |
| `readonly writableAborted` | `boolean` | Returns whether the stream was destroyed or errored before emitting `'finish'`. |
| `readonly writableEnded` | `boolean` | Is `true` after `writable.end()` has been called. This property does not indicate whether the data has been flushed, for this use `writable.writableFinished` instead. |
| `readonly writableFinished` | `boolean` | Is set to `true` immediately before the `'finish'` event is emitted. |
| `readonly writableHighWaterMark` | `number` | Return the value of `highWaterMark` passed when creating this `Writable`. |
| `readonly writableLength` | `number` | This property contains the number of bytes (or objects) in the queue ready to be written. The value provides introspection data regarding the status of the `highWaterMark`. |
| `readonly writableObjectMode` | `boolean` | Getter for the property `objectMode` of a given `Writable` stream. |
| `readonly writableCorked` | `number` | Number of times `writable.uncork()` needs to be called in order to fully uncork the stream. |
| `readonly writableNeedDrain` | `boolean` | Is `true` if the stream's buffer has been full and stream will emit `'drain'`. |
| `allowHalfOpen` | `boolean` | If `false` then the stream will automatically end the writable side when the readable side ends. Set initially by the `allowHalfOpen` constructor option, which defaults to `true`. This can be changed manually to change the half-open behavior of an existing `Duplex` stream instance, but must be changed before the `'end'` event is emitted. |

##### _construct

```typescript
_construct(callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `callback` | `(error?: Error) => void` |  |

##### _destroy

```typescript
_destroy(error: Error, callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `error` | `Error` |  |
| `callback` | `(error?: Error) => void` |  |

##### _final

```typescript
_final(callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `callback` | `(error?: Error) => void` |  |

##### _flush

```typescript
_flush(callback: TransformCallback): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `callback` | `TransformCallback` |  |

##### _read

```typescript
_read(size: number): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `size` | `number` |  |

##### _transform

```typescript
_transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` |  |
| `encoding` | `BufferEncoding` |  |
| `callback` | `TransformCallback` |  |

##### _write

```typescript
_write(chunk: any, encoding: BufferEncoding, callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` |  |
| `encoding` | `BufferEncoding` |  |
| `callback` | `(error?: Error) => void` |  |

##### _writev

```typescript
_writev(chunks: { chunk: any; encoding: BufferEncoding }[], callback: (error?: Error) => void): void
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunks` | `{ chunk: any; encoding: BufferEncoding }[]` |  |
| `callback` | `(error?: Error) => void` |  |

##### [asyncDispose]

```typescript
[asyncDispose](): Promise<void>
```

Calls `readable.destroy()` with an `AbortError` and returns
a promise that fulfills when the stream is finished.

##### [asyncIterator]

```typescript
[asyncIterator](): AsyncIterator<any>
```

**Returns** `AsyncIterator<any>`: `AsyncIterator` to fully consume the stream.

##### [captureRejectionSymbol]

```typescript
[captureRejectionSymbol](error: Error, event: string | symbol, ...args: any[]): void
```

The `Symbol.for('nodejs.rejection')` method is called in case a
promise rejection happens when emitting an event and
`captureRejections` is enabled on the emitter.
It is possible to use `events.captureRejectionSymbol` in
place of `Symbol.for('nodejs.rejection')`.

```js
import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `error` | `Error` |  |
| `event` | `string \| symbol` |  |
| `...args` | `any[]` |  |

##### addListener

```typescript
addListener<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Alias for `emitter.on(eventName, listener)`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |
| `listener` | `(args: indexedAccess) => void` |  |

```typescript
addListener(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### compose

```typescript
compose(stream: WritableStream | WritableStream<any> | TransformStream<any, any> | (source: any) => void, options?: Abortable): Duplex
```

```js
import { Readable } from 'node:stream';

async function* splitToWords(source) {
  for await (const chunk of source) {
    const words = String(chunk).split(' ');

    for (const word of words) {
      yield word;
    }
  }
}

const wordsStream = Readable.from(['text passed through', 'composed stream']).compose(splitToWords);
const words = await wordsStream.toArray();

console.log(words); // prints ['text', 'passed', 'through', 'composed', 'stream']
```

`readable.compose(s)` is equivalent to `stream.compose(readable, s)`.

This method also allows for an `AbortSignal` to be provided, which will destroy
the composed stream when aborted.

See [`stream.compose(...streams)`](https://nodejs.org/docs/latest-v25.x/api/stream.html#streamcomposestreams) for more information.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `stream` | `WritableStream \| WritableStream<any> \| TransformStream<any, any> \| (source: any) => void` |  |
| `options?` | `Abortable` |  |

**Returns** `Duplex`: a stream composed with the stream `stream`.

##### cork

```typescript
cork(): void
```

The `writable.cork()` method forces all written data to be buffered in memory.
The buffered data will be flushed when either the uncork or end methods are called.

The primary intent of `writable.cork()` is to accommodate a situation in which
several small chunks are written to the stream in rapid succession. Instead of
immediately forwarding them to the underlying destination, `writable.cork()` buffers all the chunks until `writable.uncork()` is called, which will pass them
all to `writable._writev()`, if present. This prevents a head-of-line blocking
situation where data is being buffered while waiting for the first small chunk
to be processed. However, use of `writable.cork()` without implementing `writable._writev()` may have an adverse effect on throughput.

See also: `writable.uncork()`, `writable._writev()`.

##### destroy

```typescript
destroy(error?: Error): this
```

Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'` event (unless `emitClose` is set to `false`). After this call, the readable
stream will release any internal resources and subsequent calls to `push()` will be ignored.

Once `destroy()` has been called any further calls will be a no-op and no
further errors except from `_destroy()` may be emitted as `'error'`.

Implementors should not override this method, but instead implement `readable._destroy()`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `error?` | `Error` | Error which will be passed as payload in `'error'` event |

##### drop

```typescript
drop(limit: number, options?: Abortable): Readable
```

This method returns a new stream with the first *limit* chunks dropped from the start.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `limit` | `number` | the number of chunks to drop from the readable. |
| `options?` | `Abortable` |  |

**Returns** `Readable`: a stream with *limit* chunks dropped from the start.

##### emit

```typescript
emit<E>(eventName: E, ...args: indexedAccess): boolean
```

Synchronously calls each of the listeners registered for the event named
`eventName`, in the order they were registered, passing the supplied arguments
to each.

Returns `true` if the event had listeners, `false` otherwise.

```js
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |
| `...args` | `indexedAccess` |  |

```typescript
emit(eventName: string | symbol, ...args: any[]): boolean
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `...args` | `any[]` |  |

##### end

```typescript
end(cb?: () => void): this
```

Calling the `writable.end()` method signals that no more data will be written
to the `Writable`. The optional `chunk` and `encoding` arguments allow one
final additional chunk of data to be written immediately before closing the
stream.

Calling the write method after calling end will raise an error.

```js
// Write 'hello, ' and then end with 'world!'.
import fs from 'node:fs';
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed!
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `cb?` | `() => void` | Callback for when the stream is finished. |

```typescript
end(chunk: any, cb?: () => void): this
```

Signals that no more data will be written, with one final chunk of data.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` | Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`. |
| `cb?` | `() => void` | Callback for when the stream is finished. |

```typescript
end(chunk: any, encoding: BufferEncoding, cb?: () => void): this
```

Signals that no more data will be written, with one final chunk of data.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` | Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`. |
| `encoding` | `BufferEncoding` | The encoding if `chunk` is a string |
| `cb?` | `() => void` | Callback for when the stream is finished. |

##### eventNames

```typescript
eventNames(): (string | symbol)[]
```

Returns an array listing the events for which the emitter has registered
listeners.

```js
import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
```

##### every

```typescript
every(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>
```

This method is similar to `Array.prototype.every` and calls *fn* on each chunk in the stream
to check if all awaited return values are truthy value for *fn*. Once an *fn* call on a chunk
`await`ed return value is falsy, the stream is destroyed and the promise is fulfilled with `false`.
If all of the *fn* calls on the chunks return a truthy value, the promise is fulfilled with `true`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(data: any, options?: Abortable) => boolean \| Promise<boolean>` | a function to call on each chunk of the stream. Async or not. |
| `options?` | `Pick<ReadableOperatorOptions, "concurrency" \| "signal">` |  |

**Returns** `Promise<boolean>`: a promise evaluating to `true` if *fn* returned a truthy value for every one of the chunks.

##### filter

```typescript
filter(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: ReadableOperatorOptions): Readable
```

This method allows filtering the stream. For each chunk in the stream the *fn* function will be called
and if it returns a truthy value, the chunk will be passed to the result stream.
If the *fn* function returns a promise - that promise will be `await`ed.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(data: any, options?: Abortable) => boolean \| Promise<boolean>` | a function to filter chunks from the stream. Async or not. |
| `options?` | `ReadableOperatorOptions` |  |

**Returns** `Readable`: a stream filtered with the predicate *fn*.

##### find

```typescript
find<T>(fn: (data: any, options?: Abortable) => unknown, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<T>
```

This method is similar to `Array.prototype.find` and calls *fn* on each chunk in the stream
to find a chunk with a truthy value for *fn*. Once an *fn* call's awaited return value is truthy,
the stream is destroyed and the promise is fulfilled with value for which *fn* returned a truthy value.
If all of the *fn* calls on the chunks return a falsy value, the promise is fulfilled with `undefined`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(data: any, options?: Abortable) => unknown` | a function to call on each chunk of the stream. Async or not. |
| `options?` | `Pick<ReadableOperatorOptions, "concurrency" \| "signal">` |  |

**Returns** `Promise<T>`: a promise evaluating to the first chunk for which *fn* evaluated with a truthy value, or `undefined` if no element was found.

```typescript
find(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<any>
```

This method is similar to `Array.prototype.find` and calls *fn* on each chunk in the stream
to find a chunk with a truthy value for *fn*. Once an *fn* call's awaited return value is truthy,
the stream is destroyed and the promise is fulfilled with value for which *fn* returned a truthy value.
If all of the *fn* calls on the chunks return a falsy value, the promise is fulfilled with `undefined`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(data: any, options?: Abortable) => boolean \| Promise<boolean>` | a function to call on each chunk of the stream. Async or not. |
| `options?` | `Pick<ReadableOperatorOptions, "concurrency" \| "signal">` |  |

**Returns** `Promise<any>`: a promise evaluating to the first chunk for which *fn* evaluated with a truthy value, or `undefined` if no element was found.

##### flatMap

```typescript
flatMap(fn: (data: any, options?: Abortable) => any, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Readable
```

This method returns a new stream by applying the given callback to each chunk of the stream
and then flattening the result.

It is possible to return a stream or another iterable or async iterable from *fn* and the result streams
will be merged (flattened) into the returned stream.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(data: any, options?: Abortable) => any` | a function to map over every chunk in the stream. May be async. May be a stream or generator. |
| `options?` | `Pick<ReadableOperatorOptions, "concurrency" \| "signal">` |  |

**Returns** `Readable`: a stream flat-mapped with the function *fn*.

##### forEach

```typescript
forEach(fn: (data: any, options?: Abortable) => void | Promise<void>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<void>
```

This method allows iterating a stream. For each chunk in the stream the *fn* function will be called.
If the *fn* function returns a promise - that promise will be `await`ed.

This method is different from `for await...of` loops in that it can optionally process chunks concurrently.
In addition, a `forEach` iteration can only be stopped by having passed a `signal` option
and aborting the related AbortController while `for await...of` can be stopped with `break` or `return`.
In either case the stream will be destroyed.

This method is different from listening to the `'data'` event in that it uses the `readable` event
in the underlying machinary and can limit the number of concurrent *fn* calls.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(data: any, options?: Abortable) => void \| Promise<void>` | a function to call on each chunk of the stream. Async or not. |
| `options?` | `Pick<ReadableOperatorOptions, "concurrency" \| "signal">` |  |

**Returns** `Promise<void>`: a promise for when the stream has finished.

##### getMaxListeners

```typescript
getMaxListeners(): number
```

Returns the current max listener value for the `EventEmitter` which is either
set by `emitter.setMaxListeners(n)` or defaults to
`events.defaultMaxListeners`.

##### isPaused

```typescript
isPaused(): boolean
```

The `readable.isPaused()` method returns the current operating state of the `Readable`.
This is used primarily by the mechanism that underlies the `readable.pipe()` method.
In most typical cases, there will be no reason to use this method directly.

```js
const readable = new stream.Readable();

readable.isPaused(); // === false
readable.pause();
readable.isPaused(); // === true
readable.resume();
readable.isPaused(); // === false
```

##### iterator

```typescript
iterator(options?: ReadableIteratorOptions): AsyncIterator<any>
```

The iterator created by this method gives users the option to cancel the destruction
of the stream if the `for await...of` loop is exited by `return`, `break`, or `throw`,
or if the iterator should destroy the stream if the stream emitted an error during iteration.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `options?` | `ReadableIteratorOptions` |  |

##### listenerCount

```typescript
listenerCount<E>(eventName: E, listener?: (args: indexedAccess) => void): number
```

Returns the number of listeners listening for the event named `eventName`.
If `listener` is provided, it will return how many times the listener is found
in the list of the listeners of the event.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event being listened for |
| `listener?` | `(args: indexedAccess) => void` | The event handler function |

```typescript
listenerCount(eventName: string | symbol, listener?: (args: any[]) => void): number
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener?` | `(args: any[]) => void` |  |

##### listeners

```typescript
listeners<E>(eventName: E): (args: indexedAccess) => void[]
```

Returns a copy of the array of listeners for the event named `eventName`.

```js
server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |

```typescript
listeners(eventName: string | symbol): (args: any[]) => void[]
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |

##### map

```typescript
map(fn: (data: any, options?: Abortable) => any, options?: ReadableOperatorOptions): Readable
```

This method allows mapping over the stream. The *fn* function will be called for every chunk in the stream.
If the *fn* function returns a promise - that promise will be `await`ed before being passed to the result stream.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(data: any, options?: Abortable) => any` | a function to map over every chunk in the stream. Async or not. |
| `options?` | `ReadableOperatorOptions` |  |

**Returns** `Readable`: a stream mapped with the function *fn*.

##### off

```typescript
off<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Alias for `emitter.removeListener()`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |
| `listener` | `(args: indexedAccess) => void` |  |

```typescript
off(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### on

```typescript
on<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Adds the `listener` function to the end of the listeners array for the
event named `eventName`. No checks are made to see if the `listener` has
already been added. Multiple calls passing the same combination of `eventName`
and `listener` will result in the `listener` being added, and called, multiple
times.

```js
server.on('connection', (stream) => {
  console.log('someone connected!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The
`emitter.prependListener()` method can be used as an alternative to add the
event listener to the beginning of the listeners array.

```js
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event. |
| `listener` | `(args: indexedAccess) => void` | The callback function |

```typescript
on(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### once

```typescript
once<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Adds a **one-time** `listener` function for the event named `eventName`. The
next time `eventName` is triggered, this listener is removed and then invoked.

```js
server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The
`emitter.prependOnceListener()` method can be used as an alternative to add the
event listener to the beginning of the listeners array.

```js
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event. |
| `listener` | `(args: indexedAccess) => void` | The callback function |

```typescript
once(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### paste

```typescript
paste(text: string): Promise<void>
```

Sends text as one bracketed paste, resolving once it has been sent.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `text` | `string` |  |

##### pause

```typescript
pause(): this
```

The `readable.pause()` method will cause a stream in flowing mode to stop
emitting `'data'` events, switching out of flowing mode. Any data that
becomes available will remain in the internal buffer.

```js
const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
  console.log(`Received ${chunk.length} bytes of data.`);
  readable.pause();
  console.log('There will be no additional data for 1 second.');
  setTimeout(() => {
    console.log('Now data will start flowing again.');
    readable.resume();
  }, 1000);
});
```

The `readable.pause()` method has no effect if there is a `'readable'` event listener.

##### pipe

```typescript
pipe<T>(destination: T, options?: PipeOptions): T
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `destination` | `T` |  |
| `options?` | `PipeOptions` |  |

##### prependListener

```typescript
prependListener<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Adds the `listener` function to the _beginning_ of the listeners array for the
event named `eventName`. No checks are made to see if the `listener` has
already been added. Multiple calls passing the same combination of `eventName`
and `listener` will result in the `listener` being added, and called, multiple
times.

```js
server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event. |
| `listener` | `(args: indexedAccess) => void` | The callback function |

```typescript
prependListener(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### prependOnceListener

```typescript
prependOnceListener<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Adds a **one-time** `listener` function for the event named `eventName` to the
_beginning_ of the listeners array. The next time `eventName` is triggered, this
listener is removed, and then invoked.

```js
server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` | The name of the event. |
| `listener` | `(args: indexedAccess) => void` | The callback function |

```typescript
prependOnceListener(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### push

```typescript
push(chunk: any, encoding?: BufferEncoding): boolean
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` |  |
| `encoding?` | `BufferEncoding` |  |

##### rawListeners

```typescript
rawListeners<E>(eventName: E): (args: indexedAccess) => void[]
```

Returns a copy of the array of listeners for the event named `eventName`,
including any wrappers (such as those created by `.once()`).

```js
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |

```typescript
rawListeners(eventName: string | symbol): (args: any[]) => void[]
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |

##### read

```typescript
read(size?: number): any
```

The `readable.read()` method reads data out of the internal buffer and
returns it. If no data is available to be read, `null` is returned. By default,
the data is returned as a `Buffer` object unless an encoding has been
specified using the `readable.setEncoding()` method or the stream is operating
in object mode.

The optional `size` argument specifies a specific number of bytes to read. If
`size` bytes are not available to be read, `null` will be returned _unless_ the
stream has ended, in which case all of the data remaining in the internal buffer
will be returned.

If the `size` argument is not specified, all of the data contained in the
internal buffer will be returned.

The `size` argument must be less than or equal to 1 GiB.

The `readable.read()` method should only be called on `Readable` streams
operating in paused mode. In flowing mode, `readable.read()` is called
automatically until the internal buffer is fully drained.

```js
const readable = getReadableStreamSomehow();

// 'readable' may be triggered multiple times as data is buffered in
readable.on('readable', () => {
  let chunk;
  console.log('Stream is readable (new data received in buffer)');
  // Use a loop to make sure we read all currently available data
  while (null !== (chunk = readable.read())) {
    console.log(`Read ${chunk.length} bytes of data...`);
  }
});

// 'end' will be triggered once when there is no more data available
readable.on('end', () => {
  console.log('Reached end of stream.');
});
```

Each call to `readable.read()` returns a chunk of data, or `null`. The chunks
are not concatenated. A `while` loop is necessary to consume all data
currently in the buffer. When reading a large file `.read()` may return `null`,
having consumed all buffered content so far, but there is still more data to
come not yet buffered. In this case a new `'readable'` event will be emitted
when there is more data in the buffer. Finally the `'end'` event will be
emitted when there is no more data to come.

Therefore to read a file's whole contents from a `readable`, it is necessary
to collect chunks across multiple `'readable'` events:

```js
const chunks = [];

readable.on('readable', () => {
  let chunk;
  while (null !== (chunk = readable.read())) {
    chunks.push(chunk);
  }
});

readable.on('end', () => {
  const content = chunks.join('');
});
```

A `Readable` stream in object mode will always return a single item from
a call to `readable.read(size)`, regardless of the value of the `size` argument.

If the `readable.read()` method returns a chunk of data, a `'data'` event will
also be emitted.

Calling read after the `'end'` event has
been emitted will return `null`. No runtime error will be raised.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `size?` | `number` | Optional argument to specify how much data to read. |

##### reduce

```typescript
reduce<T>(fn: (previous: any, data: any, options?: Abortable) => T): Promise<T>
```

This method calls *fn* on each chunk of the stream in order, passing it the result from the calculation
on the previous element. It returns a promise for the final value of the reduction.

If no *initial* value is supplied the first chunk of the stream is used as the initial value.
If the stream is empty, the promise is rejected with a `TypeError` with the `ERR_INVALID_ARGS` code property.

The reducer function iterates the stream element-by-element which means that there is no *concurrency* parameter
or parallelism. To perform a reduce concurrently, you can extract the async function to `readable.map` method.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(previous: any, data: any, options?: Abortable) => T` | a reducer function to call over every chunk in the stream. Async or not. |

**Returns** `Promise<T>`: a promise for the final value of the reduction.

```typescript
reduce<T>(fn: (previous: T, data: any, options?: Abortable) => T, initial: T, options?: Abortable): Promise<T>
```

This method calls *fn* on each chunk of the stream in order, passing it the result from the calculation
on the previous element. It returns a promise for the final value of the reduction.

If no *initial* value is supplied the first chunk of the stream is used as the initial value.
If the stream is empty, the promise is rejected with a `TypeError` with the `ERR_INVALID_ARGS` code property.

The reducer function iterates the stream element-by-element which means that there is no *concurrency* parameter
or parallelism. To perform a reduce concurrently, you can extract the async function to `readable.map` method.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(previous: T, data: any, options?: Abortable) => T` | a reducer function to call over every chunk in the stream. Async or not. |
| `initial` | `T` | the initial value to use in the reduction. |
| `options?` | `Abortable` |  |

**Returns** `Promise<T>`: a promise for the final value of the reduction.

##### removeAllListeners

```typescript
removeAllListeners<E>(eventName?: E): this
```

Removes all listeners, or those of the specified `eventName`.

It is bad practice to remove listeners added elsewhere in the code,
particularly when the `EventEmitter` instance was created by some other
component or module (e.g. sockets or file streams).

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName?` | `E` |  |

```typescript
removeAllListeners(eventName?: string | symbol): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName?` | `string \| symbol` |  |

##### removeListener

```typescript
removeListener<E>(eventName: E, listener: (args: indexedAccess) => void): this
```

Removes the specified `listener` from the listener array for the event named
`eventName`.

```js
const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
```

`removeListener()` will remove, at most, one instance of a listener from the
listener array. If any single listener has been added multiple times to the
listener array for the specified `eventName`, then `removeListener()` must be
called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the
time of emitting are called in order. This implies that any
`removeListener()` or `removeAllListeners()` calls _after_ emitting and
_before_ the last listener finishes execution will not remove them from
`emit()` in progress. Subsequent events behave as expected.

```js
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A
```

Because listeners are managed using an internal array, calling this will
change the position indexes of any listener registered _after_ the listener
being removed. This will not impact the order in which listeners are called,
but it means that any copies of the listener array as returned by
the `emitter.listeners()` method will need to be recreated.

When a single function has been added as a handler multiple times for a single
event (as in the example below), `removeListener()` will remove the most
recently added instance. In the example the `once('ping')`
listener is removed:

```js
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');
```

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `E` |  |
| `listener` | `(args: indexedAccess) => void` |  |

```typescript
removeListener(eventName: string | symbol, listener: (args: any[]) => void): this
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `eventName` | `string \| symbol` |  |
| `listener` | `(args: any[]) => void` |  |

##### resume

```typescript
resume(): this
```

The `readable.resume()` method causes an explicitly paused `Readable` stream to
resume emitting `'data'` events, switching the stream into flowing mode.

The `readable.resume()` method can be used to fully consume the data from a
stream without actually processing any of that data:

```js
getReadableStreamSomehow()
  .resume()
  .on('end', () => {
    console.log('Reached the end, but did not read anything.');
  });
```

The `readable.resume()` method has no effect if there is a `'readable'` event listener.

##### sendKeys

```typescript
sendKeys(...keys: string[]): Promise<void>
```

Sends key sequences one at a time, each on its own turn of the event loop, resolving after the last.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `...keys` | `string[]` |  |

##### setDefaultEncoding

```typescript
setDefaultEncoding(encoding: BufferEncoding): this
```

The `writable.setDefaultEncoding()` method sets the default `encoding` for a `Writable` stream.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `encoding` | `BufferEncoding` | The new default encoding |

##### setEncoding

```typescript
setEncoding(encoding: BufferEncoding): this
```

The `readable.setEncoding()` method sets the character encoding for
data read from the `Readable` stream.

By default, no encoding is assigned and stream data will be returned as `Buffer` objects. Setting an encoding causes the stream data
to be returned as strings of the specified encoding rather than as `Buffer` objects. For instance, calling `readable.setEncoding('utf8')` will cause the
output data to be interpreted as UTF-8 data, and passed as strings. Calling `readable.setEncoding('hex')` will cause the data to be encoded in hexadecimal
string format.

The `Readable` stream will properly handle multi-byte characters delivered
through the stream that would otherwise become improperly decoded if simply
pulled from the stream as `Buffer` objects.

```js
const readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', (chunk) => {
  assert.equal(typeof chunk, 'string');
  console.log('Got %d characters of string data:', chunk.length);
});
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `encoding` | `BufferEncoding` | The encoding to use. |

##### setMaxListeners

```typescript
setMaxListeners(n: number): this
```

By default `EventEmitter`s will print a warning if more than `10` listeners are
added for a particular event. This is a useful default that helps finding
memory leaks. The `emitter.setMaxListeners()` method allows the limit to be
modified for this specific `EventEmitter` instance. The value can be set to
`Infinity` (or `0`) to indicate an unlimited number of listeners.

Returns a reference to the `EventEmitter`, so that calls can be chained.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `n` | `number` |  |

##### setRawMode

```typescript
setRawMode(mode: boolean): TtyInput
```

Records the raw-mode flag, as a terminal's stdin would apply it.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `mode` | `boolean` |  |

##### some

```typescript
some(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>
```

This method is similar to `Array.prototype.some` and calls *fn* on each chunk in the stream
until the awaited return value is `true` (or any truthy value). Once an *fn* call on a chunk
`await`ed return value is truthy, the stream is destroyed and the promise is fulfilled with `true`.
If none of the *fn* calls on the chunks return a truthy value, the promise is fulfilled with `false`.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `fn` | `(data: any, options?: Abortable) => boolean \| Promise<boolean>` | a function to call on each chunk of the stream. Async or not. |
| `options?` | `Pick<ReadableOperatorOptions, "concurrency" \| "signal">` |  |

**Returns** `Promise<boolean>`: a promise evaluating to `true` if *fn* returned a truthy value for at least one of the chunks.

##### take

```typescript
take(limit: number, options?: Abortable): Readable
```

This method returns a new stream with the first *limit* chunks.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `limit` | `number` | the number of chunks to take from the readable. |
| `options?` | `Abortable` |  |

**Returns** `Readable`: a stream with *limit* chunks taken.

##### toArray

```typescript
toArray(options?: Abortable): Promise<any[]>
```

This method allows easily obtaining the contents of a stream.

As this method reads the entire stream into memory, it negates the benefits of streams. It's intended
for interoperability and convenience, not as the primary way to consume streams.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `options?` | `Abortable` |  |

**Returns** `Promise<any[]>`: a promise containing an array with the contents of the stream.

##### uncork

```typescript
uncork(): void
```

The `writable.uncork()` method flushes all data buffered since cork was called.

When using `writable.cork()` and `writable.uncork()` to manage the buffering
of writes to a stream, defer calls to `writable.uncork()` using `process.nextTick()`. Doing so allows batching of all `writable.write()` calls that occur within a given Node.js event
loop phase.

```js
stream.cork();
stream.write('some ');
stream.write('data ');
process.nextTick(() => stream.uncork());
```

If the `writable.cork()` method is called multiple times on a stream, the
same number of calls to `writable.uncork()` must be called to flush the buffered
data.

```js
stream.cork();
stream.write('some ');
stream.cork();
stream.write('data ');
process.nextTick(() => {
  stream.uncork();
  // The data will not be flushed until uncork() is called a second time.
  stream.uncork();
});
```

See also: `writable.cork()`.

##### unpipe

```typescript
unpipe(destination?: WritableStream): this
```

The `readable.unpipe()` method detaches a `Writable` stream previously attached
using the pipe method.

If the `destination` is not specified, then _all_ pipes are detached.

If the `destination` is specified, but no pipe is set up for it, then
the method does nothing.

```js
import fs from 'node:fs';
const readable = getReadableStreamSomehow();
const writable = fs.createWriteStream('file.txt');
// All the data from readable goes into 'file.txt',
// but only for the first second.
readable.pipe(writable);
setTimeout(() => {
  console.log('Stop writing to file.txt.');
  readable.unpipe(writable);
  console.log('Manually close the file stream.');
  writable.end();
}, 1000);
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `destination?` | `WritableStream` | Optional specific stream to unpipe |

##### unshift

```typescript
unshift(chunk: any, encoding?: BufferEncoding): void
```

Passing `chunk` as `null` signals the end of the stream (EOF) and behaves the
same as `readable.push(null)`, after which no more data can be written. The EOF
signal is put at the end of the buffer and any buffered data will still be
flushed.

The `readable.unshift()` method pushes a chunk of data back into the internal
buffer. This is useful in certain situations where a stream is being consumed by
code that needs to "un-consume" some amount of data that it has optimistically
pulled out of the source, so that the data can be passed on to some other party.

The `stream.unshift(chunk)` method cannot be called after the `'end'` event
has been emitted or a runtime error will be thrown.

Developers using `stream.unshift()` often should consider switching to
use of a `Transform` stream instead. See the `API for stream implementers` section for more information.

```js
// Pull off a header delimited by \n\n.
// Use unshift() if we get too much.
// Call the callback with (error, header, stream).
import { StringDecoder } from 'node:string_decoder';
function parseHeader(stream, callback) {
  stream.on('error', callback);
  stream.on('readable', onReadable);
  const decoder = new StringDecoder('utf8');
  let header = '';
  function onReadable() {
    let chunk;
    while (null !== (chunk = stream.read())) {
      const str = decoder.write(chunk);
      if (str.includes('\n\n')) {
        // Found the header boundary.
        const split = str.split(/\n\n/);
        header += split.shift();
        const remaining = split.join('\n\n');
        const buf = Buffer.from(remaining, 'utf8');
        stream.removeListener('error', callback);
        // Remove the 'readable' listener before unshifting.
        stream.removeListener('readable', onReadable);
        if (buf.length)
          stream.unshift(buf);
        // Now the body of the message can be read from the stream.
        callback(null, header, stream);
        return;
      }
      // Still reading the header.
      header += str;
    }
  }
}
```

Unlike push, `stream.unshift(chunk)` will not
end the reading process by resetting the internal reading state of the stream.
This can cause unexpected results if `readable.unshift()` is called during a
read (i.e. from within a _read implementation on a
custom stream). Following the call to `readable.unshift()` with an immediate push will reset the reading state appropriately,
however it is best to simply avoid calling `readable.unshift()` while in the
process of performing a read.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` | Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray}, {DataView} or `null`. For object mode streams, `chunk` may be any JavaScript value. |
| `encoding?` | `BufferEncoding` | Encoding of string chunks. Must be a valid `Buffer` encoding, such as `'utf8'` or `'ascii'`. |

##### wrap

```typescript
wrap(stream: ReadableStream): this
```

Prior to Node.js 0.10, streams did not implement the entire `node:stream` module API as it is currently defined. (See `Compatibility` for more
information.)

When using an older Node.js library that emits `'data'` events and has a pause method that is advisory only, the `readable.wrap()` method can be used to create a `Readable`
stream that uses
the old stream as its data source.

It will rarely be necessary to use `readable.wrap()` but the method has been
provided as a convenience for interacting with older Node.js applications and
libraries.

```js
import { OldReader } from './old-api-module.js';
import { Readable } from 'node:stream';
const oreader = new OldReader();
const myReader = new Readable().wrap(oreader);

myReader.on('readable', () => {
  myReader.read(); // etc.
});
```

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `stream` | `ReadableStream` | An "old style" readable stream |

##### write

```typescript
write(chunk: any, callback?: (error: Error) => void): boolean
```

The `writable.write()` method writes some data to the stream, and calls the
supplied `callback` once the data has been fully handled. If an error
occurs, the `callback` will be called with the error as its
first argument. The `callback` is called asynchronously and before `'error'` is
emitted.

The return value is `true` if the internal buffer is less than the `highWaterMark` configured when the stream was created after admitting `chunk`.
If `false` is returned, further attempts to write data to the stream should
stop until the `'drain'` event is emitted.

While a stream is not draining, calls to `write()` will buffer `chunk`, and
return false. Once all currently buffered chunks are drained (accepted for
delivery by the operating system), the `'drain'` event will be emitted.
Once `write()` returns false, do not write more chunks
until the `'drain'` event is emitted. While calling `write()` on a stream that
is not draining is allowed, Node.js will buffer all written chunks until
maximum memory usage occurs, at which point it will abort unconditionally.
Even before it aborts, high memory usage will cause poor garbage collector
performance and high RSS (which is not typically released back to the system,
even after the memory is no longer required). Since TCP sockets may never
drain if the remote peer does not read the data, writing a socket that is
not draining may lead to a remotely exploitable vulnerability.

Writing data while the stream is not draining is particularly
problematic for a `Transform`, because the `Transform` streams are paused
by default until they are piped or a `'data'` or `'readable'` event handler
is added.

If the data to be written can be generated or fetched on demand, it is
recommended to encapsulate the logic into a `Readable` and use pipe. However, if calling `write()` is preferred, it is
possible to respect backpressure and avoid memory issues using the `'drain'` event:

```js
function write(data, cb) {
  if (!stream.write(data)) {
    stream.once('drain', cb);
  } else {
    process.nextTick(cb);
  }
}

// Wait for cb to be called before doing any other write.
write('hello', () => {
  console.log('Write completed, do more writes now.');
});
```

A `Writable` stream in object mode will always ignore the `encoding` argument.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` | Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`. |
| `callback?` | `(error: Error) => void` | Callback for when this chunk of data is flushed. |

**Returns** `boolean`: `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.

```typescript
write(chunk: any, encoding: BufferEncoding, callback?: (error: Error) => void): boolean
```

Writes data to the stream, with an explicit encoding for string data.

**Parameters**

| Name | Type | Description |
| --- | --- | --- |
| `chunk` | `any` | Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`. |
| `encoding` | `BufferEncoding` | The encoding, if `chunk` is a string. |
| `callback?` | `(error: Error) => void` | Callback for when this chunk of data is flushed. |

**Returns** `boolean`: `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.

### Types

#### CapturedOutputOptions

How a captured output stream presents itself.

```typescript
type CapturedOutputOptions = unknown
```

#### CapturedStdio

What the process wrote to its standard streams while captured.

```typescript
type CapturedStdio = unknown
```

#### CaptureStdioOptions

Which streams `captureStdio` takes over, and whether they still print.

```typescript
type CaptureStdioOptions = unknown
```

#### FakeChildProcessOptions

How a fake child process identifies itself.

```typescript
type FakeChildProcessOptions = unknown
```

#### Key

One of the key sequences in `Keys`.

```typescript
type Key = indexedAccess
```

#### SpawnSyncResultOptions

The result fields `spawnSyncResult` fills in when not given.

```typescript
type SpawnSyncResultOptions = unknown
```

### Variables

#### Keys

The byte sequences a terminal sends for the keys an interactive prompt reacts to, as a
raw-mode stdin receives them.

```typescript
const Keys: Readonly<{ Backspace: ""; CtrlC: ""; CtrlD: ""; Delete: "[3~"; Down: ""; End: ""; Enter: "
"; Escape: ""; Home: ""; Left: ""; PageDown: "[6~"; PageUp: "[5~"; Right: ""; ShiftTab: ""; Space: " "; Tab: "	"; Up: "" }>
```

**Value** `...`

---

Canonical page: https://www.hyperfrontend.dev/docs/libraries/testing/process/
This file: https://www.hyperfrontend.dev/docs/libraries/testing/process.md
Documentation index: https://www.hyperfrontend.dev/llms.txt