@scriptc/compiler 0.3.3 → 0.3.5

package/ambient/scriptc-node-fallback.d.ts

@@ -635,9 +635,12 @@ interface BufferConstructor {
   from(data: Uint8Array | readonly number[]): Buffer;
   alloc(size: number, fill?: string | number | Uint8Array, encoding?: BufferEncoding): Buffer;
   compare(buf1: Uint8Array, buf2: Uint8Array): number;
-  /* alloc without the zero-fill guarantee — the lowering zero-fills
-   * anyway (never handing out uninitialized memory costs one memset). */
+  /* alloc without the zero-fill guarantee. Below Buffer.poolSize >>> 1
+   * bytes it returns a view into the shared pool slab. */
   allocUnsafe(size: number): Buffer;
+  allocUnsafeSlow(size: number): Buffer;
+  /* The pool slab size for allocUnsafe, from, and concat. */
+  poolSize: number;
   concat(list: readonly Uint8Array[], totalLength?: number): Buffer;
   isBuffer(obj: unknown): obj is Buffer;
   byteLength(input: string | Uint8Array, encoding?: BufferEncoding): number;
@@ -992,14 +995,22 @@ declare module "timers" {
 }
 
 /* node:timers/promises — the promisified pair the Node test harness leans
- * on (`await setTimeout(ms)` as a sleep). setTimeout's delay-only form and
- * setImmediate's bare form lower (a void promise the shared timer heap
- * settles); setInterval(delay, value) lowers to a typed async iterator.
- * Resolve values on the one-shot pair and AbortSignal options remain
- * declared surface that fences per site. */
+ * on (`await setTimeout(ms)` as a sleep). setTimeout and setImmediate
+ * settle with their resolve value (undefined without one) from the shared
+ * timer heap and the immediate queue; setInterval(delay, value) lowers to a
+ * typed async iterator. The options object takes `ref`; AbortSignal
+ * options remain declared surface that fences per site. */
 declare module "node:timers/promises" {
-  export function setTimeout(delay?: number): Promise<void>;
-  export function setImmediate(): Promise<void>;
+  export interface TimerOptions {
+    ref?: boolean;
+    signal?: AbortSignal;
+  }
+  export function setTimeout<T = void>(
+    delay?: number,
+    value?: T,
+    options?: TimerOptions,
+  ): Promise<T>;
+  export function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
   export function setInterval<T = unknown>(
     delay?: number,
     value?: T,
@@ -1190,6 +1201,7 @@ interface ImportMeta {
  * directory, open 'x'"). `rmSync` removes FILES only (like Node without
  * `recursive`); empty directories go through `rmdirSync`. */
 declare module "node:fs" {
+  import { Readable, Writable } from "stream";
   export function readFileSync(path: string | number, encoding: BufferEncoding): string;
   export function readFileSync(
     path: string | number,
@@ -1372,6 +1384,47 @@ declare module "node:fs" {
     bufferSize?: number;
   }
   export function opendirSync(path: string, options?: OpenDirOptions): Dir;
+  /* fs.ReadStream / fs.WriteStream: runtime Readable and Writable streams
+   * over a file (scr_fs_stream.c). The options are checked at runtime
+   * with Node's rules; flags and mode are checked when the file opens, so
+   * their errors arrive as 'error' events. Instances also emit 'open'
+   * (with the fd) and 'ready'. */
+  export interface StreamOptions {
+    flags?: string;
+    encoding?: BufferEncoding;
+    fd?: number;
+    mode?: number | string;
+    autoClose?: boolean;
+    emitClose?: boolean;
+    start?: number;
+    highWaterMark?: number;
+  }
+  export interface ReadStreamOptions extends StreamOptions {
+    end?: number;
+  }
+  export interface WriteStreamOptions extends StreamOptions {
+    flush?: boolean;
+  }
+  export class ReadStream extends Readable {
+    readonly bytesRead: number;
+    readonly path: string | Buffer;
+    readonly pending: boolean;
+    close(callback?: () => void): void;
+  }
+  export class WriteStream extends Writable {
+    readonly bytesWritten: number;
+    readonly path: string | Buffer;
+    readonly pending: boolean;
+    close(callback?: () => void): void;
+  }
+  export function createReadStream(
+    path: string | Buffer | URL,
+    options?: BufferEncoding | ReadStreamOptions,
+  ): ReadStream;
+  export function createWriteStream(
+    path: string | Buffer | URL,
+    options?: BufferEncoding | WriteStreamOptions,
+  ): WriteStream;
   export function accessSync(path: string, mode?: number): void;
   export function mkdtempSync(prefix: string): string;
   export const constants: {
@@ -1624,9 +1677,31 @@ declare module "fs/promises" {
     length?: number | null;
     position?: number | null;
   }
+  /* The streams over a FileHandle (createReadStream, createWriteStream,
+   * readLines): fs streams that hold the handle until they close; closing
+   * the stream closes the handle unless autoClose is false. */
+  export interface CreateReadStreamOptions {
+    encoding?: BufferEncoding | null;
+    autoClose?: boolean;
+    emitClose?: boolean;
+    start?: number;
+    end?: number;
+    highWaterMark?: number;
+  }
+  export interface CreateWriteStreamOptions {
+    encoding?: BufferEncoding | null;
+    autoClose?: boolean;
+    emitClose?: boolean;
+    start?: number;
+    highWaterMark?: number;
+    flush?: boolean;
+  }
   export interface FileHandle extends AsyncDisposable {
     readonly fd: number;
     close(): Promise<void>;
+    createReadStream(options?: CreateReadStreamOptions): import("node:fs").ReadStream;
+    createWriteStream(options?: CreateWriteStreamOptions): import("node:fs").WriteStream;
+    readLines(options?: CreateReadStreamOptions): import("node:readline").Interface;
     sync(): Promise<void>;
     datasync(): Promise<void>;
     truncate(len?: number): Promise<void>;
@@ -2442,6 +2517,95 @@ declare module "crypto" {
     callback: (error: Error | null, buffer: Buffer) => void,
   ): void;
   export type BinaryLike = string | ArrayBuffer | ArrayBufferView;
+  /* Cipheriv/Decipheriv: aes-128/192/256 in cbc, ctr, and gcm modes and
+   * chacha20-poly1305. The stream.Transform members are not declared. */
+  export type CipherGCMTypes = "aes-128-gcm" | "aes-192-gcm" | "aes-256-gcm";
+  export type CipherChaCha20Poly1305Types = "chacha20-poly1305";
+  export type CipherKey = BinaryLike | KeyObject;
+  export interface CipherGCMOptions {
+    authTagLength?: number;
+  }
+  export interface CipherChaCha20Poly1305Options {
+    authTagLength?: number;
+  }
+  export interface Cipheriv {
+    update(data: string | ArrayBufferView): Buffer;
+    update(data: string, inputEncoding: BufferEncoding): Buffer;
+    update(data: ArrayBufferView, inputEncoding: undefined, outputEncoding: BufferEncoding): string;
+    update(
+      data: string,
+      inputEncoding: BufferEncoding | undefined,
+      outputEncoding: BufferEncoding,
+    ): string;
+    final(): Buffer;
+    final(outputEncoding: BufferEncoding): string;
+    setAutoPadding(autoPadding?: boolean): this;
+  }
+  export interface CipherGCM extends Cipheriv {
+    setAAD(buffer: ArrayBufferView, options?: { plaintextLength: number }): this;
+    getAuthTag(): Buffer;
+  }
+  export interface CipherChaCha20Poly1305 extends Cipheriv {
+    setAAD(buffer: ArrayBufferView, options?: { plaintextLength: number }): this;
+    getAuthTag(): Buffer;
+  }
+  export interface Decipheriv {
+    update(data: ArrayBufferView): Buffer;
+    update(data: string, inputEncoding: BufferEncoding): Buffer;
+    update(data: ArrayBufferView, inputEncoding: undefined, outputEncoding: BufferEncoding): string;
+    update(
+      data: string,
+      inputEncoding: BufferEncoding | undefined,
+      outputEncoding: BufferEncoding,
+    ): string;
+    final(): Buffer;
+    final(outputEncoding: BufferEncoding): string;
+    setAutoPadding(autoPadding?: boolean): this;
+  }
+  export interface DecipherGCM extends Decipheriv {
+    setAuthTag(buffer: ArrayBufferView): this;
+    setAAD(buffer: ArrayBufferView, options?: { plaintextLength: number }): this;
+  }
+  export interface DecipherChaCha20Poly1305 extends Decipheriv {
+    setAuthTag(buffer: ArrayBufferView): this;
+    setAAD(buffer: ArrayBufferView, options?: { plaintextLength: number }): this;
+  }
+  export function createCipheriv(
+    algorithm: CipherGCMTypes,
+    key: CipherKey,
+    iv: BinaryLike,
+    options?: CipherGCMOptions,
+  ): CipherGCM;
+  export function createCipheriv(
+    algorithm: CipherChaCha20Poly1305Types,
+    key: CipherKey,
+    iv: BinaryLike,
+    options?: CipherChaCha20Poly1305Options,
+  ): CipherChaCha20Poly1305;
+  export function createCipheriv(
+    algorithm: string,
+    key: CipherKey,
+    iv: BinaryLike | null,
+    options?: { authTagLength?: number },
+  ): Cipheriv;
+  export function createDecipheriv(
+    algorithm: CipherGCMTypes,
+    key: CipherKey,
+    iv: BinaryLike,
+    options?: CipherGCMOptions,
+  ): DecipherGCM;
+  export function createDecipheriv(
+    algorithm: CipherChaCha20Poly1305Types,
+    key: CipherKey,
+    iv: BinaryLike,
+    options?: CipherChaCha20Poly1305Options,
+  ): DecipherChaCha20Poly1305;
+  export function createDecipheriv(
+    algorithm: string,
+    key: CipherKey,
+    iv: BinaryLike | null,
+    options?: { authTagLength?: number },
+  ): Decipheriv;
   export interface ScryptOptions {
     N?: number;
     r?: number;
@@ -2780,7 +2944,8 @@ declare module "child_process" {
   ): unknown;
   /* The async shell form — declared surface without full lowering (the
    * type-level tolerance story): harness code on paths tests don't reach
-   * must typecheck; a reached call fences at its site. */
+   * must typecheck; a reached call fences at its site. util.promisify
+   * recognizes it statically, as it does execFile. */
   export function exec(
     command: string,
     options?: ExecSyncOptions | ((error: Error | null, stdout: string, stderr: string) => void),
@@ -2791,9 +2956,10 @@ declare module "node:child_process" {
   export * from "child_process";
 }
 
-/* node:util — compile-time projections for child_process.execFile and
- * fs.readFile. The former retains Node's custom { stdout, stderr } result;
- * the latter resolves the callback's data argument. Other targets and bare
+/* node:util — compile-time projections for child_process.execFile,
+ * child_process.exec and fs.readFile. The first two retain Node's custom
+ * { stdout, stderr } result; the last resolves the callback's data
+ * argument. Other targets and bare
  * promisify values fence per site. */
 declare module "util" {
   export * as types from "util/types";
@@ -2885,6 +3051,18 @@ declare module "util" {
       windowsHide?: boolean;
     },
   ) => Promise<{ stdout: string; stderr: string }>;
+  export function promisify(fn: typeof import("node:child_process").exec): (
+    command: string,
+    options?: {
+      encoding?: "utf8" | "utf-8";
+      cwd?: string;
+      env?: { [k: string]: string | undefined };
+      timeout?: number;
+      maxBuffer?: number;
+      killSignal?: string;
+      windowsHide?: boolean;
+    },
+  ) => Promise<{ stdout: string; stderr: string }>;
   /* Declared surface without full lowering (the type-level tolerance
    * story: guarded/diagnostic-path code must TYPECHECK; a reached use
    * without a lowering fences at its site). inspect's options carry the
@@ -3019,7 +3197,9 @@ declare module "node:test" {
   }
   interface TestContext {
     readonly name: string;
+    readonly fullName: string;
     readonly assert: TestContextAssert;
+    readonly mock: MockTracker;
     test(name: string, fn?: TestFn): Promise<void>;
     test(name: string, options: TestOptions, fn?: TestFn): Promise<void>;
     skip(message?: string): void;
@@ -3069,10 +3249,45 @@ declare module "node:test" {
   function after(fn: HookFn): void;
   function beforeEach(fn: HookFn): void;
   function afterEach(fn: HookFn): void;
+  /* The mock function surface: mock.fn and t.mock.fn, with the calls log
+   * and the implementation controls on fn.mock. */
+  interface MockFunctionCall<
+    F extends Function,
+    ReturnType = F extends (...args: any) => infer T ? T : unknown,
+    Args = F extends (...args: infer Y) => any ? Y : unknown[],
+  > {
+    arguments: Args;
+    error: unknown | undefined;
+    result: ReturnType | undefined;
+    this: unknown;
+  }
+  interface MockFunctionContext<F extends Function> {
+    readonly calls: MockFunctionCall<F>[];
+    callCount(): number;
+    mockImplementation(implementation: F): void;
+    mockImplementationOnce(implementation: F, onCall?: number): void;
+    resetCalls(): void;
+    restore(): void;
+  }
+  type Mock<F extends Function> = F & { mock: MockFunctionContext<F> };
+  interface MockTracker {
+    fn<F extends Function = (...args: any[]) => undefined>(original?: F): Mock<F>;
+    fn<F extends Function = (...args: any[]) => undefined, Implementation extends Function = F>(
+      original?: F,
+      implementation?: Implementation,
+    ): Mock<F | Implementation>;
+    method<MockedObject extends object>(
+      object: MockedObject,
+      methodName: keyof MockedObject,
+      implementation?: Function,
+    ): Mock<Function>;
+    reset(): void;
+    restoreAll(): void;
+  }
+  const mock: MockTracker;
   /* Declared for typechecking only — every use fences (no lowering).
    * `assert` is the module-level custom-assertion registry (v24's
    * `const { assert } = require('node:test')`), not TestContext.assert. */
-  const mock: unknown;
   const assert: { register(name: string, fn: (...args: unknown[]) => unknown): void };
   function run(options?: unknown): unknown;
   function snapshot(...args: unknown[]): unknown;
@@ -3091,6 +3306,10 @@ declare module "node:test" {
     snapshot,
     TestContext,
     TestOptions,
+    Mock,
+    MockFunctionContext,
+    MockFunctionCall,
+    MockTracker,
   };
   export default test;
 }
@@ -3098,11 +3317,28 @@ declare module "node:test" {
 declare module "assert" {
   function assert(value: unknown, message?: string): void;
   namespace assert {
+    interface AssertionErrorOptions {
+      message?: string | undefined;
+      actual?: unknown;
+      expected?: unknown;
+      operator?: string | undefined;
+      stackStartFn?: Function | undefined;
+      diff?: "simple" | "full" | undefined;
+    }
+    class AssertionError extends Error {
+      constructor(options: AssertionErrorOptions);
+      actual: unknown;
+      expected: unknown;
+      generatedMessage: boolean;
+      code: "ERR_ASSERTION";
+      operator: string;
+    }
     function ok(value: unknown, message?: string): void;
     function strictEqual(actual: unknown, expected: unknown, message?: string): void;
     function notStrictEqual(actual: unknown, expected: unknown, message?: string): void;
     function deepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
     function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
+    function partialDeepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
     function equal(actual: unknown, expected: unknown, message?: string): void;
     function notEqual(actual: unknown, expected: unknown, message?: string): void;
     function deepEqual(actual: unknown, expected: unknown, message?: string): void;
@@ -3124,6 +3360,36 @@ declare module "assert" {
     function doesNotMatch(value: string, regExp: RegExp, message?: string): void;
     function ifError(value: unknown): void;
     const strict: typeof import("assert/strict");
+    interface AssertOptions {
+      diff?: "simple" | "full" | undefined;
+      strict?: boolean | undefined;
+      skipPrototype?: boolean | undefined;
+    }
+    type AssertMethodNames =
+      | "deepEqual"
+      | "deepStrictEqual"
+      | "doesNotMatch"
+      | "doesNotReject"
+      | "doesNotThrow"
+      | "equal"
+      | "fail"
+      | "ifError"
+      | "match"
+      | "notDeepEqual"
+      | "notDeepStrictEqual"
+      | "notEqual"
+      | "notStrictEqual"
+      | "ok"
+      | "partialDeepStrictEqual"
+      | "rejects"
+      | "strictEqual"
+      | "throws";
+    interface Assert extends Pick<typeof assert, AssertMethodNames> {}
+    interface AssertStrict extends Pick<typeof strict, AssertMethodNames> {}
+    const Assert: {
+      new (options?: AssertOptions & { strict?: true | undefined }): AssertStrict;
+      new (options: AssertOptions): Assert;
+    };
   }
   export = assert;
 }
@@ -3146,6 +3412,7 @@ declare module "assert/strict" {
     function notStrictEqual(actual: unknown, expected: unknown, message?: string): void;
     function deepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
     function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
+    function partialDeepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
     function fail(message?: string): never;
     function throws(fn: () => unknown, expected?: unknown, message?: string): void;
     function doesNotThrow(fn: () => unknown, expected?: unknown, message?: string): void;
@@ -3163,6 +3430,10 @@ declare module "assert/strict" {
     function doesNotMatch(value: string, regExp: RegExp, message?: string): void;
     function ifError(value: unknown): void;
     const strict: typeof import("assert/strict");
+    type AssertOptions = import("assert").AssertOptions;
+    type Assert = import("assert").Assert;
+    type AssertStrict = import("assert").AssertStrict;
+    const Assert: typeof import("assert").Assert;
   }
   export = strict;
 }
@@ -3332,9 +3603,12 @@ declare module "node:readline/promises" {
 /* node:zlib — the one-shot zlib/raw/gzip codecs lower for string/Buffer
  * inputs with Node's default options; libz links only into zlib-using
  * binaries. Callback forms use the executable worker pool. Options stay
- * declared so reached uses receive a named SC2020 refusal; Brotli,
- * streaming, and Zstd remain outside the lowered surface. */
+ * declared so reached uses receive a named SC2020 refusal. The Deflate,
+ * Inflate, Gzip, Gunzip, DeflateRaw, InflateRaw and Unzip streams are
+ * runtime Transform streams; Brotli and Zstd remain outside the lowered
+ * surface. */
 declare module "zlib" {
+  import { Transform } from "stream";
   export interface ZlibOptions {
     [option: string]: unknown;
   }
@@ -3391,6 +3665,340 @@ declare module "zlib" {
   export function crc32(data: string | Uint8Array, value?: number): number;
   export function brotliCompressSync(data: string | Uint8Array): Buffer;
   export function brotliDecompressSync(data: Uint8Array): Buffer;
+  /* Brotli needs a codec the static runtime does not vendor: these are
+   * declared so their uses receive the named refusal. */
+  export function brotliCompress(data: string | Uint8Array, callback: ZlibCallback): void;
+  export function brotliDecompress(data: Uint8Array, callback: ZlibCallback): void;
+  export function createBrotliCompress(options?: ZlibOptions): Transform;
+  export function createBrotliDecompress(options?: ZlibOptions): Transform;
+  export class BrotliCompress extends Transform {
+    constructor(options?: ZlibOptions);
+  }
+  export class BrotliDecompress extends Transform {
+    constructor(options?: ZlibOptions);
+  }
+  /* The stream classes: runtime Transform streams over the zlib engine
+   * (scr_zlib_stream.c). createGzip(options) and new Gzip(options) build
+   * the same stream; options are validated at runtime with Node's rules. */
+  class ZlibBase extends Transform {
+    readonly bytesWritten: number;
+    flush(kind?: number, callback?: () => void): void;
+    flush(callback: () => void): void;
+    params(level: number, strategy: number, callback?: () => void): void;
+    close(callback?: () => void): void;
+    reset(): void;
+  }
+  export class Deflate extends ZlibBase {
+    constructor(options?: ZlibOptions);
+  }
+  export class Inflate extends ZlibBase {
+    constructor(options?: ZlibOptions);
+  }
+  export class Gzip extends ZlibBase {
+    constructor(options?: ZlibOptions);
+  }
+  export class Gunzip extends ZlibBase {
+    constructor(options?: ZlibOptions);
+  }
+  export class DeflateRaw extends ZlibBase {
+    constructor(options?: ZlibOptions);
+  }
+  export class InflateRaw extends ZlibBase {
+    constructor(options?: ZlibOptions);
+  }
+  export class Unzip extends ZlibBase {
+    constructor(options?: ZlibOptions);
+  }
+  export function createDeflate(options?: ZlibOptions): Deflate;
+  export function createInflate(options?: ZlibOptions): Inflate;
+  export function createGzip(options?: ZlibOptions): Gzip;
+  export function createGunzip(options?: ZlibOptions): Gunzip;
+  export function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
+  export function createInflateRaw(options?: ZlibOptions): InflateRaw;
+  export function createUnzip(options?: ZlibOptions): Unzip;
+  /* Node v24 zlib.constants, literal-typed (the CryptoConstants stance):
+   * every access bakes as its literal; the object never materializes. The
+   * members outside BROTLI_* are also module properties (zlib.Z_SYNC_FLUSH). */
+  export interface ZlibConstants {
+    readonly Z_NO_FLUSH: 0;
+    readonly Z_PARTIAL_FLUSH: 1;
+    readonly Z_SYNC_FLUSH: 2;
+    readonly Z_FULL_FLUSH: 3;
+    readonly Z_FINISH: 4;
+    readonly Z_BLOCK: 5;
+    readonly Z_OK: 0;
+    readonly Z_STREAM_END: 1;
+    readonly Z_NEED_DICT: 2;
+    readonly Z_ERRNO: -1;
+    readonly Z_STREAM_ERROR: -2;
+    readonly Z_DATA_ERROR: -3;
+    readonly Z_MEM_ERROR: -4;
+    readonly Z_BUF_ERROR: -5;
+    readonly Z_VERSION_ERROR: -6;
+    readonly Z_NO_COMPRESSION: 0;
+    readonly Z_BEST_SPEED: 1;
+    readonly Z_BEST_COMPRESSION: 9;
+    readonly Z_DEFAULT_COMPRESSION: -1;
+    readonly Z_FILTERED: 1;
+    readonly Z_HUFFMAN_ONLY: 2;
+    readonly Z_RLE: 3;
+    readonly Z_FIXED: 4;
+    readonly Z_DEFAULT_STRATEGY: 0;
+    readonly ZLIB_VERNUM: 4897;
+    readonly DEFLATE: 1;
+    readonly INFLATE: 2;
+    readonly GZIP: 3;
+    readonly GUNZIP: 4;
+    readonly DEFLATERAW: 5;
+    readonly INFLATERAW: 6;
+    readonly UNZIP: 7;
+    readonly BROTLI_DECODE: 8;
+    readonly BROTLI_ENCODE: 9;
+    readonly ZSTD_DECOMPRESS: 11;
+    readonly ZSTD_COMPRESS: 10;
+    readonly Z_MIN_WINDOWBITS: 8;
+    readonly Z_MAX_WINDOWBITS: 15;
+    readonly Z_DEFAULT_WINDOWBITS: 15;
+    readonly Z_MIN_CHUNK: 64;
+    readonly Z_MAX_CHUNK: number;
+    readonly Z_DEFAULT_CHUNK: 16384;
+    readonly Z_MIN_MEMLEVEL: 1;
+    readonly Z_MAX_MEMLEVEL: 9;
+    readonly Z_DEFAULT_MEMLEVEL: 8;
+    readonly Z_MIN_LEVEL: -1;
+    readonly Z_MAX_LEVEL: 9;
+    readonly Z_DEFAULT_LEVEL: -1;
+    readonly BROTLI_OPERATION_PROCESS: 0;
+    readonly BROTLI_OPERATION_FLUSH: 1;
+    readonly BROTLI_OPERATION_FINISH: 2;
+    readonly BROTLI_OPERATION_EMIT_METADATA: 3;
+    readonly BROTLI_PARAM_MODE: 0;
+    readonly BROTLI_MODE_GENERIC: 0;
+    readonly BROTLI_MODE_TEXT: 1;
+    readonly BROTLI_MODE_FONT: 2;
+    readonly BROTLI_DEFAULT_MODE: 0;
+    readonly BROTLI_PARAM_QUALITY: 1;
+    readonly BROTLI_MIN_QUALITY: 0;
+    readonly BROTLI_MAX_QUALITY: 11;
+    readonly BROTLI_DEFAULT_QUALITY: 11;
+    readonly BROTLI_PARAM_LGWIN: 2;
+    readonly BROTLI_MIN_WINDOW_BITS: 10;
+    readonly BROTLI_MAX_WINDOW_BITS: 24;
+    readonly BROTLI_LARGE_MAX_WINDOW_BITS: 30;
+    readonly BROTLI_DEFAULT_WINDOW: 22;
+    readonly BROTLI_PARAM_LGBLOCK: 3;
+    readonly BROTLI_MIN_INPUT_BLOCK_BITS: 16;
+    readonly BROTLI_MAX_INPUT_BLOCK_BITS: 24;
+    readonly BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4;
+    readonly BROTLI_PARAM_SIZE_HINT: 5;
+    readonly BROTLI_PARAM_LARGE_WINDOW: 6;
+    readonly BROTLI_PARAM_NPOSTFIX: 7;
+    readonly BROTLI_PARAM_NDIRECT: 8;
+    readonly BROTLI_DECODER_RESULT_ERROR: 0;
+    readonly BROTLI_DECODER_RESULT_SUCCESS: 1;
+    readonly BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2;
+    readonly BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3;
+    readonly BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0;
+    readonly BROTLI_DECODER_PARAM_LARGE_WINDOW: 1;
+    readonly BROTLI_DECODER_NO_ERROR: 0;
+    readonly BROTLI_DECODER_SUCCESS: 1;
+    readonly BROTLI_DECODER_NEEDS_MORE_INPUT: 2;
+    readonly BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3;
+    readonly BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1;
+    readonly BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2;
+    readonly BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3;
+    readonly BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4;
+    readonly BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5;
+    readonly BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6;
+    readonly BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7;
+    readonly BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8;
+    readonly BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9;
+    readonly BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10;
+    readonly BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11;
+    readonly BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12;
+    readonly BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13;
+    readonly BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14;
+    readonly BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15;
+    readonly BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16;
+    readonly BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19;
+    readonly BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20;
+    readonly BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21;
+    readonly BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22;
+    readonly BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25;
+    readonly BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26;
+    readonly BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27;
+    readonly BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30;
+    readonly BROTLI_DECODER_ERROR_UNREACHABLE: -31;
+    readonly ZSTD_e_continue: 0;
+    readonly ZSTD_e_flush: 1;
+    readonly ZSTD_e_end: 2;
+    readonly ZSTD_fast: 1;
+    readonly ZSTD_dfast: 2;
+    readonly ZSTD_greedy: 3;
+    readonly ZSTD_lazy: 4;
+    readonly ZSTD_lazy2: 5;
+    readonly ZSTD_btlazy2: 6;
+    readonly ZSTD_btopt: 7;
+    readonly ZSTD_btultra: 8;
+    readonly ZSTD_btultra2: 9;
+    readonly ZSTD_c_compressionLevel: 100;
+    readonly ZSTD_c_windowLog: 101;
+    readonly ZSTD_c_hashLog: 102;
+    readonly ZSTD_c_chainLog: 103;
+    readonly ZSTD_c_searchLog: 104;
+    readonly ZSTD_c_minMatch: 105;
+    readonly ZSTD_c_targetLength: 106;
+    readonly ZSTD_c_strategy: 107;
+    readonly ZSTD_c_enableLongDistanceMatching: 160;
+    readonly ZSTD_c_ldmHashLog: 161;
+    readonly ZSTD_c_ldmMinMatch: 162;
+    readonly ZSTD_c_ldmBucketSizeLog: 163;
+    readonly ZSTD_c_ldmHashRateLog: 164;
+    readonly ZSTD_c_contentSizeFlag: 200;
+    readonly ZSTD_c_checksumFlag: 201;
+    readonly ZSTD_c_dictIDFlag: 202;
+    readonly ZSTD_c_nbWorkers: 400;
+    readonly ZSTD_c_jobSize: 401;
+    readonly ZSTD_c_overlapLog: 402;
+    readonly ZSTD_d_windowLogMax: 100;
+    readonly ZSTD_CLEVEL_DEFAULT: 3;
+    readonly ZSTD_error_no_error: 0;
+    readonly ZSTD_error_GENERIC: 1;
+    readonly ZSTD_error_prefix_unknown: 10;
+    readonly ZSTD_error_version_unsupported: 12;
+    readonly ZSTD_error_frameParameter_unsupported: 14;
+    readonly ZSTD_error_frameParameter_windowTooLarge: 16;
+    readonly ZSTD_error_corruption_detected: 20;
+    readonly ZSTD_error_checksum_wrong: 22;
+    readonly ZSTD_error_literals_headerWrong: 24;
+    readonly ZSTD_error_dictionary_corrupted: 30;
+    readonly ZSTD_error_dictionary_wrong: 32;
+    readonly ZSTD_error_dictionaryCreation_failed: 34;
+    readonly ZSTD_error_parameter_unsupported: 40;
+    readonly ZSTD_error_parameter_combination_unsupported: 41;
+    readonly ZSTD_error_parameter_outOfBound: 42;
+    readonly ZSTD_error_tableLog_tooLarge: 44;
+    readonly ZSTD_error_maxSymbolValue_tooLarge: 46;
+    readonly ZSTD_error_maxSymbolValue_tooSmall: 48;
+    readonly ZSTD_error_stabilityCondition_notRespected: 50;
+    readonly ZSTD_error_stage_wrong: 60;
+    readonly ZSTD_error_init_missing: 62;
+    readonly ZSTD_error_memory_allocation: 64;
+    readonly ZSTD_error_workSpace_tooSmall: 66;
+    readonly ZSTD_error_dstSize_tooSmall: 70;
+    readonly ZSTD_error_srcSize_wrong: 72;
+    readonly ZSTD_error_dstBuffer_null: 74;
+    readonly ZSTD_error_noForwardProgress_destFull: 80;
+    readonly ZSTD_error_noForwardProgress_inputEmpty: 82;
+  }
+  export const constants: ZlibConstants;
+  export const Z_NO_FLUSH: 0;
+  export const Z_PARTIAL_FLUSH: 1;
+  export const Z_SYNC_FLUSH: 2;
+  export const Z_FULL_FLUSH: 3;
+  export const Z_FINISH: 4;
+  export const Z_BLOCK: 5;
+  export const Z_OK: 0;
+  export const Z_STREAM_END: 1;
+  export const Z_NEED_DICT: 2;
+  export const Z_ERRNO: -1;
+  export const Z_STREAM_ERROR: -2;
+  export const Z_DATA_ERROR: -3;
+  export const Z_MEM_ERROR: -4;
+  export const Z_BUF_ERROR: -5;
+  export const Z_VERSION_ERROR: -6;
+  export const Z_NO_COMPRESSION: 0;
+  export const Z_BEST_SPEED: 1;
+  export const Z_BEST_COMPRESSION: 9;
+  export const Z_DEFAULT_COMPRESSION: -1;
+  export const Z_FILTERED: 1;
+  export const Z_HUFFMAN_ONLY: 2;
+  export const Z_RLE: 3;
+  export const Z_FIXED: 4;
+  export const Z_DEFAULT_STRATEGY: 0;
+  export const ZLIB_VERNUM: 4897;
+  export const DEFLATE: 1;
+  export const INFLATE: 2;
+  export const GZIP: 3;
+  export const GUNZIP: 4;
+  export const DEFLATERAW: 5;
+  export const INFLATERAW: 6;
+  export const UNZIP: 7;
+  export const ZSTD_DECOMPRESS: 11;
+  export const ZSTD_COMPRESS: 10;
+  export const Z_MIN_WINDOWBITS: 8;
+  export const Z_MAX_WINDOWBITS: 15;
+  export const Z_DEFAULT_WINDOWBITS: 15;
+  export const Z_MIN_CHUNK: 64;
+  export const Z_MAX_CHUNK: number;
+  export const Z_DEFAULT_CHUNK: 16384;
+  export const Z_MIN_MEMLEVEL: 1;
+  export const Z_MAX_MEMLEVEL: 9;
+  export const Z_DEFAULT_MEMLEVEL: 8;
+  export const Z_MIN_LEVEL: -1;
+  export const Z_MAX_LEVEL: 9;
+  export const Z_DEFAULT_LEVEL: -1;
+  export const ZSTD_e_continue: 0;
+  export const ZSTD_e_flush: 1;
+  export const ZSTD_e_end: 2;
+  export const ZSTD_fast: 1;
+  export const ZSTD_dfast: 2;
+  export const ZSTD_greedy: 3;
+  export const ZSTD_lazy: 4;
+  export const ZSTD_lazy2: 5;
+  export const ZSTD_btlazy2: 6;
+  export const ZSTD_btopt: 7;
+  export const ZSTD_btultra: 8;
+  export const ZSTD_btultra2: 9;
+  export const ZSTD_c_compressionLevel: 100;
+  export const ZSTD_c_windowLog: 101;
+  export const ZSTD_c_hashLog: 102;
+  export const ZSTD_c_chainLog: 103;
+  export const ZSTD_c_searchLog: 104;
+  export const ZSTD_c_minMatch: 105;
+  export const ZSTD_c_targetLength: 106;
+  export const ZSTD_c_strategy: 107;
+  export const ZSTD_c_enableLongDistanceMatching: 160;
+  export const ZSTD_c_ldmHashLog: 161;
+  export const ZSTD_c_ldmMinMatch: 162;
+  export const ZSTD_c_ldmBucketSizeLog: 163;
+  export const ZSTD_c_ldmHashRateLog: 164;
+  export const ZSTD_c_contentSizeFlag: 200;
+  export const ZSTD_c_checksumFlag: 201;
+  export const ZSTD_c_dictIDFlag: 202;
+  export const ZSTD_c_nbWorkers: 400;
+  export const ZSTD_c_jobSize: 401;
+  export const ZSTD_c_overlapLog: 402;
+  export const ZSTD_d_windowLogMax: 100;
+  export const ZSTD_CLEVEL_DEFAULT: 3;
+  export const ZSTD_error_no_error: 0;
+  export const ZSTD_error_GENERIC: 1;
+  export const ZSTD_error_prefix_unknown: 10;
+  export const ZSTD_error_version_unsupported: 12;
+  export const ZSTD_error_frameParameter_unsupported: 14;
+  export const ZSTD_error_frameParameter_windowTooLarge: 16;
+  export const ZSTD_error_corruption_detected: 20;
+  export const ZSTD_error_checksum_wrong: 22;
+  export const ZSTD_error_literals_headerWrong: 24;
+  export const ZSTD_error_dictionary_corrupted: 30;
+  export const ZSTD_error_dictionary_wrong: 32;
+  export const ZSTD_error_dictionaryCreation_failed: 34;
+  export const ZSTD_error_parameter_unsupported: 40;
+  export const ZSTD_error_parameter_combination_unsupported: 41;
+  export const ZSTD_error_parameter_outOfBound: 42;
+  export const ZSTD_error_tableLog_tooLarge: 44;
+  export const ZSTD_error_maxSymbolValue_tooLarge: 46;
+  export const ZSTD_error_maxSymbolValue_tooSmall: 48;
+  export const ZSTD_error_stabilityCondition_notRespected: 50;
+  export const ZSTD_error_stage_wrong: 60;
+  export const ZSTD_error_init_missing: 62;
+  export const ZSTD_error_memory_allocation: 64;
+  export const ZSTD_error_workSpace_tooSmall: 66;
+  export const ZSTD_error_dstSize_tooSmall: 70;
+  export const ZSTD_error_srcSize_wrong: 72;
+  export const ZSTD_error_dstBuffer_null: 74;
+  export const ZSTD_error_noForwardProgress_destFull: 80;
+  export const ZSTD_error_noForwardProgress_inputEmpty: 82;
 }
 declare module "node:zlib" {
   export * from "zlib";
@@ -3415,6 +4023,17 @@ declare module "net" {
     ref(): void;
     unref(): void;
     readonly remoteAddress: string | undefined;
+    /* The peer's fields are cached at first read, like remoteAddress; the
+     * local ones are undefined while connecting and after close. */
+    readonly remotePort: number | undefined;
+    readonly remoteFamily: string | undefined;
+    readonly localAddress: string | undefined;
+    readonly localPort: number | undefined;
+    readonly localFamily: string | undefined;
+    readonly bytesRead: number;
+    readonly connecting: boolean;
+    readonly pending: boolean;
+    readonly readyState: "opening" | "open" | "readOnly" | "writeOnly" | "closed";
     /* true once the fd is gone (destroy() or full close) — Node's flag. */
     readonly destroyed: boolean;
     /* the write half is open: no end() yet, no FIN sent, fd alive. */
@@ -3424,8 +4043,11 @@ declare module "net" {
     /* every byte the write paths accepted (buffered included — Node
      * counts those too; plaintext on TLS sockets). */
     readonly bytesWritten: number;
-    write(data: string | Uint8Array): void;
-    end(data?: string | Uint8Array): void;
+    /* write's callback runs once the data is flushed, with null; end's
+     * once the socket finishes. */
+    write(data: string | Uint8Array, callback?: (err?: Error | null) => void): void;
+    end(callback?: () => void): void;
+    end(data: string | Uint8Array, callback?: () => void): void;
     destroy(): void;
     /* Flow control: pause holds reads off (kernel/TCP backpressure is
      * the buffer); resume flows — and discards without listeners, so
@@ -3434,8 +4056,15 @@ declare module "net" {
     resume(): Socket;
     /* TCP_NODELAY on the live fd; missing means true. Chains. */
     setNoDelay(noDelay?: boolean): Socket;
+    /* SO_KEEPALIVE with the initial delay in ms. Chains. */
+    setKeepAlive(enable?: boolean, initialDelay?: number): Socket;
     /* end() now, destroy once the FIN actually flushed. */
     destroySoon(): void;
+    /* An RST instead of a FIN; a connecting socket resets once it
+     * connects. Throws ERR_INVALID_HANDLE_TYPE on a TLS socket. */
+    resetAndDestroy(): Socket;
+    /* The local address, or {} while connecting and once destroyed. */
+    address(): AddressInfo | {};
     /* setEncoding('utf8'): 'data' delivers strings — the IncomingMessage
      * twin's contract. */
     setEncoding(encoding: string): void;
@@ -3444,7 +4073,8 @@ declare module "net" {
     pipe(
       destination: Socket | import("http").ServerResponse | import("http2").Http2ServerResponse,
     ): void;
-    setTimeout(ms: number): void;
+    /* The callback is a once('timeout') listener (removed again by 0). */
+    setTimeout(ms: number, callback?: () => void): void;
     /* The paused-mode demux surface: once('readable') + read(1) +
      * unshift — read answers exactly n buffered bytes or null. */
     read(size?: number): Buffer | null;
@@ -3455,25 +4085,34 @@ declare module "net" {
      * registration never fires — Node's exact split. 'session' fires
      * once with the serialized session (the received-ticket event). */
     on(event: "data", listener: (chunk: Buffer) => void): void;
+    /* After setEncoding the chunk is a string. */
+    on(event: "data", listener: (chunk: string) => void): void;
     on(
-      event: "end" | "close" | "connect" | "timeout" | "readable" | "finish" | "secureConnect",
+      event: "end" | "connect" | "ready" | "timeout" | "readable" | "finish" | "secureConnect",
       listener: () => void,
     ): void;
+    on(event: "close", listener: (hadError: boolean) => void): void;
     on(event: "error", listener: (err: Error) => void): void;
     on(event: "session", listener: (session: Buffer) => void): void;
     /* addListener IS on (Node aliases them) — the suite spells both. */
     addListener(event: "data", listener: (chunk: Buffer) => void): void;
+    /* After setEncoding the chunk is a string. */
+    addListener(event: "data", listener: (chunk: string) => void): void;
     addListener(
-      event: "end" | "close" | "connect" | "timeout" | "readable" | "finish" | "secureConnect",
+      event: "end" | "connect" | "ready" | "timeout" | "readable" | "finish" | "secureConnect",
       listener: () => void,
     ): void;
+    addListener(event: "close", listener: (hadError: boolean) => void): void;
     addListener(event: "error", listener: (err: Error) => void): void;
     addListener(event: "session", listener: (session: Buffer) => void): void;
     once(event: "data", listener: (chunk: Buffer) => void): void;
+    /* After setEncoding the chunk is a string. */
+    once(event: "data", listener: (chunk: string) => void): void;
     once(
-      event: "end" | "close" | "connect" | "timeout" | "readable" | "finish" | "secureConnect",
+      event: "end" | "connect" | "ready" | "timeout" | "readable" | "finish" | "secureConnect",
       listener: () => void,
     ): void;
+    once(event: "close", listener: (hadError: boolean) => void): void;
     once(event: "error", listener: (err: Error) => void): void;
     once(event: "session", listener: (session: Buffer) => void): void;
   }
@@ -3482,6 +4121,13 @@ declare module "net" {
     ref(): void;
     unref(): void;
     readonly listening: boolean;
+    /* Connections past this many are closed with a 'drop' event;
+     * undefined (the default) or null lifts the cap. */
+    maxConnections: number | undefined;
+    /* Node reads it only in cluster mode: a stored value here. */
+    dropMaxConnection: boolean | undefined;
+    /* cb(null, count) on the next tick. */
+    getConnections(callback: (error: Error | null, count: number) => void): Server;
     /* Node answers the server itself (`return this` chaining). */
     listen(port: number, callback?: () => void): Server;
     /* The positional bind address (the options form's host in argument
@@ -3503,6 +4149,7 @@ declare module "net" {
     emit(event: "connection", socket: Socket): boolean;
     on(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
     on(event: "close" | "listening", listener: () => void): void;
+    on(event: "drop", listener: (data?: DropArgument) => void): void;
     on(event: "timeout", listener: (socket: Socket) => void): void;
     on(event: "error", listener: (err: Error) => void): void;
     /* The WebSocket handover: fires INSTEAD of 'request' for
@@ -3520,6 +4167,7 @@ declare module "net" {
     /* addListener IS on (Node aliases them) — the suite spells both. */
     addListener(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
     addListener(event: "close" | "listening", listener: () => void): void;
+    addListener(event: "drop", listener: (data?: DropArgument) => void): void;
     addListener(event: "timeout", listener: (socket: Socket) => void): void;
     addListener(event: "error", listener: (err: Error) => void): void;
     addListener(
@@ -3532,6 +4180,7 @@ declare module "net" {
     ): void;
     once(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
     once(event: "close" | "listening", listener: () => void): void;
+    once(event: "drop", listener: (data?: DropArgument) => void): void;
     once(event: "timeout", listener: (socket: Socket) => void): void;
     once(event: "error", listener: (err: Error) => void): void;
     once(
@@ -3543,6 +4192,20 @@ declare module "net" {
       listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
     ): void;
   }
+  /* The 'drop' payload: the turned-away connection's addresses. */
+  export interface DropArgument {
+    localAddress?: string;
+    localPort?: number;
+    localFamily?: string;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+  }
+  export type AddressInfo = import("node:dgram").AddressInfo;
+  /* Node's IPv4Reg and IPv6Reg tests: 4, 6, or 0 for isIP. */
+  export function isIP(input: string): number;
+  export function isIPv4(input: string): boolean;
+  export function isIPv6(input: string): boolean;
   /* The Socket VALUE — the `x instanceof net.Socket` narrowing target
    * (the h2 compat 'connect' listener's test). Constructing bare sockets
    * has no lowering; the construct signature exists for instanceof. */
@@ -3708,8 +4371,11 @@ declare module "http" {
     /* Node's writable head properties: the implicit head reads them. */
     statusCode: number;
     statusMessage: string | undefined;
-    setHeader(name: string, value: string | number): void;
-    getHeader(name: string): string | undefined;
+    /* The value keeps its type: getHeader answers the number, string or
+     * array that was set. */
+    setHeader(name: string, value: number | string | readonly string[]): void;
+    appendHeader(name: string, value: string | readonly string[]): void;
+    getHeader(name: string): number | string | string[] | undefined;
     getHeaderNames(): string[];
     getRawHeaderNames(): string[];
     getHeaders(): OutgoingHttpHeaders;
@@ -3930,7 +4596,7 @@ declare module "tls" {
   }
   export function createServer(
     options: TlsOptions,
-    secureConnectionListener?: (socket: Socket) => void,
+    secureConnectionListener?: (socket: TLSSocket) => void,
   ): Server;
   /** TLSSocket — post-handshake it IS a net socket to every lowered
    * member (the mapping collapses it onto the socket kind; the
@@ -3941,7 +4607,20 @@ declare module "tls" {
   export interface TLSSocket extends Socket {
     authorized: boolean;
     authorizationError: string | null;
+    /* null before the handshake, then the negotiated protocol or false */
+    readonly alpnProtocol: string | false | null;
+    /* "TLSv1.2" or "TLSv1.3"; null before the handshake and after close */
+    getProtocol(): string | null;
+    /* OpenSSL's suite name, the IANA name and the suite's version */
+    getCipher(): CipherNameAndProtocol;
+  }
+  export interface CipherNameAndProtocol {
+    name: string;
+    standardName: string;
+    version: string;
   }
+  export const DEFAULT_MIN_VERSION: string;
+  export const DEFAULT_MAX_VERSION: string;
   /** tls.connect options — the RUNTIME options record (members read at
    * runtime; port/host/rejectUnauthorized/ca/servername are the
    * honestly-implemented set, every other documented member throws the
@@ -4728,8 +5407,9 @@ declare module "node:http2" {
  * Buffer datagram with an explicit port + address (the connected-send
  * and callback forms have no lowering); address() returns the real
  * {address, family, port} record and THROWS "Not running" before bind,
- * like Node. 'error' with no listener exits 1 (the unhandled
- * EventEmitter 'error' behavior). Multicast has no lowering. */
+ * like Node. The socket options throw Node's errors (EBADF before bind);
+ * add/dropMembership before bind is refused at run time (SC2020). 'error'
+ * with no listener exits 1 (the unhandled EventEmitter 'error' behavior). */
 declare module "dgram" {
   export interface AddressInfo {
     address: string;
@@ -4748,8 +5428,22 @@ declare module "dgram" {
     send(msg: string | Uint8Array, port: number, address: string): void;
     address(): AddressInfo;
     close(callback?: () => void): void;
+    disconnect(): void;
     unref(): void;
     ref(): void;
+    setBroadcast(flag: boolean): void;
+    setTTL(ttl: number): number;
+    setMulticastTTL(ttl: number): number;
+    setMulticastLoopback(flag: boolean): boolean;
+    setMulticastInterface(multicastInterface: string): void;
+    addMembership(multicastAddress: string, multicastInterface?: string): void;
+    dropMembership(multicastAddress: string, multicastInterface?: string): void;
+    getRecvBufferSize(): number;
+    getSendBufferSize(): number;
+    setRecvBufferSize(size: number): void;
+    setSendBufferSize(size: number): void;
+    getSendQueueSize(): number;
+    getSendQueueCount(): number;
     on(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): void;
     on(event: "listening" | "close" | "connect", listener: () => void): void;
     on(event: "error", listener: (err: Error) => void): void;
@@ -4771,14 +5465,55 @@ declare module "node:dgram" {
  * ENOTFOUND <hostname>") as the callback's Error argument, with "" for
  * the address where Node passes undefined. */
 declare module "dns" {
+  export interface LookupAddress {
+    address: string;
+    family: number;
+  }
+  export interface LookupOptions {
+    family?: number | "IPv4" | "IPv6";
+    hints?: number;
+    all?: boolean;
+    order?: "ipv4first" | "ipv6first" | "verbatim";
+    verbatim?: boolean;
+  }
+  export interface LookupOneOptions extends LookupOptions {
+    all?: false;
+  }
+  export interface LookupAllOptions extends LookupOptions {
+    all: true;
+  }
+  /* The callback comes with the other lookup deliveries (literal
+   * addresses on the next tick); the options follow lib/dns.js. */
+  export function lookup(
+    hostname: string,
+    callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
+  ): void;
+  export function lookup(
+    hostname: string,
+    family: number,
+    callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
+  ): void;
+  export function lookup(
+    hostname: string,
+    options: LookupOneOptions,
+    callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
+  ): void;
   export function lookup(
     hostname: string,
-    /* The options-record stance (see http.RequestOptions): family is the
-     * lowered option ({ family: 4 }); hints/all/order/verbatim fence by
-     * name; undocumented keys drop like Node. */
-    options: { family: number; [option: string]: unknown },
-    callback: (err: Error | null, address: string, family: number) => void,
+    options: LookupAllOptions,
+    callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void,
   ): void;
+  /* getnameinfo with NI_NAMEREQD: the host's name and the port's service
+   * name (the number when it has none). */
+  export function lookupService(
+    address: string,
+    port: number,
+    callback: (err: NodeJS.ErrnoException | null, hostname: string, service: string) => void,
+  ): void;
+  /* The nameservers /etc/resolv.conf lists. */
+  export function getServers(): string[];
+  export function getDefaultResultOrder(): "ipv4first" | "ipv6first" | "verbatim";
+  export function setDefaultResultOrder(order: "ipv4first" | "ipv6first" | "verbatim"): void;
 }
 declare module "node:dns" {
   export * from "dns";
@@ -4976,7 +5711,12 @@ declare module "events" {
     // The class under its own name, so `import { EventEmitter }` resolves
     // (the @types/node namespace-alias pattern).
     export { internal as EventEmitter };
-    export function once(emitter: EventEmitter, eventName: string): Promise<any[]>;
+    // The event's arguments, as checked-dynamic values.
+    export function once(
+      emitter: EventEmitter,
+      eventName: string,
+      options?: { signal?: AbortSignal },
+    ): Promise<unknown[]>;
   }
   export = EventEmitter;
 }
@@ -5101,6 +5841,14 @@ declare module "stream" {
     signal?: AbortSignal;
   }
 
+  /* The operators' options: concurrency and highWaterMark bound map's
+   * in-flight callbacks and queued results. */
+  interface ArrayOptions {
+    concurrency?: number;
+    highWaterMark?: number;
+    signal?: AbortSignal;
+  }
+
   class Readable extends EventEmitter {
     constructor(opts?: ReadableOptions);
     /* The underscore-method surface (@types/node declares these on the
@@ -5131,6 +5879,51 @@ declare module "stream" {
     readonly destroyed: boolean;
     readonly errored: Error | null;
     static from(iterable: unknown, options?: ReadableOptions): Readable;
+    /* The Readable operators: chunks are strings or Buffers, map and
+     * flatMap callbacks return strings or Buffers (flatMap: arrays of
+     * them, or strings), and callbacks that declare the options argument
+     * are refused. */
+    map(
+      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any,
+      options?: ArrayOptions,
+    ): Readable;
+    filter(
+      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
+      options?: ArrayOptions,
+    ): Readable;
+    forEach(
+      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>,
+      options?: ArrayOptions,
+    ): Promise<void>;
+    toArray(options?: Pick<ArrayOptions, "signal">): Promise<any[]>;
+    some(
+      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
+      options?: ArrayOptions,
+    ): Promise<boolean>;
+    find(
+      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
+      options?: ArrayOptions,
+    ): Promise<any>;
+    every(
+      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
+      options?: ArrayOptions,
+    ): Promise<boolean>;
+    flatMap(
+      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any,
+      options?: ArrayOptions,
+    ): Readable;
+    drop(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
+    take(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
+    reduce<T = any>(
+      fn: (previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T,
+      initial?: undefined,
+      options?: Pick<ArrayOptions, "signal">,
+    ): Promise<T>;
+    reduce<T = any>(
+      fn: (previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T,
+      initial: T,
+      options?: Pick<ArrayOptions, "signal">,
+    ): Promise<T>;
     on(event: "data", listener: (chunk: any) => void): this;
     on(event: "end" | "close" | "readable" | "pause" | "resume", listener: () => void): this;
     on(event: "error", listener: (err: Error) => void): this;
@@ -5347,6 +6140,9 @@ declare module "stream" {
   function addAbortSignal<T extends Readable | Writable>(signal: AbortSignal, stream: T): T;
   /* Declared so requires typecheck; each fences at its use site. */
   function pipeline(...streams: unknown[]): unknown;
+  /* compose(...streams): a Duplex that writes to the first stream and
+   * reads from the last, with the streams running as a pipeline. */
+  function compose(...streams: Array<Readable | Writable>): Duplex;
   /* finished's options: readable/writable choose which ends count,
    * error: false ignores 'error' events, signal aborts the wait. */
   interface FinishedOptions {
@@ -5364,8 +6160,16 @@ declare module "stream" {
   /* Folds to the TARGET platform's default at compile time (win32 16384,
    * else 65536 — Node's own state.js split); literal argument only. */
   function getDefaultHighWaterMark(objectMode: boolean): number;
+  /* The promise pipeline's result: a last stage that is an async
+   * function resolves the promise with its value. */
+  type PipelinePromise<T extends unknown[]> = T extends [
+    ...unknown[],
+    (...args: any[]) => Promise<infer P>,
+  ]
+    ? Promise<P>
+    : Promise<void>;
   namespace promises {
-    function pipeline(...streams: unknown[]): Promise<void>;
+    function pipeline<T extends unknown[]>(...streams: T): PipelinePromise<T>;
     function finished(
       stream: unknown,
       options?: FinishedOptions & { cleanup?: boolean },
@@ -5382,6 +6186,7 @@ declare module "stream" {
     Stream,
     addAbortSignal,
     pipeline,
+    compose,
     finished,
     getDefaultHighWaterMark,
     promises,
@@ -5404,8 +6209,11 @@ declare module "stream/promises" {
    * ERR_STREAM_PREMATURE_CLOSE on an early close). Stream arguments are
    * the lowered surface — iterables/generators/functions fence per site.
    * pipeline's trailing { signal, end } object and finished's options
-   * (readable, writable, error, cleanup, signal) are supported. */
-  function pipeline(...streams: unknown[]): Promise<void>;
+   * (readable, writable, error, cleanup, signal) are supported. A last
+   * stage that is an async function resolves the promise with its value. */
+  function pipeline<T extends unknown[]>(
+    ...streams: T
+  ): T extends [...unknown[], (...args: any[]) => Promise<infer P>] ? Promise<P> : Promise<void>;
   function finished(
     stream: unknown,
     options?: {