@scriptc/compiler 0.3.1 → 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;
@@ -86,12 +106,14 @@ declare namespace NodeJS {
  * util.inspect rendering — so the parameters are unknown[], like stock
  * lib's console; values inspect cannot render statically (functions inside
  * composites, class hierarchies, `any`) fence per argument with a hint.
+ * assert, count/countReset, dir/dirxml, group/groupCollapsed/groupEnd,
+ * table, time/timeEnd/timeLog, clear, and the inspector-only
+ * profile/profileEnd/timeStamp lower on the global console.
  *
- * The REMAINING stock console members are declared too — not because they
- * lower (none do), but so a program that typechecks under its own tsc
- * reaches the per-site SC2020 fence naming the member and the supported
- * surface, instead of dying on a fallback-manufactured type error its own
- * tsc cannot reproduce. */
+ * trace is declared too — not because it lowers, but so a program that
+ * typechecks under its own tsc reaches the per-site SC2020 fence naming
+ * the member and the supported surface, instead of dying on a
+ * fallback-manufactured type error its own tsc cannot reproduce. */
 declare const console: {
   log(...args: unknown[]): void;
   info(...args: unknown[]): void;
@@ -112,13 +134,15 @@ declare const console: {
   timeEnd(label?: string): void;
   timeLog(label?: string, ...data: unknown[]): void;
   timeStamp(label?: string): void;
+  profile(label?: string): void;
+  profileEnd(label?: string): void;
   trace(...data: unknown[]): void;
   Console: typeof import("node:console").Console;
 };
 
 // node:console exports the global instance's bound methods and the Console
 // constructor: instances over process.stdout/process.stderr or node:stream
-// writables lower their log/info/debug/error/warn members; the remaining
+// writables lower their log/info/debug/error/warn members; their remaining
 // methods are declared so unsupported uses reach named fences.
 type ScriptcConsoleMethods = typeof console;
 declare module "node:console" {
@@ -145,6 +169,8 @@ declare module "node:console" {
   export const timeEnd: ScriptcConsoleMethods["timeEnd"];
   export const timeLog: ScriptcConsoleMethods["timeLog"];
   export const timeStamp: ScriptcConsoleMethods["timeStamp"];
+  export const profile: ScriptcConsoleMethods["profile"];
+  export const profileEnd: ScriptcConsoleMethods["profileEnd"];
   export const trace: ScriptcConsoleMethods["trace"];
   const defaultConsole: ScriptcConsoleMethods & { Console: typeof Console };
   export default defaultConsole;
@@ -223,12 +249,26 @@ 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;
   env: { [name: string]: string | undefined };
   /** Numeric writes set the status returned by ordinary program exit. */
   exitCode?: number;
+  /* Silence and throw DeprecationWarnings (util.deprecate,
+   * process.emitWarning); undefined until assigned. */
+  noDeprecation?: boolean;
+  throwDeprecation?: boolean;
   /* `never`, like @types/node: code behind an early-exit guard narrows
    * (`if (!x) process.exit(1)` proves x afterwards) — typed `void` the
    * guard narrows nothing and correct programs fail preflight. The
@@ -245,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'
@@ -830,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;
@@ -1024,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;
 }
@@ -1170,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;
@@ -1207,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: {
@@ -1233,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;
@@ -1529,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,
@@ -1555,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(
@@ -1573,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";
@@ -1583,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;
@@ -1594,6 +1798,27 @@ declare module "path" {
   export function isAbsolute(path: string): boolean;
   export function relative(from: string, to: string): string;
   export function toNamespacedPath(path: string): string;
+  /* matchesGlob() is Node's glob matcher: brace expansion, extglobs, POSIX
+   * classes and the ** and dot rules. */
+  export function matchesGlob(path: string, pattern: string): boolean;
+  /* parse() splits a path into its root, directory, base, extension and
+   * name; format() joins those fields back (Node's `||` defaults). */
+  export interface ParsedPath {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+  }
+  export interface FormatInputPathObject {
+    root?: string | undefined;
+    dir?: string | undefined;
+    base?: string | undefined;
+    ext?: string | undefined;
+    name?: string | undefined;
+  }
+  export function parse(path: string): ParsedPath;
+  export function format(pathObject: FormatInputPathObject): string;
   /* The union @types/node declares: the bare module answers the TARGET
    * platform's value (a compile-time constant — "\\"/";" under a win32
    * triple, "/"/":" everywhere else). */
@@ -1619,6 +1844,9 @@ declare module "path/posix" {
   export function isAbsolute(path: string): boolean;
   export function relative(from: string, to: string): string;
   export function toNamespacedPath(path: string): string;
+  export function matchesGlob(path: string, pattern: string): boolean;
+  export function parse(path: string): import("path").ParsedPath;
+  export function format(pathObject: import("path").FormatInputPathObject): string;
   export const sep: "/";
   export const delimiter: ":";
 }
@@ -1635,6 +1863,9 @@ declare module "path/win32" {
   export function isAbsolute(path: string): boolean;
   export function relative(from: string, to: string): string;
   export function toNamespacedPath(path: string): string;
+  export function matchesGlob(path: string, pattern: string): boolean;
+  export function parse(path: string): import("path").ParsedPath;
+  export function format(pathObject: import("path").FormatInputPathObject): string;
   export const sep: "\\";
   export const delimiter: ";";
 }
@@ -1692,6 +1923,237 @@ declare module "os" {
   }
   export type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
   export function networkInterfaces(): { [name: string]: NetworkInterfaceInfo[] | undefined };
+  /* Host facts, libuv's answers: model/speed/times per logical CPU, the
+   * host name, the 1/5/15-minute load averages, uptime in seconds, free
+   * memory in bytes, process.arch, uname's machine and version fields,
+   * the byte order, and a process's scheduling priority (an omitted pid
+   * is the current process). Shapes mirror @types/node's. */
+  export interface CpuInfo {
+    model: string;
+    speed: number;
+    times: {
+      user: number;
+      nice: number;
+      sys: number;
+      idle: number;
+      irq: number;
+    };
+  }
+  export function cpus(): CpuInfo[];
+  export function hostname(): string;
+  export function loadavg(): number[];
+  export function uptime(): number;
+  export function freemem(): number;
+  export function arch(): string;
+  export function machine(): string;
+  export function version(): string;
+  export function endianness(): "BE" | "LE";
+  export function getPriority(pid?: number): number;
+  /* The TARGET platform's null device ("\\\\.\\nul" under a win32 triple). */
+  export const devNull: string;
+  /* The platform's constants: null-prototype objects with read-only
+   * members, `signals` frozen (Node's internalBinding('constants').os). */
+  export type SignalConstants = {
+    [
+      key in
+        | "SIGABRT"
+        | "SIGALRM"
+        | "SIGBUS"
+        | "SIGCHLD"
+        | "SIGCONT"
+        | "SIGFPE"
+        | "SIGHUP"
+        | "SIGILL"
+        | "SIGINT"
+        | "SIGIO"
+        | "SIGIOT"
+        | "SIGKILL"
+        | "SIGPIPE"
+        | "SIGPOLL"
+        | "SIGPROF"
+        | "SIGPWR"
+        | "SIGQUIT"
+        | "SIGSEGV"
+        | "SIGSTKFLT"
+        | "SIGSTOP"
+        | "SIGSYS"
+        | "SIGTERM"
+        | "SIGTRAP"
+        | "SIGTSTP"
+        | "SIGTTIN"
+        | "SIGTTOU"
+        | "SIGUNUSED"
+        | "SIGURG"
+        | "SIGUSR1"
+        | "SIGUSR2"
+        | "SIGVTALRM"
+        | "SIGWINCH"
+        | "SIGXCPU"
+        | "SIGXFSZ"
+        | "SIGBREAK"
+        | "SIGLOST"
+        | "SIGINFO"
+    ]: number;
+  };
+  export namespace constants {
+    const UV_UDP_REUSEADDR: number;
+    namespace signals {}
+    const signals: SignalConstants;
+    namespace errno {
+      const E2BIG: number;
+      const EACCES: number;
+      const EADDRINUSE: number;
+      const EADDRNOTAVAIL: number;
+      const EAFNOSUPPORT: number;
+      const EAGAIN: number;
+      const EALREADY: number;
+      const EBADF: number;
+      const EBADMSG: number;
+      const EBUSY: number;
+      const ECANCELED: number;
+      const ECHILD: number;
+      const ECONNABORTED: number;
+      const ECONNREFUSED: number;
+      const ECONNRESET: number;
+      const EDEADLK: number;
+      const EDESTADDRREQ: number;
+      const EDOM: number;
+      const EDQUOT: number;
+      const EEXIST: number;
+      const EFAULT: number;
+      const EFBIG: number;
+      const EHOSTUNREACH: number;
+      const EIDRM: number;
+      const EILSEQ: number;
+      const EINPROGRESS: number;
+      const EINTR: number;
+      const EINVAL: number;
+      const EIO: number;
+      const EISCONN: number;
+      const EISDIR: number;
+      const ELOOP: number;
+      const EMFILE: number;
+      const EMLINK: number;
+      const EMSGSIZE: number;
+      const EMULTIHOP: number;
+      const ENAMETOOLONG: number;
+      const ENETDOWN: number;
+      const ENETRESET: number;
+      const ENETUNREACH: number;
+      const ENFILE: number;
+      const ENOBUFS: number;
+      const ENODATA: number;
+      const ENODEV: number;
+      const ENOENT: number;
+      const ENOEXEC: number;
+      const ENOLCK: number;
+      const ENOLINK: number;
+      const ENOMEM: number;
+      const ENOMSG: number;
+      const ENOPROTOOPT: number;
+      const ENOSPC: number;
+      const ENOSR: number;
+      const ENOSTR: number;
+      const ENOSYS: number;
+      const ENOTCONN: number;
+      const ENOTDIR: number;
+      const ENOTEMPTY: number;
+      const ENOTSOCK: number;
+      const ENOTSUP: number;
+      const ENOTTY: number;
+      const ENXIO: number;
+      const EOPNOTSUPP: number;
+      const EOVERFLOW: number;
+      const EPERM: number;
+      const EPIPE: number;
+      const EPROTO: number;
+      const EPROTONOSUPPORT: number;
+      const EPROTOTYPE: number;
+      const ERANGE: number;
+      const EROFS: number;
+      const ESPIPE: number;
+      const ESRCH: number;
+      const ESTALE: number;
+      const ETIME: number;
+      const ETIMEDOUT: number;
+      const ETXTBSY: number;
+      const EWOULDBLOCK: number;
+      const EXDEV: number;
+      const WSAEINTR: number;
+      const WSAEBADF: number;
+      const WSAEACCES: number;
+      const WSAEFAULT: number;
+      const WSAEINVAL: number;
+      const WSAEMFILE: number;
+      const WSAEWOULDBLOCK: number;
+      const WSAEINPROGRESS: number;
+      const WSAEALREADY: number;
+      const WSAENOTSOCK: number;
+      const WSAEDESTADDRREQ: number;
+      const WSAEMSGSIZE: number;
+      const WSAEPROTOTYPE: number;
+      const WSAENOPROTOOPT: number;
+      const WSAEPROTONOSUPPORT: number;
+      const WSAESOCKTNOSUPPORT: number;
+      const WSAEOPNOTSUPP: number;
+      const WSAEPFNOSUPPORT: number;
+      const WSAEAFNOSUPPORT: number;
+      const WSAEADDRINUSE: number;
+      const WSAEADDRNOTAVAIL: number;
+      const WSAENETDOWN: number;
+      const WSAENETUNREACH: number;
+      const WSAENETRESET: number;
+      const WSAECONNABORTED: number;
+      const WSAECONNRESET: number;
+      const WSAENOBUFS: number;
+      const WSAEISCONN: number;
+      const WSAENOTCONN: number;
+      const WSAESHUTDOWN: number;
+      const WSAETOOMANYREFS: number;
+      const WSAETIMEDOUT: number;
+      const WSAECONNREFUSED: number;
+      const WSAELOOP: number;
+      const WSAENAMETOOLONG: number;
+      const WSAEHOSTDOWN: number;
+      const WSAEHOSTUNREACH: number;
+      const WSAENOTEMPTY: number;
+      const WSAEPROCLIM: number;
+      const WSAEUSERS: number;
+      const WSAEDQUOT: number;
+      const WSAESTALE: number;
+      const WSAEREMOTE: number;
+      const WSASYSNOTREADY: number;
+      const WSAVERNOTSUPPORTED: number;
+      const WSANOTINITIALISED: number;
+      const WSAEDISCON: number;
+      const WSAENOMORE: number;
+      const WSAECANCELLED: number;
+      const WSAEINVALIDPROCTABLE: number;
+      const WSAEINVALIDPROVIDER: number;
+      const WSAEPROVIDERFAILEDINIT: number;
+      const WSASYSCALLFAILURE: number;
+      const WSASERVICE_NOT_FOUND: number;
+      const WSATYPE_NOT_FOUND: number;
+      const WSA_E_NO_MORE: number;
+      const WSA_E_CANCELLED: number;
+      const WSAEREFUSED: number;
+    }
+    namespace dlopen {
+      const RTLD_LAZY: number;
+      const RTLD_NOW: number;
+      const RTLD_GLOBAL: number;
+      const RTLD_LOCAL: number;
+      const RTLD_DEEPBIND: number;
+    }
+    namespace priority {
+      const PRIORITY_LOW: number;
+      const PRIORITY_BELOW_NORMAL: number;
+      const PRIORITY_NORMAL: number;
+      const PRIORITY_ABOVE_NORMAL: number;
+      const PRIORITY_HIGH: number;
+      const PRIORITY_HIGHEST: number;
+    }
+  }
 }
 declare module "node:os" {
   export * from "os";
@@ -1761,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;
@@ -1770,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";
@@ -1777,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,
@@ -1855,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,
@@ -1892,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;
@@ -1932,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;
@@ -2191,6 +2809,60 @@ declare module "util" {
     options?: { validateStream?: boolean; stream?: unknown },
   ): string;
   export function parseEnv(content: string): { [key: string]: string | undefined };
+  export function inherits(constructor: unknown, superConstructor: unknown): void;
+  export interface DeprecateOptions {
+    modifyPrototype?: boolean;
+  }
+  export function deprecate<T extends Function>(
+    fn: T,
+    msg: string,
+    code?: string,
+    options?: DeprecateOptions,
+  ): T;
+  /* The callback receives null on success and the rejection reason
+   * otherwise (falsy reasons arrive as ERR_FALSY_VALUE_REJECTION). */
+  export function callbackify(
+    fn: () => Promise<void>,
+  ): (callback: (err: NodeJS.ErrnoException | null) => void) => void;
+  export function callbackify<TResult>(
+    fn: () => Promise<TResult>,
+  ): (callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+  export function callbackify<T1>(
+    fn: (arg1: T1) => Promise<void>,
+  ): (arg1: T1, callback: (err: NodeJS.ErrnoException | null) => void) => void;
+  export function callbackify<T1, TResult>(
+    fn: (arg1: T1) => Promise<TResult>,
+  ): (arg1: T1, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+  export function callbackify<T1, T2>(
+    fn: (arg1: T1, arg2: T2) => Promise<void>,
+  ): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null) => void) => void;
+  export function callbackify<T1, T2, TResult>(
+    fn: (arg1: T1, arg2: T2) => Promise<TResult>,
+  ): (
+    arg1: T1,
+    arg2: T2,
+    callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+  ) => void;
+  export function callbackify<T1, T2, T3>(
+    fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>,
+  ): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null) => void) => void;
+  export function callbackify<T1, T2, T3, TResult>(
+    fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>,
+  ): (
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+  ) => void;
+  export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void;
+  export interface DebugLogger extends DebugLoggerFunction {
+    enabled: boolean;
+  }
+  export function debuglog(
+    section: string,
+    callback?: (fn: DebugLoggerFunction) => void,
+  ): DebugLogger;
+  export { debuglog as debug };
   export type TextEncoder = globalThis.TextEncoder;
   export type TextDecoder = globalThis.TextDecoder;
   export var TextEncoder: typeof globalThis.TextEncoder;
@@ -2580,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
@@ -2686,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;
@@ -2750,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;
@@ -2944,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. */
@@ -3181,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 };
@@ -4126,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";
@@ -4210,16 +4946,20 @@ declare module "events" {
   class EventEmitter {
     constructor();
     static defaultMaxListeners: number;
-    on(eventName: string, listener: (...args: any[]) => void): this;
-    addListener(eventName: string, listener: (...args: any[]) => void): this;
-    once(eventName: string, listener: (...args: any[]) => void): this;
-    prependListener(eventName: string, listener: (...args: any[]) => void): this;
-    prependOnceListener(eventName: string, listener: (...args: any[]) => void): this;
-    off(eventName: string, listener: (...args: any[]) => void): this;
-    removeListener(eventName: string, listener: (...args: any[]) => void): this;
-    removeAllListeners(eventName?: string): this;
-    emit(eventName: string, ...args: any[]): boolean;
-    listenerCount(eventName: string, listener?: (...args: any[]) => void): number;
+    /* Listeners registered under this symbol observe 'error' emits first
+     * (an emit with no 'error' listener still throws). */
+    static readonly errorMonitor: unique symbol;
+    static addAbortListener(signal: AbortSignal, listener: (event: Event) => void): Disposable;
+    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    removeAllListeners(eventName?: string | symbol): this;
+    emit(eventName: string | symbol, ...args: any[]): boolean;
+    listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
     /* Declared as zero-parameter closures so the RESULT is statically
      * consumable (.length, indexing, identity): the lowering only admits
      * these calls for events whose argument tuple is empty — a listener
@@ -4273,7 +5013,7 @@ declare module "stream" {
     emitClose?: boolean;
     captureRejections?: boolean;
     defaultEncoding?: string;
-    signal?: unknown;
+    signal?: AbortSignal;
   }
   interface WritableOptions {
     highWaterMark?: number;
@@ -4293,7 +5033,7 @@ declare module "stream" {
     autoDestroy?: boolean;
     emitClose?: boolean;
     captureRejections?: boolean;
-    signal?: unknown;
+    signal?: AbortSignal;
   }
   interface DuplexOptions {
     highWaterMark?: number;
@@ -4322,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;
@@ -4358,7 +5098,7 @@ declare module "stream" {
     readable?: boolean;
     writable?: boolean;
     defaultEncoding?: string;
-    signal?: unknown;
+    signal?: AbortSignal;
   }
 
   class Readable extends EventEmitter {
@@ -4602,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 {}
 
@@ -4621,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");
@@ -4636,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" {
@@ -4652,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>;