@scriptc/compiler 0.3.2 → 0.3.3

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

@@ -36,6 +36,26 @@ declare namespace NodeJS {
     user: number;
     system: number;
   }
+  interface MemoryUsage {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers: number;
+  }
+  /* process.memoryUsage(): rss from the OS, heapTotal/heapUsed from the
+   * runtime heap's own accounting; external and arrayBuffers are 0. */
+  interface MemoryUsageFn {
+    (): MemoryUsage;
+    rss(): number;
+  }
+  interface ProcessRelease {
+    name: string;
+    sourceUrl?: string | undefined;
+    headersUrl?: string | undefined;
+    libUrl?: string | undefined;
+    lts?: string | undefined;
+  }
   interface ResourceUsage {
     userCPUTime: number;
     systemCPUTime: number;
@@ -229,6 +249,16 @@ declare var process: {
   readonly execPath: string;
   getuid?(): number;
   getgid?(): number;
+  geteuid?(): number;
+  getegid?(): number;
+  getgroups?(): number[];
+  readonly ppid: number;
+  /* libuv's process title: argv[0] until set; a write is truncated to
+   * the original argument area on POSIX and sets the console title on
+   * Windows. */
+  title: string;
+  argv0: string;
+  readonly release: NodeJS.ProcessRelease;
   /* signal admits null (Node treats it as the SIGTERM default) — real
    * callers forward a `string | null` result field. */
   kill(pid: number, signal?: string | number | null): true;
@@ -255,6 +285,7 @@ declare var process: {
   cpuUsage(previousValue?: NodeJS.CpuUsage): NodeJS.CpuUsage;
   threadCpuUsage(previousValue?: NodeJS.CpuUsage): NodeJS.CpuUsage;
   resourceUsage(): NodeJS.ResourceUsage;
+  memoryUsage: NodeJS.MemoryUsageFn;
   availableMemory(): number;
   constrainedMemory(): number;
   /* The loop's own bookkeeping: 'Timeout' per armed timer, 'Immediate'
@@ -840,6 +871,44 @@ declare var Response: {
   json(data: unknown, init?: ResponseInit): Response;
   redirect(url: string | URL, status?: number): Response;
 };
+/* Blob and File (node:buffer, also globals): immutable bytes with a
+ * content type. Sources are copied when the Blob is built. */
+interface BlobPropertyBag {
+  endings?: "transparent" | "native";
+  type?: string;
+}
+interface FilePropertyBag extends BlobPropertyBag {
+  lastModified?: number;
+}
+interface Blob {
+  readonly size: number;
+  readonly type: string;
+  slice(start?: number, end?: number, contentType?: string): Blob;
+  text(): Promise<string>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  bytes(): Promise<Uint8Array>;
+  stream(): ReadableStream<Uint8Array>;
+  textStream(): ReadableStream<string>;
+}
+declare var Blob: {
+  new (
+    sources?: readonly (string | ArrayBuffer | ArrayBufferView | Blob)[],
+    options?: BlobPropertyBag,
+  ): Blob;
+  readonly prototype: Blob;
+};
+interface File extends Blob {
+  readonly name: string;
+  readonly lastModified: number;
+}
+declare var File: {
+  new (
+    sources: readonly (string | ArrayBuffer | ArrayBufferView | Blob)[],
+    fileName: string,
+    options?: FilePropertyBag,
+  ): File;
+  readonly prototype: File;
+};
 interface Request {
   readonly method: string;
   readonly url: string;
@@ -1034,10 +1103,48 @@ declare module "diagnostics_channel" {
  * anchored monotonic clock (Node's timeOrigin for a compiled program),
  * fractional milliseconds. The .bind(performance) spelling lowers to the
  * same clock as a plain () => number function value (the mockable-clock idiom's
- * getTimestamp); everything else fences per member. */
+ * getTimestamp). mark, measure, the getEntries family and the clears run
+ * over the thread's performance timeline with Node's validation; everything
+ * else fences per member. */
 declare module "node:perf_hooks" {
+  export type EntryType = "mark" | "measure";
+  export class PerformanceEntry {
+    protected constructor();
+    readonly duration: number;
+    readonly name: string;
+    readonly startTime: number;
+    readonly entryType: EntryType;
+    toJSON(): any;
+  }
+  export class PerformanceMark extends PerformanceEntry {
+    readonly detail: any;
+    readonly duration: 0;
+    readonly entryType: "mark";
+  }
+  export class PerformanceMeasure extends PerformanceEntry {
+    readonly detail: any;
+    readonly entryType: "measure";
+  }
+  export interface MarkOptions {
+    detail?: unknown | undefined;
+    startTime?: number | undefined;
+  }
+  export interface MeasureOptions {
+    detail?: unknown;
+    duration?: number | undefined;
+    end?: number | string | undefined;
+    start?: number | string | undefined;
+  }
   export interface Performance {
     now(): number;
+    mark(name: string, options?: MarkOptions): PerformanceMark;
+    measure(name: string, startMark?: string, endMark?: string): PerformanceMeasure;
+    measure(name: string, options: MeasureOptions): PerformanceMeasure;
+    getEntries(): PerformanceEntry[];
+    getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
+    getEntriesByType(type: EntryType): PerformanceEntry[];
+    clearMarks(name?: string): void;
+    clearMeasures(name?: string): void;
   }
   export const performance: Performance;
 }
@@ -1180,6 +1287,9 @@ declare module "node:fs" {
     options: string | { encoding?: string | null } | null,
   ): string | Buffer;
   export function chownSync(path: string, uid: number, gid: number): void;
+  export function lchownSync(path: string, uid: number, gid: number): void;
+  export function fchownSync(fd: number, uid: number, gid: number): void;
+  export function truncateSync(path: string, len?: number): void;
   /* The 2-argument form only (Node's mode flags have no lowering). The
    * destination is created or truncated carrying the SOURCE's mode. */
   export function copyFileSync(src: string, dest: string): void;
@@ -1217,6 +1327,51 @@ declare module "node:fs" {
      * fences by name at the call site; undocumented keys drop like Node. */
     options: { withFileTypes: true; recursive?: boolean; [option: string]: unknown },
   ): Dirent[];
+  /* fs.globSync / fs.glob: Node's glob walk over the file system. Patterns
+   * are minimatch globs (case-insensitive on macOS and Windows); results
+   * are relative to cwd unless the pattern is absolute. withFileTypes must
+   * be a literal so the result type is known. */
+  export interface GlobOptions {
+    cwd?: string | URL;
+    exclude?: readonly string[] | ((fileName: string) => boolean);
+    followSymlinks?: boolean;
+    withFileTypes?: false;
+  }
+  export interface GlobOptionsWithFileTypes {
+    cwd?: string | URL;
+    exclude?: readonly string[];
+    followSymlinks?: boolean;
+    withFileTypes: true;
+  }
+  export function globSync(pattern: string | readonly string[], options?: GlobOptions): string[];
+  export function globSync(
+    pattern: string | readonly string[],
+    options: GlobOptionsWithFileTypes,
+  ): Dirent[];
+  export function glob(
+    pattern: string | readonly string[],
+    callback: (err: NodeJS.ErrnoException | null, matches?: string[]) => void,
+  ): void;
+  export function glob(
+    pattern: string | readonly string[],
+    options: GlobOptions,
+    callback: (err: NodeJS.ErrnoException | null, matches?: string[]) => void,
+  ): void;
+  /* fs.Dir: an open directory stream (opendirSync, fs.promises.opendir)
+   * read one Dirent at a time in OS order; utf8 names, no recursive walk. */
+  export interface Dir {
+    readonly path: string;
+    readSync(): Dirent | null;
+    read(): Promise<Dirent | null>;
+    closeSync(): void;
+    close(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Dirent>;
+  }
+  export interface OpenDirOptions {
+    encoding?: "utf8" | "utf-8";
+    bufferSize?: number;
+  }
+  export function opendirSync(path: string, options?: OpenDirOptions): Dir;
   export function accessSync(path: string, mode?: number): void;
   export function mkdtempSync(prefix: string): string;
   export const constants: {
@@ -1243,14 +1398,28 @@ declare module "node:fs" {
     isFile(): boolean;
     isDirectory(): boolean;
     isSymbolicLink(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
     readonly dev: number;
+    readonly mode: number;
+    readonly nlink: number;
+    readonly uid: number;
+    readonly gid: number;
+    readonly rdev: number;
+    readonly blksize: number;
     readonly ino: number;
     readonly size: number;
     readonly blocks: number;
-    readonly nlink: number;
     readonly atimeMs: number;
     readonly mtimeMs: number;
     readonly ctimeMs: number;
+    readonly birthtimeMs: number;
+    readonly atime: Date;
+    readonly mtime: Date;
+    readonly ctime: Date;
+    readonly birthtime: Date;
   }
   export function statSync(path: string): Stats;
   export function lstatSync(path: string): Stats;
@@ -1539,6 +1708,10 @@ declare module "fs/promises" {
     mtime: number | string | Date,
   ): Promise<void>;
   export function readFile(path: string, encoding: "utf8" | "utf-8"): Promise<string>;
+  export function readFile(
+    path: string,
+    options: BufferEncoding | { encoding: BufferEncoding },
+  ): Promise<string>;
   export function readFile(path: string): Promise<Buffer>;
   export function writeFile(
     path: string,
@@ -1565,6 +1738,15 @@ declare module "fs/promises" {
       [option: string]: unknown;
     },
   ): Promise<import("node:fs").Dirent[]>;
+  /* The async iterator form of fs.globSync: iterate it with for await. */
+  export function glob(
+    pattern: string | readonly string[],
+    options?: import("node:fs").GlobOptions,
+  ): AsyncIterableIterator<string>;
+  export function glob(
+    pattern: string | readonly string[],
+    options: import("node:fs").GlobOptionsWithFileTypes,
+  ): AsyncIterableIterator<import("node:fs").Dirent>;
   export function rm(path: string): Promise<void>;
   export function stat(path: string): Promise<import("node:fs").Stats>;
   export function statfs(
@@ -1583,7 +1765,19 @@ declare module "fs/promises" {
   export function lstat(path: string): Promise<import("node:fs").Stats>;
   export function unlink(path: string): Promise<void>;
   export function chmod(path: string, mode: number): Promise<void>;
+  export function chown(path: string, uid: number, gid: number): Promise<void>;
+  export function lchown(path: string, uid: number, gid: number): Promise<void>;
+  export function access(path: string, mode?: number): Promise<void>;
+  export function truncate(path: string, len?: number): Promise<void>;
+  export function appendFile(path: string, data: string | Uint8Array): Promise<void>;
+  export function copyFile(src: string, dest: string): Promise<void>;
+  export function mkdtemp(prefix: string): Promise<string>;
+  export function rmdir(path: string): Promise<void>;
   export function rename(oldPath: string, newPath: string): Promise<void>;
+  export function opendir(
+    path: string,
+    options?: import("node:fs").OpenDirOptions,
+  ): Promise<import("node:fs").Dir>;
 }
 declare module "node:fs/promises" {
   export * from "fs/promises";
@@ -1593,7 +1787,7 @@ declare module "node:fs/promises" {
  * on posix triples, path.win32 under a win32 triple, with the posix and
  * win32 namespaces answering their own platform anywhere. Every function
  * is a pure string algorithm matching Node's implementations
- * byte-for-byte; join/resolve are variadic like Node's. */
+ * exactly; join/resolve are variadic like Node's. */
 declare module "path" {
   export function join(...paths: string[]): string;
   export function resolve(...paths: string[]): string;
@@ -2029,7 +2223,10 @@ declare var URLSearchParams: {
 /* node:url — the file-URL bridge pair. fileURLToPath accepts a URL value
  * or a URL string and throws Node's TypeErrors (non-file scheme, encoded
  * slashes, non-empty host); pathToFileURL resolves the path and percent-
- * encodes it into a file: URL. */
+ * encodes it into a file: URL. The legacy API: parse() answers a Url
+ * object, format() serializes a Url-shaped object, a string, or a URL,
+ * resolve() resolves one URL string against another, and the domain pair
+ * converts a hostname to and from its Punycode form. */
 declare module "url" {
   export type URL = globalThis.URL;
   export type URLSearchParams = globalThis.URLSearchParams;
@@ -2038,6 +2235,65 @@ declare module "url" {
   export function fileURLToPath(url: string | URL, options?: { windows?: boolean }): string;
   export function fileURLToPathBuffer(url: string | URL, options?: { windows?: boolean }): Buffer;
   export function pathToFileURL(path: string, options?: { windows?: boolean }): URL;
+  export interface UrlObject {
+    auth?: string | null | undefined;
+    hash?: string | null | undefined;
+    host?: string | null | undefined;
+    hostname?: string | null | undefined;
+    href?: string | null | undefined;
+    pathname?: string | null | undefined;
+    protocol?: string | null | undefined;
+    search?: string | null | undefined;
+    slashes?: boolean | null | undefined;
+    port?: string | number | null | undefined;
+    query?: string | null | import("querystring").ParsedUrlQueryInput | undefined;
+  }
+  export interface Url {
+    auth: string | null;
+    hash: string | null;
+    host: string | null;
+    hostname: string | null;
+    href: string;
+    path: string | null;
+    pathname: string | null;
+    protocol: string | null;
+    search: string | null;
+    slashes: boolean | null;
+    port: string | null;
+    query: string | null | import("querystring").ParsedUrlQuery;
+  }
+  export interface UrlWithParsedQuery extends Url {
+    query: import("querystring").ParsedUrlQuery;
+  }
+  export interface UrlWithStringQuery extends Url {
+    query: string | null;
+  }
+  export interface URLFormatOptions {
+    auth?: boolean | undefined;
+    fragment?: boolean | undefined;
+    search?: boolean | undefined;
+    unicode?: boolean | undefined;
+  }
+  export function parse(
+    urlString: string,
+    parseQueryString?: false,
+    slashesDenoteHost?: boolean,
+  ): UrlWithStringQuery;
+  export function parse(
+    urlString: string,
+    parseQueryString: true,
+    slashesDenoteHost?: boolean,
+  ): UrlWithParsedQuery;
+  export function parse(
+    urlString: string,
+    parseQueryString: boolean,
+    slashesDenoteHost?: boolean,
+  ): Url;
+  export function format(urlObject: URL, options?: URLFormatOptions): string;
+  export function format(urlObject: UrlObject | string): string;
+  export function resolve(from: string, to: string): string;
+  export function domainToASCII(domain: string): string;
+  export function domainToUnicode(domain: string): string;
 }
 declare module "node:url" {
   export * from "url";
@@ -2045,34 +2301,127 @@ declare module "node:url" {
 
 /* node:crypto: the static hashing/MAC/random/key-derivation utility slice. */
 declare module "crypto" {
-  export function randomUUID(): string;
+  export type KeyObjectType = "secret" | "public" | "private";
+  export interface JsonWebKey {
+    kty?: string;
+    k?: string;
+  }
+  export interface JwkKeyExportOptions {
+    format: "jwk";
+  }
+  export interface KeyExportOptions {
+    format?: "buffer" | undefined;
+  }
+  /** Secret keys only; the asymmetric key types are not available. */
+  export class KeyObject {
+    private constructor();
+    type: KeyObjectType;
+    symmetricKeySize?: number;
+    asymmetricKeyType?: string;
+    export(options?: KeyExportOptions): Buffer;
+    export(options: JwkKeyExportOptions): JsonWebKey;
+    equals(otherKeyObject: KeyObject): boolean;
+  }
+  export function createSecretKey(key: ArrayBufferView | ArrayBufferLike): KeyObject;
+  export function createSecretKey(key: string, encoding: BufferEncoding): KeyObject;
+  export function generateKeySync(type: "hmac" | "aes", options: { length: number }): KeyObject;
+  export function generateKey(
+    type: "hmac" | "aes",
+    options: { length: number },
+    callback: (err: Error | null, key: KeyObject) => void,
+  ): void;
+  export interface RandomUUIDOptions {
+    disableEntropyCache?: boolean | undefined;
+  }
+  export function randomUUID(options?: RandomUUIDOptions): string;
+  export function randomUUIDv7(options?: RandomUUIDOptions): string;
   export function randomBytes(size: number): Buffer;
+  export type BinaryToTextEncoding = "base64" | "base64url" | "hex" | "binary";
+  export type CharacterEncoding = "utf8" | "utf-8" | "utf16le" | "utf-16le" | "latin1";
+  export type LegacyCharacterEncoding = "ascii" | "binary" | "ucs2" | "ucs-2";
+  export type Encoding = BinaryToTextEncoding | CharacterEncoding | LegacyCharacterEncoding;
+  export interface HashOptions {
+    outputLength?: number | undefined;
+  }
   export interface Hash {
-    update(data: string | Uint8Array, inputEncoding?: "utf8" | "utf-8" | "hex" | "base64"): Hash;
+    copy(options?: HashOptions): Hash;
+    update(data: string | ArrayBufferView): Hash;
+    update(data: string, inputEncoding: Encoding): Hash;
     digest(): Buffer;
-    digest(encoding: "hex" | "base64"): string;
-    copy(): Hash;
+    digest(encoding: BinaryToTextEncoding): string;
   }
   export interface Hmac {
-    update(data: string | Uint8Array, inputEncoding?: "utf8" | "utf-8" | "hex" | "base64"): Hmac;
+    update(data: string | ArrayBufferView): Hmac;
+    update(data: string, inputEncoding: Encoding): Hmac;
     digest(): Buffer;
-    digest(encoding: "hex" | "base64"): string;
+    digest(encoding: BinaryToTextEncoding): string;
+  }
+  export function createHash(algorithm: string, options?: HashOptions): Hash;
+  export function createHmac(
+    algorithm: string,
+    key: BinaryLike | KeyObject,
+    options?: { encoding?: BufferEncoding | undefined },
+  ): Hmac;
+  export interface OneShotDigestOptions {
+    outputEncoding?: BinaryToTextEncoding | "buffer" | undefined;
+    outputLength?: number | undefined;
+  }
+  export interface OneShotDigestOptionsWithStringEncoding extends OneShotDigestOptions {
+    outputEncoding?: BinaryToTextEncoding | undefined;
+  }
+  export interface OneShotDigestOptionsWithBufferEncoding extends OneShotDigestOptions {
+    outputEncoding: "buffer";
   }
-  export function createHash(algorithm: string): Hash;
-  export function createHmac(algorithm: string, key: string | Uint8Array): Hmac;
   export function hash(
     algorithm: string,
-    data: string | Uint8Array,
-    outputEncoding?: "hex" | "base64",
+    data: string | ArrayBufferView,
+    options?: OneShotDigestOptionsWithStringEncoding | BinaryToTextEncoding,
   ): string;
-  export function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;
-  export function randomFillSync<T extends Uint8Array>(
+  export function hash(
+    algorithm: string,
+    data: string | ArrayBufferView,
+    options: OneShotDigestOptionsWithBufferEncoding | "buffer",
+  ): Buffer;
+  export function hash(
+    algorithm: string,
+    data: string | ArrayBufferView,
+    options: OneShotDigestOptions | BinaryToTextEncoding | "buffer",
+  ): string | Buffer;
+  export function timingSafeEqual(
+    a: ArrayBufferView | ArrayBufferLike,
+    b: ArrayBufferView | ArrayBufferLike,
+  ): boolean;
+  export function randomFillSync<T extends ArrayBufferView | ArrayBufferLike>(
     buffer: T,
     offset?: number,
     size?: number,
   ): T;
+  export function randomFill<T extends ArrayBufferView | ArrayBufferLike>(
+    buffer: T,
+    callback: (err: Error | null, buf: T) => void,
+  ): void;
+  export function randomFill<T extends ArrayBufferView | ArrayBufferLike>(
+    buffer: T,
+    offset: number,
+    callback: (err: Error | null, buf: T) => void,
+  ): void;
+  export function randomFill<T extends ArrayBufferView | ArrayBufferLike>(
+    buffer: T,
+    offset: number,
+    size: number,
+    callback: (err: Error | null, buf: T) => void,
+  ): void;
   export function randomInt(max: number): number;
   export function randomInt(min: number, max: number): number;
+  export function randomInt(
+    max: number,
+    callback: (err: Error | null, value: number) => void,
+  ): void;
+  export function randomInt(
+    min: number,
+    max: number,
+    callback: (err: Error | null, value: number) => void,
+  ): void;
   export function pbkdf2Sync(
     password: string | Uint8Array,
     salt: string | Uint8Array,
@@ -2123,14 +2472,14 @@ declare module "crypto" {
   ): void;
   export function hkdfSync(
     digest: string,
-    ikm: BinaryLike,
+    ikm: BinaryLike | KeyObject,
     salt: BinaryLike,
     info: BinaryLike,
     keylen: number,
   ): ArrayBuffer;
   export function hkdf(
     digest: string,
-    ikm: BinaryLike,
+    ikm: BinaryLike | KeyObject,
     salt: BinaryLike,
     info: BinaryLike,
     keylen: number,
@@ -2160,7 +2509,7 @@ declare module "crypto" {
    * stance). Every ACCESS bakes as its literal at lowering; the object
    * itself never materializes (bare crypto.constants value uses fence). */
   export interface CryptoConstants {
-    readonly OPENSSL_VERSION_NUMBER: 810549328;
+    readonly OPENSSL_VERSION_NUMBER: 810549376;
     readonly SSL_OP_ALL: 2147485776;
     readonly SSL_OP_ALLOW_NO_DHE_KEX: 1024;
     readonly SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: 262144;
@@ -2200,6 +2549,7 @@ declare module "crypto" {
     readonly DH_UNABLE_TO_CHECK_GENERATOR: 4;
     readonly DH_NOT_SUITABLE_GENERATOR: 8;
     readonly RSA_PKCS1_PADDING: 1;
+    readonly RSA_SSLV23_PADDING: 2;
     readonly RSA_NO_PADDING: 3;
     readonly RSA_PKCS1_OAEP_PADDING: 4;
     readonly RSA_X931_PADDING: 5;
@@ -2902,29 +3252,82 @@ 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. */
   export interface Interface extends Disposable {
     question(query: string, callback: (answer: string) => void): void;
     close(): void;
-    on(event: "close", listener: () => void): void;
+    pause(): this;
+    resume(): this;
+    prompt(preserveCursor?: boolean): void;
+    setPrompt(prompt: string): void;
+    getPrompt(): string;
+    write(data: string): void;
+    on(event: "line", listener: (input: string) => void): this;
+    on(event: "close" | "pause" | "resume", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    once(event: "line", listener: (input: string) => void): this;
+    once(event: "close" | "pause" | "resume", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "line", listener: (input: string) => void): this;
+    addListener(event: "close" | "pause" | "resume", listener: () => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     [Symbol.dispose](): void;
   }
-  export function createInterface(options: {
+  export interface ReadLineOptions {
     input: unknown;
     output?: unknown;
     terminal?: boolean;
-    /* crlfDelay: Infinity is accepted — the lowered splitter already
-     * holds a trailing \r for the next chunk, Node's Infinity behavior;
-     * completer and the history knobs fence by name (no interactive
-     * terminal). The options-record stance (see http.RequestOptions)
-     * admits every key; the walk decides. */
+    /* 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
+     * stance (see http.RequestOptions) admits every key; the walk
+     * decides. */
     crlfDelay?: number;
     completer?: unknown;
+    signal?: AbortSignal;
     [option: string]: unknown;
-  }): Interface;
+  }
+  export function createInterface(options: ReadLineOptions): Interface;
+  export function createInterface(input: unknown, output?: unknown): Interface;
 }
 declare module "node:readline" {
   export * from "readline";
 }
+declare module "readline/promises" {
+  import { ReadLineOptions } from "readline";
+  /* 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 {
+    question(query: string, options?: { signal?: AbortSignal }): Promise<string>;
+    close(): void;
+    pause(): this;
+    resume(): this;
+    prompt(preserveCursor?: boolean): void;
+    setPrompt(prompt: string): void;
+    getPrompt(): string;
+    write(data: string): void;
+    on(event: "line", listener: (input: string) => void): this;
+    on(event: "close" | "pause" | "resume", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    once(event: "line", listener: (input: string) => void): this;
+    once(event: "close" | "pause" | "resume", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "line", listener: (input: string) => void): this;
+    addListener(event: "close" | "pause" | "resume", listener: () => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
+    [Symbol.dispose](): void;
+  }
+  export function createInterface(options: ReadLineOptions): Interface;
+  export function createInterface(input: unknown, output?: unknown): Interface;
+}
+declare module "node:readline/promises" {
+  export * from "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
@@ -3008,6 +3411,9 @@ declare module "node:zlib" {
  * 'error'. */
 declare module "net" {
   export interface Socket {
+    /* Whether the socket keeps the event loop alive (ref'd by default). */
+    ref(): void;
+    unref(): void;
     readonly remoteAddress: string | undefined;
     /* true once the fd is gone (destroy() or full close) — Node's flag. */
     readonly destroyed: boolean;
@@ -3072,6 +3478,9 @@ declare module "net" {
     once(event: "session", listener: (session: Buffer) => void): void;
   }
   export interface Server {
+    /* Whether the server keeps the event loop alive (ref'd by default). */
+    ref(): void;
+    unref(): void;
     readonly listening: boolean;
     /* Node answers the server itself (`return this` chaining). */
     listen(port: number, callback?: () => void): Server;
@@ -3266,7 +3675,8 @@ declare module "http" {
     destroy(): void;
     setTimeout(msecs: number, callback?: () => void): this;
     /* setEncoding('utf8'): 'data' delivers strings (other real encodings
-     * fence loudly at runtime; unknown names throw ERR_UNKNOWN_ENCODING). */
+     * throw a "not supported yet" Error at runtime; unknown names throw
+     * ERR_UNKNOWN_ENCODING). */
     setEncoding(encoding: string): void;
     /* The proxy legs: the body streams into a ServerResponse, a
      * ClientRequest, or a raw Socket; natural end ends the destination. */
@@ -3503,7 +3913,7 @@ declare module "node:http" {
  * that behaves exactly like a net socket (write/end/destroy/pipe and the
  * data/end/close/error events are the same lowered surface). cert/key
  * are PEM strings or Buffers. Handshake failures tear the socket down
- * silently, Node's default for 'tlsClientError' with no listener. */
+ * without emitting an event, Node's default for 'tlsClientError' with no listener. */
 declare module "tls" {
   import { Server, Socket } from "net";
   export { Server };
@@ -4448,6 +4858,10 @@ declare module "buffer" {
   export const kMaxLength: number;
   export const kStringMaxLength: number;
   export const Buffer: BufferConstructor;
+  export type Blob = globalThis.Blob;
+  export type File = globalThis.File;
+  export const Blob: typeof globalThis.Blob;
+  export const File: typeof globalThis.File;
 }
 declare module "node:buffer" {
   export * from "buffer";
@@ -4599,7 +5013,7 @@ declare module "stream" {
     emitClose?: boolean;
     captureRejections?: boolean;
     defaultEncoding?: string;
-    signal?: unknown;
+    signal?: AbortSignal;
   }
   interface WritableOptions {
     highWaterMark?: number;
@@ -4619,7 +5033,7 @@ declare module "stream" {
     autoDestroy?: boolean;
     emitClose?: boolean;
     captureRejections?: boolean;
-    signal?: unknown;
+    signal?: AbortSignal;
   }
   interface DuplexOptions {
     highWaterMark?: number;
@@ -4648,7 +5062,7 @@ declare module "stream" {
     writable?: boolean;
     defaultEncoding?: string;
     writev?(this: Duplex, chunks: unknown[], callback: (error?: Error | null) => void): void;
-    signal?: unknown;
+    signal?: AbortSignal;
   }
   interface TransformOptions {
     highWaterMark?: number;
@@ -4684,7 +5098,7 @@ declare module "stream" {
     readable?: boolean;
     writable?: boolean;
     defaultEncoding?: string;
-    signal?: unknown;
+    signal?: AbortSignal;
   }
 
   class Readable extends EventEmitter {
@@ -4928,15 +5342,34 @@ declare module "stream" {
     constructor(opts?: TransformOptions);
   }
 
+  /* addAbortSignal(signal, stream): the stream, destroyed with an
+   * AbortError (cause: signal.reason) when the signal aborts. */
+  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;
+  /* finished's options: readable/writable choose which ends count,
+   * error: false ignores 'error' events, signal aborts the wait. */
+  interface FinishedOptions {
+    readable?: boolean;
+    writable?: boolean;
+    error?: boolean;
+    signal?: AbortSignal;
+  }
   function finished(stream: unknown, callback: (err?: Error | null) => void): () => void;
+  function finished(
+    stream: unknown,
+    options: FinishedOptions | null,
+    callback: (err?: Error | null) => void,
+  ): () => void;
   /* 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;
   namespace promises {
     function pipeline(...streams: unknown[]): Promise<void>;
-    function finished(stream: unknown): Promise<void>;
+    function finished(
+      stream: unknown,
+      options?: FinishedOptions & { cleanup?: boolean },
+    ): Promise<void>;
   }
   class Stream extends EventEmitter {}
 
@@ -4947,12 +5380,19 @@ declare module "stream" {
     Transform,
     PassThrough,
     Stream,
+    addAbortSignal,
     pipeline,
     finished,
     getDefaultHighWaterMark,
     promises,
   };
-  export type { ReadableOptions, WritableOptions, DuplexOptions, TransformOptions };
+  export type {
+    ReadableOptions,
+    WritableOptions,
+    DuplexOptions,
+    TransformOptions,
+    FinishedOptions,
+  };
 }
 declare module "node:stream" {
   import stream = require("stream");
@@ -4962,9 +5402,20 @@ declare module "stream/promises" {
   /* The promise forms of finished/pipeline: a void promise the stream's
    * terminal point settles (rejected with the error, or
    * ERR_STREAM_PREMATURE_CLOSE on an early close). Stream arguments are
-   * the lowered surface — iterables/generators/functions fence per site. */
+   * 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>;
-  function finished(stream: unknown): Promise<void>;
+  function finished(
+    stream: unknown,
+    options?: {
+      readable?: boolean;
+      writable?: boolean;
+      error?: boolean;
+      cleanup?: boolean;
+      signal?: AbortSignal;
+    } | null,
+  ): Promise<void>;
   export { pipeline, finished };
 }
 declare module "node:stream/promises" {
@@ -4978,8 +5429,8 @@ declare module "stream/consumers" {
    * with the parse's SyntaxError), buffer (the concatenated bytes;
    * string chunks contribute their utf8 bytes, Node's Blob rule).
    * Stream errors reject; an early close rejects with
-   * ERR_STREAM_PREMATURE_CLOSE. arrayBuffer and blob fence per site:
-   * neither value has a representation in a compiled binary. */
+   * ERR_STREAM_PREMATURE_CLOSE. arrayBuffer answers an ArrayBuffer over
+   * the bytes; blob fences per site. */
   function text(stream: unknown): Promise<string>;
   function json(stream: unknown): Promise<unknown>;
   function buffer(stream: unknown): Promise<Buffer>;