@scriptc/compiler 0.1.2 → 0.1.4

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

@@ -62,15 +62,14 @@ declare namespace NodeJS {
    * keeps the loop alive. */
   interface ReadableStream {
     on(event: "data", listener: (chunk: Buffer) => void): void;
+    on(event: "data", listener: (chunk: string) => void): void;
     on(event: "end", listener: () => void): void;
     once(event: "data", listener: (chunk: Buffer) => void): void;
+    once(event: "data", listener: (chunk: string) => void): void;
     once(event: "end", listener: () => void): void;
-    /* Declared surface without a lowering (chunks stay bytes; decode
-     * with TextDecoder) — string-mode consumers typecheck and fence at
-     * the reached site. With setEncoding in force Node hands strings to
-     * 'data', hence the string arm on the listener above being absent:
-     * the lowered surface is bytes-only. */
-    setEncoding(encoding: string): void;
+    /* setEncoding('utf8') makes subsequent data chunks strings, including
+     * multibyte sequences split across native pipe reads. */
+    setEncoding(encoding: string): this;
   }
 }
 
@@ -181,11 +180,13 @@ declare var process: {
    * 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;
   /* `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
-   * lowering already handles the optional code (bare exit() is exit(0),
-   * Node's behavior when exitCode was never set). */
+   * lowering already handles the optional code (bare exit() uses exitCode,
+   * or zero when it was never set). */
   exit(code?: number | null): never;
   cwd(): string;
   /* The user tick queue: callbacks run before promise jobs at every loop
@@ -280,8 +281,27 @@ declare var process: {
   /* emitWarning — Node's full grammar (string or Error warning; type/
    * ctor/options second; code/ctor third). */
   emitWarning(warning: string | Error, ...args: any[]): void;
+  /** Present in a child created by child_process.fork(). */
+  readonly connected: boolean;
+  send?(message: object, callback?: (error: Error | null) => void): boolean;
+  disconnect(): void;
+  on(event: "message", listener: (message: any) => void): void;
+  on(event: "disconnect", listener: () => void): void;
+  once(event: "message", listener: (message: any) => void): void;
+  once(event: "disconnect", listener: () => void): void;
 };
 
+/* Node's process module default export is the global process object. These
+ * declaration aliases let the ESM spelling typecheck against the same
+ * deliberately narrow fallback surface when @types/node is absent. */
+declare module "process" {
+  export = process;
+}
+declare module "node:process" {
+  import process = require("process");
+  export = process;
+}
+
 /* ── globals a real CLI's sources reference (all @types/node or dyn-lib
  * territory; the fallback declares the slice so projects PREFLIGHT and
  * every reached use lands on the SC2020 fence — or a real lowering where
@@ -463,6 +483,12 @@ interface Buffer<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends
   writeUIntLE(value: number, offset: number, byteLength: number): number;
   writeIntBE(value: number, offset: number, byteLength: number): number;
   writeIntLE(value: number, offset: number, byteLength: number): number;
+  writeBigInt64BE(value: bigint, offset?: number): number;
+  writeBigInt64LE(value: bigint, offset?: number): number;
+  writeBigUInt64BE(value: bigint, offset?: number): number;
+  writeBigUInt64LE(value: bigint, offset?: number): number;
+  writeBigUint64BE(value: bigint, offset?: number): number;
+  writeBigUint64LE(value: bigint, offset?: number): number;
   readUInt8(offset?: number): number;
   readUInt16BE(offset?: number): number;
   readUInt16LE(offset?: number): number;
@@ -481,6 +507,12 @@ interface Buffer<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends
   readUIntLE(offset: number, byteLength: number): number;
   readIntBE(offset: number, byteLength: number): number;
   readIntLE(offset: number, byteLength: number): number;
+  readBigInt64BE(offset?: number): bigint;
+  readBigInt64LE(offset?: number): bigint;
+  readBigUInt64BE(offset?: number): bigint;
+  readBigUInt64LE(offset?: number): bigint;
+  readBigUint64BE(offset?: number): bigint;
+  readBigUint64LE(offset?: number): bigint;
 }
 interface BufferConstructor {
   from(data: string, encoding?: BufferEncoding): Buffer;
@@ -747,6 +779,7 @@ interface Request {
   arrayBuffer(): Promise<ArrayBuffer>;
   bytes(): Promise<Uint8Array>;
 }
+type RequestInfo = string | URL | Request;
 interface RequestInit {
   method?: string;
   headers?:
@@ -759,7 +792,7 @@ interface RequestInit {
   signal?: AbortSignal;
 }
 declare var Request: {
-  new (input: string | URL | Request, init?: RequestInit): Request;
+  new (input: RequestInfo, init?: RequestInit): Request;
   readonly prototype: Request;
 };
 declare function fetch(input: string | URL, init?: RequestInit): Promise<Response>;
@@ -924,15 +957,19 @@ declare var performance: import("node:perf_hooks").Performance;
  * createRequire(import.meta.url) (or __filename) whose require calls
  * take STATIC string literals — the indirection erases at compile time.
  * A builtin spec makes the binding a namespace import in const clothing;
- * a relative .json document bakes and parses (JSON.parse's `unknown`
- * stance — validate with a checked cast); an installed npm package loads
- * through the island's require-condition entry under --dynamic; a bare
- * name nothing installed resolves compiles to Node's catchable
- * MODULE_NOT_FOUND throw (the optional-dependency try/require pattern).
+ * relative and package-import program modules use the compiled module
+ * graph; a relative .json document bakes and parses (JSON.parse's
+ * `unknown` stance — validate with a checked cast); an installed npm
+ * package loads through the island's require-condition entry under
+ * --dynamic, or through the compiled graph under --npm-static; a bare name
+ * nothing installed resolves compiles to Node's catchable MODULE_NOT_FOUND
+ * throw (the optional-dependency try/require pattern).
  * Dynamic specifiers fence: a compiled binary's module graph is fixed at
  * build time. builtinModules is the baked Node v24 list (a fresh
  * mutable array per read where Node ships one frozen singleton);
- * isBuiltin and syncBuiltinESMExports fence per site. Both spellings
+ * isBuiltin checks runtime strings against that pinned list, and
+ * syncBuiltinESMExports is a no-op because the static builtin surface is
+ * immutable. Both spellings
  * name the builtin, like in Node (the builtin wins over the npm package
  * named "module" for the bare specifier there too). */
 declare module "node:module" {
@@ -984,6 +1021,15 @@ declare module "node:fs" {
   export function readFileSync(fd: number): Buffer;
   /* The options-object spelling of the utf8 form. */
   export function readFileSync(path: string, options: { encoding: "utf8" | "utf-8" }): string;
+  /* Error-first callback target used by the static util.promisify
+   * projection. Its options stay unknown because direct calls remain
+   * outside the typed fs slice; this also lets checked-JS validation
+   * ladders observe invalid runtime encodings without contextual narrowing. */
+  export function readFile(
+    path: string,
+    options: unknown,
+    callback: (error: Error | null, data: string) => void,
+  ): void;
   /* The options form carries the mode (applied at CREATION only, like
    * Node — an existing file keeps its permissions) and/or the utf8
    * encoding spelling. */
@@ -1003,6 +1049,9 @@ declare module "node:fs" {
   export function mkdirSync(path: string, options: { recursive?: boolean; mode?: number }): void;
   export function unlinkSync(path: string): void;
   export function chmodSync(path: string, mode: number): void;
+  export function fchmodSync(fd: number, mode: number): void;
+  export function fsyncSync(fd: number): void;
+  export function linkSync(existingPath: string, newPath: string): void;
   export function chownSync(path: string, uid: number, gid: 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. */
@@ -1041,36 +1090,61 @@ declare module "node:fs" {
     readonly R_OK: number;
     readonly W_OK: number;
     readonly X_OK: number;
+    readonly O_RDONLY: number;
+    readonly O_WRONLY: number;
+    readonly O_RDWR: number;
+    readonly O_CREAT: number;
+    readonly O_EXCL: number;
+    readonly O_NOFOLLOW: number;
+    readonly O_NONBLOCK: number;
+    readonly O_TRUNC: number;
+    readonly O_APPEND: number;
   };
   /* A stat(2) snapshot (statSync follows symlinks, lstatSync does not —
    * Node's split) — immutable; the supported surface is exactly these
-   * members. blocks is the allocated size in 512-byte units; the time
-   * fields are milliseconds with their sub-second fractions. */
+   * members. dev/ino identify the filesystem entry, blocks is the allocated
+   * size in 512-byte units, and the time fields are milliseconds with their
+   * sub-second fractions. */
   export interface Stats {
     isFile(): boolean;
     isDirectory(): boolean;
     isSymbolicLink(): boolean;
+    readonly dev: number;
+    readonly ino: number;
     readonly size: number;
     readonly blocks: number;
     readonly nlink: number;
     readonly atimeMs: number;
     readonly mtimeMs: number;
+    readonly ctimeMs: number;
   }
   export function statSync(path: string): Stats;
   export function lstatSync(path: string): Stats;
   /* The fd pair behind spawn's fd-stdio form: openSync(path, flags) →
-   * the raw fd (string flags only — "r", "w", "a" and the +/x/s
-   * variants), closeSync(fd). */
+   * the raw fd. Numeric flags use an inline OR of the O_* constants. */
   export function openSync(path: string, flags: string): number;
+  export function openSync(path: string, flags: number, mode?: number): number;
   export function closeSync(fd: number): void;
   /* Read into a caller buffer from the fd's current position when position
    * is omitted/null, or from a numeric byte position without advancing the
    * fd. Answers the byte count, 0 at EOF. */
+  export interface ReadSyncOptions {
+    offset?: number;
+    length?: number;
+    position?: number | null;
+  }
+  export function readSync(fd: number, buffer: Uint8Array, options?: ReadSyncOptions): number;
   export function readSync(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number | null): number;
   /* Write a caller-buffer window, or a utf8 string, at the fd's current
    * position when position is omitted/null (advancing it), or at a numeric
    * byte position without advancing it. Answers the byte count. */
-  export function writeSync(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number | null): number;
+  export interface WriteSyncOptions {
+    offset?: number;
+    length?: number;
+    position?: number | null;
+  }
+  export function writeSync(fd: number, buffer: Uint8Array, options: WriteSyncOptions): number;
+  export function writeSync(fd: number, buffer: Uint8Array, offset?: number, length?: number, position?: number | null): number;
   export function writeSync(fd: number, string: string, position?: number | null, encoding?: "utf8" | "utf-8"): number;
   /* statSync over an open fd — the same Stats snapshot. */
   export function fstatSync(fd: number): Stats;
@@ -1175,8 +1249,19 @@ declare module "fs/promises" {
   export function writeFile(path: string, data: string, encoding: "utf8" | "utf-8"): Promise<void>;
   export function mkdir(path: string, options?: { recursive?: boolean; mode?: number }): Promise<void>;
   export function readdir(path: string): Promise<string[]>;
+  export function readdir(
+    path: string,
+    options: {
+      encoding?: "utf8" | "utf-8";
+      withFileTypes: true;
+      recursive?: boolean;
+      [option: string]: unknown;
+    },
+  ): Promise<import("node:fs").Dirent[]>;
   export function rm(path: string): Promise<void>;
   export function stat(path: string): Promise<import("node:fs").Stats>;
+  export function realpath(path: string): Promise<string>;
+  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 rename(oldPath: string, newPath: string): Promise<void>;
@@ -1305,7 +1390,7 @@ declare module "node:os" {
 /* The WHATWG URL class (a Node global; the es2023 lib doesn't declare it),
  * typed as exactly the supported surface: construction from ONE absolute-
  * URL string (invalid input throws a catchable TypeError, like Node), the
- * protocol/pathname/href/host/hostname/search getters, searchParams (the
+ * protocol/origin/username/pathname/href/host/hostname/port/search/hash getters, searchParams (the
  * LIVE query view — mutations through it re-serialize into the URL, so
  * href reflects immediately; every read answers the same object, Node's
  * caching), and toString() (the href serialization).
@@ -1317,16 +1402,21 @@ declare module "node:os" {
  * documented in SEMANTICS.md. */
 interface URL {
   readonly protocol: string;
+  readonly origin: string;
+  readonly username: string;
+  readonly password: string;
   readonly pathname: string;
   readonly href: string;
   readonly host: string;
   readonly hostname: string;
+  readonly port: string;
   readonly search: string;
+  readonly hash: string;
   readonly searchParams: URLSearchParams;
   toString(): string;
 }
 declare var URL: {
-  new (input: string): URL;
+  new (input: string, base?: string | URL): URL;
 };
 
 /* URLSearchParams — the WHATWG application/x-www-form-urlencoded list.
@@ -1366,23 +1456,31 @@ declare module "node:url" {
   export * from "url";
 }
 
-/* node:crypto: randomUUID(), and randomBytes returning a REAL Buffer —
- * the composed randomBytes(n).toString("hex" | "base64") still lowers as
- * one fused string-producing operation (the Buffer never materializes
- * there); every other use gets an ordinary Buffer value. */
+/* node:crypto: the static hashing/MAC/random/PBKDF2 utility slice. */
 declare module "crypto" {
   export function randomUUID(): string;
   export function randomBytes(size: number): Buffer;
-  /* The lowered Hash surface is exactly the COMPOSED chain
-   * createHash("sha256" | "sha1").update(data).digest("hex" | "base64")
-   * — fused into one call, the Hash handle never materializes (holding
-   * one fences). sha1 exists for the RFC 6455 Sec-WebSocket-Accept
-   * hash. */
   export interface Hash {
-    update(data: string | Uint8Array): Hash;
+    update(data: string | Uint8Array, inputEncoding?: "utf8" | "utf-8" | "hex" | "base64"): Hash;
+    digest(): Buffer;
+    digest(encoding: "hex" | "base64"): string;
+    copy(): Hash;
+  }
+  export interface Hmac {
+    update(data: string | Uint8Array, inputEncoding?: "utf8" | "utf-8" | "hex" | "base64"): Hmac;
+    digest(): Buffer;
     digest(encoding: "hex" | "base64"): string;
   }
   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"): string;
+  export function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;
+  export function randomFillSync<T extends Uint8Array>(buffer: T, offset?: number, size?: number): T;
+  export function randomInt(max: number): number;
+  export function randomInt(min: number, max: number): number;
+  export function pbkdf2Sync(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, digest: string): Buffer;
+  export function pbkdf2(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, digest: string, callback: (error: Error | null, derivedKey: Buffer) => void): void;
+  export function randomBytes(size: number, callback: (error: Error | null, buffer: Buffer) => void): void;
   /* The lowered X509Certificate surface is the data-record slice:
    * fingerprint (the SHA-1 of the DER, uppercase colon-separated) and
    * the validFrom/validTo validity window (Node's ASN1_TIME_print
@@ -1514,23 +1612,43 @@ declare module "child_process" {
   ): SpawnSyncReturns;
 
   /* The asynchronous slice: spawn with stdio "ignore"/"inherit"/fd/"pipe"
-   * tuples (piped stdout/stderr deliver through child.stdout/stderr) and
-   * the two terminal events. "exit" fires once with the exit code, or
+   * tuples (piped stdin is writable through child.stdin; piped stdout/stderr
+   * deliver through child.stdout/stderr) and the terminal events. "exit"
+   * fires once with the exit code, or
    * null when the child died to a signal; "error" fires ONLY when the
    * child could not be spawned at all (Node's split: a spawn failure
-   * emits "error" and never "exit"). Listeners take at most one
-   * parameter; Node's second "exit" parameter (the signal name) has no
-   * lowering. `on` returns void here (Node returns the child; chaining
-   * is fenced). The event loop keeps the process alive until every
-   * spawned child is reaped, like Node — reaping polls at loop
-   * quiescence (SEMANTICS.md documents the divergence). An "error"
+   * emits "error" and never "exit"). "close" fires after exit/error and
+   * every piped stdio handle reaches EOF. Exit/close listeners may take
+   * Node's code and signal parameters. `on`/`once` return void here (Node
+   * returns the child; chaining is fenced). The event loop keeps the process
+   * alive until every spawned child is reaped, like Node — reaping polls at
+   * loop quiescence (SEMANTICS.md documents the divergence). An "error"
    * event with no registered listener prints the error and exits 1,
    * exactly the unhandled-'error' EventEmitter behavior. */
+  export interface ChildStdin {
+    readonly writable: boolean;
+    write(chunk: string | Uint8Array): boolean;
+    end(): void;
+    destroy(): void;
+    on(event: "drain" | "finish", listener: () => void): void;
+    on(event: "error", listener: (err: Error) => void): void;
+    once(event: "drain" | "finish", listener: () => void): void;
+    once(event: "error", listener: (err: Error) => void): void;
+  }
+
   export interface ChildProcess extends Disposable {
     /* The exit listener may also take Node's second parameter — the
      * terminating signal's name, null for a normal exit. */
     on(event: "exit", listener: (code: number | null, signal: string | null) => void): void;
+    on(event: "close", listener: (code: number | null, signal: string | null) => void): void;
     on(event: "error", listener: (err: Error) => void): void;
+    once(event: "exit", listener: (code: number | null, signal: string | null) => void): void;
+    once(event: "close", listener: (code: number | null, signal: string | null) => void): void;
+    once(event: "error", listener: (err: Error) => void): void;
+    on(event: "message", listener: (message: any) => void): void;
+    on(event: "disconnect", listener: () => void): void;
+    once(event: "message", listener: (message: any) => void): void;
+    once(event: "disconnect", listener: () => void): void;
     /* The lifecycle members, Node's exact shapes: pid is undefined exactly
      * when the spawn failed; exitCode is null while running, the code
      * after a normal exit, null for a signal death, and -errno once a
@@ -1546,9 +1664,13 @@ declare module "child_process" {
     readonly killed: boolean;
     kill(signal?: string | number): boolean;
     unref(): void;
+    readonly connected: boolean;
+    send(message: object, callback?: (error: Error | null) => void): boolean;
+    disconnect(): void;
     [Symbol.dispose](): void;
-    /* The piped-output streams — non-null exactly when the matching
-     * stdio slot was "pipe" (Node's shape). */
+    /* The piped streams — non-null exactly when the matching stdio slot
+     * was "pipe" (Node's shape). */
+    readonly stdin: ChildStdin | null;
     readonly stdout: NodeJS.ReadableStream | null;
     readonly stderr: NodeJS.ReadableStream | null;
   }
@@ -1559,15 +1681,32 @@ declare module "child_process" {
       /* The 3-tuple form admits number fds in the stdout/stderr slots —
        * openSync results dup2'd into the child (the daemon-log idiom
        * ["ignore", logFd, logFd]) — and "pipe" there too (child.stdout/
-       * child.stderr streams); piped STDIN stays a compile fence. */
+       * child.stderr streams); "pipe" in the stdin slot exposes
+       * child.stdin. */
       stdio: "ignore" | "inherit" | "pipe" | ("ignore" | "inherit" | "pipe" | number)[];
       /* detached gives the child its own session and process group
        * (POSIX_SPAWN_SETSID); env REPLACES the child environment; cwd
-       * sets its working directory; windowsHide is a POSIX no-op. */
+       * sets its working directory; windowsHide is a POSIX no-op; shell
+       * runs the complete command string through /bin/sh or cmd.exe. */
       detached?: boolean;
       env?: { [k: string]: string | undefined };
       cwd?: string;
       windowsHide?: boolean;
+      shell?: boolean;
+    },
+  ): ChildProcess;
+
+  export function fork(
+    modulePath: string | URL,
+    args?: string[],
+    options?: {
+      cwd?: string;
+      env?: { [k: string]: string | undefined };
+      execArgv?: string[];
+      silent?: boolean;
+      stdio?: "pipe" | "ignore" | "inherit" | ("pipe" | "ignore" | "inherit" | "ipc")[];
+      serialization?: "json" | "advanced";
+      windowsHide?: boolean;
     },
   ): ChildProcess;
 
@@ -1612,9 +1751,13 @@ declare module "child_process" {
   }
   export function execFileSync(file: string, args?: string[], options?: ExecSyncOptions): string;
   export function execSync(command: string, options?: ExecSyncOptions): string;
-  /* The callback form exists to be PROMISIFIED — `const execFileAsync =
-   * promisify(execFile)` is the one lowered use (see "util"); calling it
-   * directly with a callback has no lowering and fences per site. */
+  export type ExecFileCallback = (error: Error | null, stdout: string, stderr: string) => void;
+  /* The callback form starts an asynchronous child and captures utf8
+   * stdout/stderr. The no-callback overload remains for util.promisify's
+   * static target recognition; reached no-callback calls still fence. */
+  export function execFile(file: string, callback: ExecFileCallback): ChildProcess;
+  export function execFile(file: string, args: string[] | null, callback: ExecFileCallback): ChildProcess;
+  export function execFile(file: string, args: string[] | null, options: ExecSyncOptions, callback: ExecFileCallback): ChildProcess;
   export function execFile(
     file: string,
     args?: string[] | null,
@@ -1633,13 +1776,14 @@ declare module "node:child_process" {
   export * from "child_process";
 }
 
-/* node:util — promisify, for exactly ONE target: child_process.execFile.
- * `const execFileAsync = promisify(execFile)` binds an async exec whose
- * calls run the file (no shell, PATH-searched) and settle with
- * { stdout, stderr } — fulfilled on exit 0, rejected with Node's
- * Command-failed / spawn-ENOENT errors otherwise. Other promisify
- * targets and bare promisify values fence per site. */
+/* 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
+ * promisify values fence per site. */
 declare module "util" {
+  export function promisify(
+    fn: typeof import("node:fs").readFile,
+  ): (path: string, encoding: "utf8" | "utf-8") => Promise<string>;
   export function promisify(
     fn: (file: string, args?: string[] | null, options?: object) => unknown,
   ): (
@@ -1736,9 +1880,10 @@ declare module "node:util/types" {
  * Object.is over scalars; deepStrictEqual compares composites
  * structurally per their static types. The messages here are plain
  * strings (Node accepts Errors — that form fences per site), and the
- * loose-equality quartet (equal/notEqual/deepEqual/notDeepEqual) is
- * declared so real code typechecks but fences at its use sites (== has
- * no lowering; assert/strict's equal IS strictEqual and lowers). */
+ * shallow legacy pair (equal/notEqual) follows Node's == coercions for
+ * primitive and primitive-union operands, including Node v24's NaN
+ * exception. deepEqual/notDeepEqual remain declared-but-fenced;
+ * assert/strict's loose names alias the strict forms and lower. */
 /* node:test — the in-process test runner (prefix-only in Node too:
  * require("test") is MODULE_NOT_FOUND). test/it register tests (sync and
  * async bodies, skip/todo/only options and method twins), describe/suite
@@ -1978,14 +2123,38 @@ declare module "node:readline" {
   export * from "readline";
 }
 
-/* node:zlib — deflateSync/inflateSync lower (Buffer in, Buffer out,
- * Node's default options; libz links only into zlib-using binaries);
- * gzip and friends typecheck and fence at their use sites. */
+/* node:zlib — the one-shot zlib/raw/gzip codecs lower for string/Buffer
+ * inputs with Node's default options; libz links only into zlib-using
+ * binaries. Callback forms use the executable worker pool. Options stay
+ * declared so reached uses receive a named SC2020 refusal; Brotli,
+ * streaming, and Zstd remain outside the lowered surface. */
 declare module "zlib" {
-  export function deflateSync(data: string | Uint8Array): Buffer;
-  export function inflateSync(data: Uint8Array): Buffer;
-  export function gzipSync(data: string | Uint8Array): Buffer;
-  export function gunzipSync(data: Uint8Array): Buffer;
+  export interface ZlibOptions { [option: string]: unknown }
+  export type ZlibCallback = (error: NodeJS.ErrnoException | null, result: Buffer) => void;
+  export function deflate(data: string | Uint8Array, callback: ZlibCallback): void;
+  export function deflate(data: string | Uint8Array, options: ZlibOptions, callback: ZlibCallback): void;
+  export function deflateSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
+  export function inflate(data: string | Uint8Array, callback: ZlibCallback): void;
+  export function inflate(data: string | Uint8Array, options: ZlibOptions, callback: ZlibCallback): void;
+  export function inflateSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
+  export function deflateRaw(data: string | Uint8Array, callback: ZlibCallback): void;
+  export function deflateRaw(data: string | Uint8Array, options: ZlibOptions, callback: ZlibCallback): void;
+  export function deflateRawSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
+  export function inflateRaw(data: string | Uint8Array, callback: ZlibCallback): void;
+  export function inflateRaw(data: string | Uint8Array, options: ZlibOptions, callback: ZlibCallback): void;
+  export function inflateRawSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
+  export function gzip(data: string | Uint8Array, callback: ZlibCallback): void;
+  export function gzip(data: string | Uint8Array, options: ZlibOptions, callback: ZlibCallback): void;
+  export function gzipSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
+  export function gunzip(data: string | Uint8Array, callback: ZlibCallback): void;
+  export function gunzip(data: string | Uint8Array, options: ZlibOptions, callback: ZlibCallback): void;
+  export function gunzipSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
+  export function unzip(data: string | Uint8Array, callback: ZlibCallback): void;
+  export function unzip(data: string | Uint8Array, options: ZlibOptions, callback: ZlibCallback): void;
+  export function unzipSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
+  export function crc32(data: string | Uint8Array, value?: number): number;
+  export function brotliCompressSync(data: string | Uint8Array): Buffer;
+  export function brotliDecompressSync(data: Uint8Array): Buffer;
 }
 declare module "node:zlib" {
   export * from "zlib";
@@ -2191,7 +2360,11 @@ declare module "http" {
     readonly statusMessage: string | undefined;
     readonly socket: Socket;
     readonly headers: { [name: string]: string | undefined };
+    readonly headersDistinct: { [name: string]: string[] | undefined };
     readonly rawHeaders: string[];
+    readonly trailers: { [name: string]: string | undefined };
+    readonly trailersDistinct: { [name: string]: string[] | undefined };
+    readonly rawTrailers: string[];
     resume(): void;
     destroy(): void;
     /* setEncoding('utf8'): 'data' delivers strings (other real encodings
@@ -2213,6 +2386,7 @@ declare module "http" {
   }
   export interface ServerResponse {
     readonly headersSent: boolean;
+    readonly writableCorked: number;
     /* Node's writable head properties: the implicit head reads them. */
     statusCode: number;
     statusMessage: string;
@@ -2225,6 +2399,10 @@ declare module "http" {
     writeHead(statusCode: number, headers?: OutgoingHttpHeaders | string[]): ServerResponse;
     writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders | string[]): ServerResponse;
     write(data: string | Uint8Array): void;
+    flushHeaders(): void;
+    cork(): void;
+    uncork(): void;
+    addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void;
     /* end's callback forms fire once the body went out (the 'finish'
      * emit, deferred past the handler's synchronous tail). */
     end(data?: string | Uint8Array, callback?: () => void): void;
@@ -2300,6 +2478,11 @@ declare module "http" {
   export const globalAgent: Agent;
   export interface ClientRequest {
     readonly destroyed: boolean;
+    readonly writableCorked: number;
+    flushHeaders(): void;
+    addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void;
+    cork(): void;
+    uncork(): void;
     write(data: string | Uint8Array): void;
     end(data?: string | Uint8Array): void;
     destroy(): void;
@@ -2517,6 +2700,7 @@ declare module "http2" {
   }
   export interface Http2ServerResponse {
     readonly headersSent: boolean;
+    readonly writableCorked: number;
     /* The same lowered surface as http.ServerResponse — the allowHTTP1
      * lowering serves every connection as HTTP/1.1, where the compat
      * response IS this parser's response handle. */
@@ -2529,6 +2713,10 @@ declare module "http2" {
     writeHead(statusCode: number, headers?: import("http").OutgoingHttpHeaders | string[]): Http2ServerResponse;
     writeHead(statusCode: number, statusMessage: string, headers?: import("http").OutgoingHttpHeaders | string[]): Http2ServerResponse;
     write(data: string | Uint8Array): void;
+    flushHeaders(): void;
+    cork(): void;
+    uncork(): void;
+    addTrailers(headers: import("http").OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void;
     end(data?: string | Uint8Array, callback?: () => void): void;
     end(callback: () => void): void;
     destroy(): void;
@@ -3117,8 +3305,14 @@ declare module "node:cluster" {
   export = cluster;
 }
 
-/* node:tty — the fd probe (the same isatty(3) behind process.*.isTTY). */
+/* node:tty — the fd probe (the same isatty(3) behind process.*.isTTY)
+ * and the supported structural view of a process output stream. */
 declare module "tty" {
+  export interface WriteStream {
+    write(data: string | Uint8Array, callback?: (error?: Error | null) => void): boolean;
+    write(data: string | Uint8Array, encoding: BufferEncoding, callback?: (error?: Error | null) => void): boolean;
+    readonly isTTY: boolean;
+  }
   export function isatty(fd: number): boolean;
 }
 declare module "node:tty" {

package/dist/backend/c/async.d.ts

@@ -59,6 +59,15 @@ export declare function dnsLookupThunkFor(emitter: CEmitter, cbT: IrType): strin
  * ScrError (or NULL); the adapter builds the callback's program-specific
  * Error | null union, or a dyn error/null for checkJs callbacks. */
 export declare function fsRenameThunkFor(emitter: CEmitter, cbT: IrType): string;
+/** Callback adapter for randomBytes/pbkdf2. The runtime transfers one
+ * owned Buffer; the adapter materializes the callback's Error | null (or
+ * checked-dynamic null) first argument and either transfers or boxes the
+ * Buffer according to the program-specific callback signature. */
+export declare function cryptoBytesThunkFor(emitter: CEmitter, cbT: IrType): string;
+/** Error-first Buffer callback adapter for worker-backed zlib operations.
+ * The runtime transfers the success Buffer and borrows the failure Error;
+ * exactly one is non-NULL. */
+export declare function zlibBytesThunkFor(emitter: CEmitter, cbT: IrType): string;
 /** Interned CONNECT-listener adapter for a UNION socket slot — the h2
    * compat listener (`(req, resOrSocket: Http2ServerResponse | net.Socket)
    * => void`): the runtime fires (cb, req, sock, head) like an upgrade;
@@ -117,6 +126,27 @@ export declare function resolveThunkFor(emitter: CEmitter, inner: IrType): strin
  * (the callee owns +1 per the universal convention; f64/bool copy), and
  * calls cb->fn behind its exact C signature. Interned per func-type key. */
 export declare function emitterInvokeThunkFor(emitter: CEmitter, cbT: IrType): string;
+/** child_process.execFile's error-first callback adapter. The runtime owns
+ * one +1 callback plus +1 error/output values at settlement; the adapter
+ * wraps the nullable error with this program's union tags, transfers every
+ * declared argument into the compiled closure, and releases ignored suffix
+ * values for callbacks that declare fewer than three parameters. */
+export declare function execFileThunkFor(emitter: CEmitter, cbT: IrType & {
+    kind: "func";
+}): string;
+/** Fork IPC message adapter: parse results arrive as a borrowed dyn tree,
+ * then validate into the listener's static JSON shape. Async listener
+ * promises are deliberately released without attaching a handler, matching
+ * EventEmitter's ignored return value. */
+export declare function ipcMessageThunkFor(emitter: CEmitter, cbT: IrType & {
+    kind: "func";
+}): string;
+/** Fork IPC send completion adapter. The nullable +1 runtime Error moves
+ * into the callback's Error|null union, or is released for a zero-argument
+ * callback. */
+export declare function ipcSendThunkFor(emitter: CEmitter, cbT: IrType & {
+    kind: "func";
+}): string;
 /** The stream-'data' listener invoke adapter for one listener func type:
  * the runtime's 'data' emission carries BOTH payload slots (ScrBytes *b,
  * ScrStr *s — exactly one non-NULL; encoded streams deliver strings),