@scriptc/compiler 0.3.4 → 0.3.6

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

@@ -299,7 +299,7 @@ declare var process: {
   stdout: import("tty").WriteStream;
   stderr: import("tty").WriteStream;
   /* The stdin stream, the piped-input slice: the TTY probe, the
-   * data/end/error events (on and once — a 'data' listener keeps the
+   * data/end/error events and readline's 'keypress' (on and once — a 'data' listener keeps the
    * event loop alive until EOF, like Node's flowing stdin), destroy()
    * (full teardown: nothing fires after, the loop stops waiting), and
    * async iteration (`for await (const chunk of process.stdin)` — chunks
@@ -310,9 +310,18 @@ declare var process: {
     on(event: "data", listener: (chunk: Uint8Array) => void): void;
     on(event: "end", listener: () => void): void;
     on(event: "error", listener: (err: Error) => void): void;
+    /* readline.emitKeypressEvents(process.stdin)'s keys */
+    on(
+      event: "keypress",
+      listener: (str: string | undefined, key: import("readline").Key) => void,
+    ): void;
     once(event: "data", listener: (chunk: Uint8Array) => void): void;
     once(event: "end", listener: () => void): void;
     once(event: "error", listener: (err: Error) => void): void;
+    once(
+      event: "keypress",
+      listener: (str: string | undefined, key: import("readline").Key) => void,
+    ): void;
     destroy(): void;
     setEncoding(encoding: "utf8"): void;
     /* Termios raw mode on a TTY stdin (libuv's UV_TTY_MODE_RAW, the mode
@@ -635,9 +644,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;
@@ -1198,6 +1210,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,
@@ -1247,6 +1260,45 @@ declare module "node:fs" {
     path: string | Uint8Array | URL,
     type?: string | null,
   ): void;
+  /* fs.cpSync / fs.cp: copies a file, symlink or (with recursive) a
+   * directory tree. filter decides per path; the callback and promise
+   * forms complete the copy before reporting. */
+  export interface CopySyncOptions {
+    dereference?: boolean;
+    errorOnExist?: boolean;
+    filter?: (source: string, destination: string) => boolean;
+    force?: boolean;
+    mode?: number;
+    preserveTimestamps?: boolean;
+    recursive?: boolean;
+    verbatimSymlinks?: boolean;
+  }
+  export interface CopyOptions {
+    dereference?: boolean;
+    errorOnExist?: boolean;
+    filter?: (source: string, destination: string) => boolean | Promise<boolean>;
+    force?: boolean;
+    mode?: number;
+    preserveTimestamps?: boolean;
+    recursive?: boolean;
+    verbatimSymlinks?: boolean;
+  }
+  export function cpSync(
+    source: string | URL,
+    destination: string | URL,
+    options?: CopySyncOptions,
+  ): void;
+  export function cp(
+    source: string | URL,
+    destination: string | URL,
+    callback: (err: NodeJS.ErrnoException | null) => void,
+  ): void;
+  export function cp(
+    source: string | URL,
+    destination: string | URL,
+    options: CopyOptions,
+    callback: (err: NodeJS.ErrnoException | null) => void,
+  ): void;
   export function symlink(
     target: string | Uint8Array | URL,
     path: string | Uint8Array | URL,
@@ -1380,6 +1432,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: {
@@ -1396,6 +1489,9 @@ declare module "node:fs" {
     readonly O_NONBLOCK: number;
     readonly O_TRUNC: number;
     readonly O_APPEND: number;
+    readonly COPYFILE_EXCL: number;
+    readonly COPYFILE_FICLONE: number;
+    readonly COPYFILE_FICLONE_FORCE: number;
   };
   /* A stat(2) snapshot (statSync follows symlinks, lstatSync does not —
    * Node's split) — immutable; the supported surface is exactly these
@@ -1429,8 +1525,37 @@ declare module "node:fs" {
     readonly ctime: Date;
     readonly birthtime: Date;
   }
-  export function statSync(path: string): Stats;
-  export function lstatSync(path: string): Stats;
+  /* throwIfNoEntry: false answers undefined for a missing entry (ENOENT or
+   * ENOTDIR) instead of throwing. BigIntStats (bigint: true) has no
+   * lowering. */
+  export interface StatSyncOptions {
+    bigint?: boolean;
+    throwIfNoEntry?: boolean;
+  }
+  export function statSync(path: string, options?: undefined): Stats;
+  export function statSync(
+    path: string,
+    options: StatSyncOptions & { bigint?: false; throwIfNoEntry: false },
+  ): Stats | undefined;
+  export function statSync(
+    path: string,
+    options: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true },
+  ): Stats;
+  /* bigint: true type-checks so the lowering can name it as unsupported. */
+  export function statSync(path: string, options: StatSyncOptions & { bigint: true }): Stats;
+  export function statSync(path: string, options: StatSyncOptions): Stats | undefined;
+  export function lstatSync(path: string, options?: undefined): Stats;
+  export function lstatSync(
+    path: string,
+    options: StatSyncOptions & { bigint?: false; throwIfNoEntry: false },
+  ): Stats | undefined;
+  export function lstatSync(
+    path: string,
+    options: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true },
+  ): Stats;
+  /* bigint: true type-checks so the lowering can name it as unsupported. */
+  export function lstatSync(path: string, options: StatSyncOptions & { bigint: true }): Stats;
+  export function lstatSync(path: string, options: StatSyncOptions): Stats | undefined;
   /* The fd pair behind spawn's fd-stdio form: openSync(path, flags) →
    * the raw fd. Numeric flags use an inline OR of the O_* constants. */
   export function openSync(path: string, flags: string): number;
@@ -1632,9 +1757,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>;
@@ -1693,6 +1840,11 @@ declare module "fs/promises" {
     path: string | Uint8Array | URL,
     type?: string | null,
   ): Promise<void>;
+  export function cp(
+    source: string | URL,
+    destination: string | URL,
+    options?: import("node:fs").CopyOptions,
+  ): Promise<void>;
   export function readlink(
     path: string | Uint8Array | URL,
     options: "buffer" | { encoding: "buffer" },
@@ -2309,6 +2461,7 @@ declare module "node:url" {
 
 /* node:crypto: the static hashing/MAC/random/key-derivation utility slice. */
 declare module "crypto" {
+  import { Transform } from "stream";
   export type KeyObjectType = "secret" | "public" | "private";
   export interface JsonWebKey {
     kty?: string;
@@ -2351,14 +2504,16 @@ declare module "crypto" {
   export interface HashOptions {
     outputLength?: number | undefined;
   }
-  export interface Hash {
+  /* Hash and Hmac are Transforms: written chunks update the digest, which
+   * the readable side delivers once the writable side ends. */
+  export interface Hash extends Transform {
     copy(options?: HashOptions): Hash;
     update(data: string | ArrayBufferView): Hash;
     update(data: string, inputEncoding: Encoding): Hash;
     digest(): Buffer;
     digest(encoding: BinaryToTextEncoding): string;
   }
-  export interface Hmac {
+  export interface Hmac extends Transform {
     update(data: string | ArrayBufferView): Hmac;
     update(data: string, inputEncoding: Encoding): Hmac;
     digest(): Buffer;
@@ -2877,7 +3032,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),
@@ -2888,9 +3044,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";
@@ -2964,6 +3121,12 @@ declare module "util" {
   export type TextDecoder = globalThis.TextDecoder;
   export var TextEncoder: typeof globalThis.TextEncoder;
   export var TextDecoder: typeof globalThis.TextDecoder;
+  /* stream.pipeline's (...streams: unknown[]) => unknown is assignable to
+   * every other target's parameter type, so its overload comes first; no
+   * other target is assignable to it. */
+  export function promisify(
+    fn: typeof import("node:stream").pipeline,
+  ): typeof import("node:stream/promises").pipeline;
   export function promisify(
     fn: typeof import("node:fs").readFile,
   ): (path: string, encoding: "utf8" | "utf-8") => Promise<string>;
@@ -2982,6 +3145,32 @@ declare module "util" {
       windowsHide?: boolean;
     },
   ) => Promise<{ stdout: string; stderr: string }>;
+  export function promisify(
+    fn: typeof globalThis.setTimeout,
+  ): typeof import("node:timers/promises").setTimeout;
+  export function promisify(
+    fn: typeof globalThis.setImmediate,
+  ): typeof import("node:timers/promises").setImmediate;
+  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 }>;
+  /* The zlib callback one-shots (deflate, inflate, deflateRaw, inflateRaw,
+   * gzip, gunzip, unzip) share one type. */
+  export function promisify(
+    fn: typeof import("node:zlib").gzip,
+  ): (data: string | Uint8Array, options?: import("node:zlib").ZlibOptions) => Promise<Buffer>;
+  export function promisify(
+    fn: typeof import("node:stream").finished,
+  ): typeof import("node:stream/promises").finished;
   /* 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
@@ -3168,8 +3357,9 @@ 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. */
+  /* The mock function surface: mock.fn, mock.method and their t.mock
+   * twins, the tracker's restoreAll and reset, and the calls log and the
+   * implementation controls on fn.mock. */
   interface MockFunctionCall<
     F extends Function,
     ReturnType = F extends (...args: any) => infer T ? T : unknown,
@@ -3189,17 +3379,35 @@ declare module "node:test" {
     restore(): void;
   }
   type Mock<F extends Function> = F & { mock: MockFunctionContext<F> };
+  interface MockFunctionOptions {
+    times?: number;
+  }
+  type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+  }[keyof T];
   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>(
+    method<MockedObject extends object, MethodName extends FunctionPropertyNames<MockedObject>>(
+      object: MockedObject,
+      methodName: MethodName,
+      options?: MockFunctionOptions,
+    ): MockedObject[MethodName] extends Function ? Mock<MockedObject[MethodName]> : never;
+    method<
+      MockedObject extends object,
+      MethodName extends FunctionPropertyNames<MockedObject>,
+      Implementation extends Function,
+    >(
       object: MockedObject,
-      methodName: keyof MockedObject,
-      implementation?: Function,
-    ): Mock<Function>;
+      methodName: MethodName,
+      implementation: Implementation,
+      options?: MockFunctionOptions,
+    ): MockedObject[MethodName] extends Function
+      ? Mock<MockedObject[MethodName] | Implementation>
+      : never;
     reset(): void;
     restoreAll(): void;
   }
@@ -3442,10 +3650,31 @@ declare module "node:querystring" {
  * on("close", cb). An open interface keeps the process alive until
  * close()/EOF, Node's semantics; lines split on \n and \r\n. */
 declare module "readline" {
-  /* The non-terminal Interface over process.stdin or a stream input
-   * (scr_readline.c). Listener registrations are statements: chaining
-   * on()/once() results has no lowering. */
+  /* The Interface over process.stdin or a stream input (scr_readline.c;
+   * terminal mode in scr_readline_tty.c). Listener registrations are
+   * statements: chaining on()/once() results has no lowering. */
+  export interface Key {
+    sequence?: string;
+    name?: string;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+  }
   export interface Interface extends Disposable {
+    /* terminal says whether the interface edits lines as a terminal;
+     * line and cursor are the terminal's (line is '' otherwise). history
+     * is the history option itself (or the interface's own empty array);
+     * a terminal records the lines it reads. */
+    readonly terminal: boolean;
+    readonly line: string;
+    readonly cursor: number;
+    getCursorPos(): CursorPos;
+    history: string[];
+    readonly historySize: number;
+    readonly historyIndex: number;
+    readonly crlfDelay: number;
+    readonly tabSize: number;
+    readonly escapeCodeTimeout: number;
     question(query: string, callback: (answer: string) => void): void;
     close(): void;
     pause(): this;
@@ -3453,16 +3682,28 @@ declare module "readline" {
     prompt(preserveCursor?: boolean): void;
     setPrompt(prompt: string): void;
     getPrompt(): string;
-    write(data: string): void;
+    write(data: string | null | undefined, key?: Key): void;
     on(event: "line", listener: (input: string) => void): this;
-    on(event: "close" | "pause" | "resume", listener: () => void): this;
+    on(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     on(event: "error", listener: (err: Error) => void): this;
+    on(event: "history", listener: (history: string[]) => void): this;
     once(event: "line", listener: (input: string) => void): this;
-    once(event: "close" | "pause" | "resume", listener: () => void): this;
+    once(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     once(event: "error", listener: (err: Error) => void): this;
+    once(event: "history", listener: (history: string[]) => void): this;
     addListener(event: "line", listener: (input: string) => void): this;
-    addListener(event: "close" | "pause" | "resume", listener: () => void): this;
+    addListener(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "history", listener: (history: string[]) => void): this;
     [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     [Symbol.dispose](): void;
   }
@@ -3472,26 +3713,83 @@ declare module "readline" {
     terminal?: boolean;
     /* Node's crlfDelay: a \n arriving within this many ms (at least 100)
      * after a line ended by \r is dropped. completer and the history
-     * knobs fence by name (no interactive terminal). The options-record
+     * options are validated and kept; a terminal interface uses them.
+     * The options-record
      * stance (see http.RequestOptions) admits every key; the walk
      * decides. */
     crlfDelay?: number;
     completer?: unknown;
     signal?: AbortSignal;
+    history?: string[];
+    historySize?: number;
+    removeHistoryDuplicates?: boolean;
+    tabSize?: number;
+    escapeCodeTimeout?: number;
     [option: string]: unknown;
   }
   export function createInterface(options: ReadLineOptions): Interface;
-  export function createInterface(input: unknown, output?: unknown): Interface;
+  export function createInterface(
+    input: unknown,
+    output?: unknown,
+    completer?: unknown,
+    terminal?: boolean,
+  ): Interface;
+  export interface CursorPos {
+    rows: number;
+    cols: number;
+  }
+  /* The escape-sequence helpers over process.stdout, process.stderr, a
+   * writable stream, or null/undefined (nothing is written). */
+  export function cursorTo(stream: unknown, x: number, y?: number, callback?: () => void): boolean;
+  export function cursorTo(stream: unknown, x: number, callback: () => void): boolean;
+  export function moveCursor(
+    stream: unknown,
+    dx: number,
+    dy: number,
+    callback?: () => void,
+  ): boolean;
+  export function clearLine(stream: unknown, dir: -1 | 0 | 1, callback?: () => void): boolean;
+  export function clearScreenDown(stream: unknown, callback?: () => void): boolean;
+  /* 'keypress' events (str, key) on process.stdin or a readable stream */
+  export function emitKeypressEvents(stream: unknown, readlineInterface?: unknown): void;
+  /* the same object as node:readline/promises */
+  export const promises: typeof import("node:readline/promises");
 }
 declare module "node:readline" {
   export * from "readline";
 }
 declare module "readline/promises" {
-  import { ReadLineOptions } from "readline";
+  import { CursorPos, Key, ReadLineOptions } from "readline";
+  /* The escape-sequence builder over process.stdout, process.stderr or a
+   * writable stream: actions queue until commit(), or are written on the
+   * next tick with autoCommit. */
+  export class Readline {
+    constructor(stream: unknown, options?: { autoCommit?: boolean });
+    clearLine(dir: -1 | 0 | 1): this;
+    clearScreenDown(): this;
+    commit(): Promise<void>;
+    cursorTo(x: number, y?: number): this;
+    moveCursor(dx: number, dy: number): this;
+    rollback(): this;
+  }
   /* The readline Interface with the promise question: it resolves with
    * the next line, rejects with an AbortError when options.signal aborts,
    * and with ERR_USE_AFTER_CLOSE after close(). */
   export interface Interface extends Disposable {
+    /* terminal says whether the interface edits lines as a terminal;
+     * line and cursor are the terminal's (line is '' otherwise). history
+     * is the history option itself (or the interface's own empty array);
+     * a terminal records the lines it reads. */
+    readonly terminal: boolean;
+    readonly line: string;
+    readonly cursor: number;
+    getCursorPos(): CursorPos;
+    history: string[];
+    readonly historySize: number;
+    readonly historyIndex: number;
+    readonly crlfDelay: number;
+    readonly tabSize: number;
+    readonly escapeCodeTimeout: number;
     question(query: string, options?: { signal?: AbortSignal }): Promise<string>;
     close(): void;
     pause(): this;
@@ -3499,21 +3797,38 @@ declare module "readline/promises" {
     prompt(preserveCursor?: boolean): void;
     setPrompt(prompt: string): void;
     getPrompt(): string;
-    write(data: string): void;
+    write(data: string | null | undefined, key?: Key): void;
     on(event: "line", listener: (input: string) => void): this;
-    on(event: "close" | "pause" | "resume", listener: () => void): this;
+    on(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     on(event: "error", listener: (err: Error) => void): this;
+    on(event: "history", listener: (history: string[]) => void): this;
     once(event: "line", listener: (input: string) => void): this;
-    once(event: "close" | "pause" | "resume", listener: () => void): this;
+    once(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     once(event: "error", listener: (err: Error) => void): this;
+    once(event: "history", listener: (history: string[]) => void): this;
     addListener(event: "line", listener: (input: string) => void): this;
-    addListener(event: "close" | "pause" | "resume", listener: () => void): this;
+    addListener(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "history", listener: (history: string[]) => void): this;
     [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     [Symbol.dispose](): void;
   }
   export function createInterface(options: ReadLineOptions): Interface;
-  export function createInterface(input: unknown, output?: unknown): Interface;
+  export function createInterface(
+    input: unknown,
+    output?: unknown,
+    completer?: unknown,
+    terminal?: boolean,
+  ): Interface;
 }
 declare module "node:readline/promises" {
   export * from "readline/promises";
@@ -3979,6 +4294,11 @@ declare module "net" {
     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;
@@ -4038,6 +4358,8 @@ declare module "net" {
     /* 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). */
@@ -4073,7 +4395,7 @@ declare module "net" {
     /* http.createServer(handler)'s event twin (a no-parser net server
      * never fires it, like Node). */
     on(
-      event: "request",
+      event: "request" | "checkContinue" | "checkExpectation",
       listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
     ): void;
     /* addListener IS on (Node aliases them) — the suite spells both. */
@@ -4087,7 +4409,7 @@ declare module "net" {
       listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void,
     ): void;
     addListener(
-      event: "request",
+      event: "request" | "checkContinue" | "checkExpectation",
       listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
     ): void;
     once(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
@@ -4100,7 +4422,7 @@ declare module "net" {
       listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void,
     ): void;
     once(
-      event: "request",
+      event: "request" | "checkContinue" | "checkExpectation",
       listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
     ): void;
   }
@@ -4221,6 +4543,7 @@ declare module "http" {
     requireHostHeader?: boolean;
     joinDuplicateHeaders?: boolean;
     keepAliveTimeoutBuffer?: number;
+    maxHeaderSize?: number;
     [option: string]: unknown;
   }
   /* The outgoing-header shape, @types/node's matrix: numbers format via
@@ -4340,6 +4663,8 @@ declare module "http" {
      * Agent VALUE threads through (getName-keyed maxSockets accounting
      * over one-dial-per-request connections). */
     agent?: Agent | boolean | null;
+    /* Aborting destroys the request with an AbortError. */
+    signal?: AbortSignal;
     /* The options-record stance: Node ignores an options record's
      * unknown keys, so every key typechecks here — the option WALK in
      * the lowering decides per key (lower, fence by name, or drop
@@ -4421,7 +4746,7 @@ declare module "http" {
     setTimeout(timeout: number, callback?: () => void): this;
     write(data: string | Uint8Array): void;
     end(data?: string | Uint8Array): void;
-    destroy(): void;
+    destroy(error?: Error): void;
     abort(): void;
     on(event: "response", listener: (res: IncomingMessage) => void): void;
     on(event: "socket", listener: (socket: Socket) => void): void;
@@ -4429,7 +4754,7 @@ declare module "http" {
       event: "upgrade",
       listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void,
     ): void;
-    on(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
+    on(event: "timeout" | "close" | "finish" | "abort" | "continue", listener: () => void): void;
     on(event: "error", listener: (err: Error) => void): void;
     /* addListener IS on (Node aliases them) — the suite spells both. */
     addListener(event: "response", listener: (res: IncomingMessage) => void): void;
@@ -4446,7 +4771,7 @@ declare module "http" {
       event: "upgrade",
       listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void,
     ): void;
-    once(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
+    once(event: "timeout" | "close" | "finish" | "abort" | "continue", listener: () => void): void;
     once(event: "error", listener: (err: Error) => void): void;
   }
   export function createServer(
@@ -4508,7 +4833,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
@@ -4519,7 +4844,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
@@ -4596,6 +4934,8 @@ declare module "https" {
     rejectUnauthorized?: boolean;
     ca?: string | Uint8Array;
     agent?: Agent | boolean | null;
+    /* Aborting destroys the request with an AbortError. */
+    signal?: AbortSignal;
     /* The options-record stance (see http.RequestOptions). */
     [option: string]: unknown;
   }
@@ -5306,8 +5646,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;
@@ -5326,8 +5667,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;
@@ -5456,6 +5811,13 @@ declare module "worker_threads" {
     removeAllListeners(event?: string): this;
     listenerCount(event: string, listener?: (...args: any[]) => void): number;
   }
+  /* Two entangled ports; a port moves to another thread through a
+   * postMessage or workerData transferList. */
+  export class MessageChannel {
+    readonly port1: MessagePort;
+    readonly port2: MessagePort;
+  }
+  export function receiveMessageOnPort(port: MessagePort): { message: any } | undefined;
   export const parentPort: MessagePort | null;
   export const workerData: any;
 }
@@ -5595,7 +5957,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;
 }