register & whenAborted

Both work with any AbortSignal: yours, fetch’s, a framework’s, AbortSignal.timeout.

register(signal, callback)

register is .NET’s CancellationToken.Register. It runs callback(reason) once when the signal aborts and returns an AbortRegistration.

const 
const registration: AbortRegistration
registration = 
function register(signal: AbortSignal, callback: (reason: unknown) => void): AbortRegistration
Runs callback with the signal's reason when signal aborts, like .NET's CancellationToken.Register.
Works with any AbortSignal (from fetch, a framework, AbortSignal.timeout, ...).

If the signal has already aborted, the callback runs synchronously, now, and its exceptions
propagate to the caller of register().
Otherwise it runs once, as an abort event listener: an exception it throws is reported like any
event-listener exception (in Node, an uncaught exception), so handle errors inside the callback.
Call unregister() (or using) on the result when the guarded work finishes.
register(
const signal: AbortSignal
signal, (
reason: unknown
reason) => 
const socket: {
    destroy(error?: Error): void;
}
socket.
function destroy(error?: Error): void
destroy(
reason: unknown
reason as 
interface Error
Error));
try {
  await 
function doWork(): Promise<void>
doWork();
} finally {
  
const registration: AbortRegistration
registration.
AbortRegistration.unregister(): void
Removes the callback. Safe to call more than once.
unregister(); // the work is done: stop listening
}

// Same thing with using:
{
  using 
using _: AbortRegistration
_ = 
function register(signal: AbortSignal, callback: (reason: unknown) => void): AbortRegistration
Runs callback with the signal's reason when signal aborts, like .NET's CancellationToken.Register.
Works with any AbortSignal (from fetch, a framework, AbortSignal.timeout, ...).

If the signal has already aborted, the callback runs synchronously, now, and its exceptions
propagate to the caller of register().
Otherwise it runs once, as an abort event listener: an exception it throws is reported like any
event-listener exception (in Node, an uncaught exception), so handle errors inside the callback.
Call unregister() (or using) on the result when the guarded work finishes.
register(
const signal: AbortSignal
signal, () => 
const socket: {
    destroy(error?: Error): void;
}
socket.
function destroy(error?: Error): void
destroy());
  await 
function doWork(): Promise<void>
doWork();
}

`AbortRegistration`
`unregister()`	Removes the callback. Safe to call more than once.
`dispose()`, `[Symbol.dispose]()`	Same as `unregister()`; supports `using`.
`isDisposed`	`true` once unregistered, once the callback has run, or if the signal was already aborted at registration.

The controller’s own signal has it built in: controller.signal.register(cb).

Already aborted? It runs now

If the signal has already aborted, register calls the callback synchronously, before returning, and returns an already-disposed registration. Compare addEventListener('abort', ...), which never fires for a signal that aborted earlier.

Errors in callbacks

Signal already aborted: the callback runs inside register(), so its exception propagates to the caller of register().
Otherwise the callback runs as an abort event listener. An exception there is reported like any event-listener exception, not to whoever called abort(). In Node that is an uncaught exception, which by default ends the process.

Unregister on long-lived signals

A request-scoped callback on an app-wide shutdown signal stays attached until it is removed. Unregister when the guarded work finishes, or scope it with using. EnhancedAbortSignal.none never aborts, so register(none, cb) adds no listener at all.

whenAborted(signal)

whenAborted returns a promise that resolves with the reason once the signal aborts, immediately if it already has. It never rejects, so it is safe to race:

const 
const winner: string | {
    aborted: unknown;
}
winner = await 
var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.
PromiseConstructor.race<[Promise<string>, Promise<{
    aborted: unknown;
}>]>(values: [Promise<string>, Promise<{
    aborted: unknown;
}>]): Promise<string | {
    aborted: unknown;
}> (+1 overload)
Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
or rejected.
@param ― values An array of Promises.
@returns ― A new Promise.
race([
function poll(): Promise<string>
poll(), 
function whenAborted(signal: AbortSignal): Promise<unknown>
A promise that resolves with the signal's reason once it aborts (immediately if it already has).
It never rejects. The listener is removed when the signal aborts.
whenAborted(
const signal: AbortSignal
signal).
Promise<unknown>.then<{
    aborted: unknown;
}, never>(onfulfilled?: ((value: unknown) => {
    aborted: unknown;
} | PromiseLike<{
    aborted: unknown;
}>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<{
    aborted: unknown;
}>
Attaches callbacks for the resolution and/or rejection of the Promise.
@param ― onfulfilled The callback to execute when the Promise is resolved.
@param ― onrejected The callback to execute when the Promise is rejected.
@returns ― A Promise for the completion of which ever callback is executed.
then((
reason: unknown
reason) => ({ 
aborted: unknown
aborted: 
reason: unknown
reason }))]);

const 
const reason: unknown
reason = await 
function whenAborted(signal: AbortSignal): Promise<unknown>
A promise that resolves with the signal's reason once it aborts (immediately if it already has).
It never rejects. The listener is removed when the signal aborts.
whenAborted(
const signal: AbortSignal
signal);
if (
function isTimeoutError(error: unknown): boolean
True if error is a timeout: a TimeoutError from abortAfter, timeout() or AbortSignal.timeout,
also when wrapped: Node core APIs (fs/promises, timers/promises, streams, events.once) reject with an
AbortError whose cause is the signal's reason.
isTimeoutError(
const reason: unknown
reason)) 
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log('deadline');

The listener is removed when the signal aborts. A whenAborted on a signal that never aborts keeps its listener (and promise) as long as the signal lives; prefer register with unregister() for work that can end first.
controller.signal.whenAborted is cached: one promise and one listener per signal however often you read it.
whenAborted(EnhancedAbortSignal.none) returns one shared promise that never settles and holds no listener.