@scriptc/compiler 0.3.3 → 0.3.4

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

@@ -992,14 +992,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,
@@ -2442,6 +2450,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;
@@ -3019,7 +3116,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 +3168,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 +3225,10 @@ declare module "node:test" {
     snapshot,
     TestContext,
     TestOptions,
+    Mock,
+    MockFunctionContext,
+    MockFunctionCall,
+    MockTracker,
   };
   export default test;
 }
@@ -3098,11 +3236,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 +3279,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 +3331,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 +3349,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 +3522,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 +3584,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 +3942,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 +3962,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,6 +3975,8 @@ 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;
     /* setEncoding('utf8'): 'data' delivers strings — the IncomingMessage
@@ -3444,7 +3987,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 +3999,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 +4035,11 @@ 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;
+    /* 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 +4061,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 +4079,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 +4092,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 +4104,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 +4283,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;
@@ -4771,14 +5349,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,
-    /* 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: LookupOneOptions,
+    callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
   ): void;
+  export function lookup(
+    hostname: string,
+    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";
@@ -5101,6 +5720,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 +5758,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 +6019,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 +6039,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 +6065,7 @@ declare module "stream" {
     Stream,
     addAbortSignal,
     pipeline,
+    compose,
     finished,
     getDefaultHighWaterMark,
     promises,
@@ -5404,8 +6088,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?: {