@volter/tabnode 0.4.1 → 0.5.1

package/dist/native-stream-binding.d.ts

@@ -0,0 +1,57 @@
+/** Worker-side libuv delegation. The capability channel never becomes a handle property. */
+import type { NativeStreamDescriptor, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport } from './native-stream-owner';
+import type { TCP } from './node-lib/binding/tcp_wrap';
+import type { Pipe } from './node-lib/binding/pipe_wrap';
+import { LibuvStreamWrap, type WriteWrap } from './node-lib/binding/stream_wrap';
+type Stream = TCP | Pipe;
+export declare function registerNativeStreamConstructor(kind: 'tcp' | 'pipe', constructor: new (type: number) => Stream): void;
+/** Host bootstrap only, before any TCP/Pipe exists in this process realm. */
+export declare function installNativeStreamTransport(next: NativeStreamTransport): void;
+export declare function nativeStreamFor(handle: LibuvStreamWrap): NativeStreamDriver | undefined;
+/** Inherited descriptors live with the owner, not in this realm's JS fd table. */
+export declare function nativeInheritedFdType(fd: number): 'TCP' | 'PIPE' | undefined;
+/** Trusted process admission uses this ID for explicit descriptor inheritance. */
+export declare function nativeStreamDescriptor(handle: LibuvStreamWrap): NativeStreamDescriptor | undefined;
+export declare function attachNativeStream(handle: Stream, kind: 'tcp' | 'pipe', type: number, closeLocal: (callback?: () => void) => void, flushLocal: () => void): void;
+export declare class NativeStreamDriver {
+    private readonly handle;
+    readonly descriptor: NativeStreamDescriptor;
+    private readonly channel;
+    private readonly closeLocal;
+    private readonly flushLocal;
+    private readingCredit;
+    private buffered;
+    private readEnded;
+    private closing;
+    private readonly completions;
+    private readonly writes;
+    private readonly closeCallbacks;
+    private endpoint;
+    private pumping;
+    private releaseClose;
+    private writeEnded;
+    private pendingShutdown;
+    constructor(handle: Stream, descriptor: NativeStreamDescriptor, channel: NativeStreamTransport, closeLocal: (callback?: () => void) => void, flushLocal: () => void);
+    get peer(): LibuvStreamWrap | null;
+    pair(other: NativeStreamDriver): void;
+    call(operation: NativeStreamOperation): NativeStreamReply;
+    operation(operation: 'readStop' | 'ref' | 'unref'): number;
+    beginRead(): number;
+    readFlushed(empty: boolean, ended: boolean): void;
+    complete(operation: NativeStreamOperation, callback: (status: number) => void): number;
+    connect(address: string, port: number | undefined, ipv6: boolean, callback: (status: number) => void): number;
+    shutdown(callback: (status: number) => void): number;
+    duplicate(): Stream;
+    write(request: WriteWrap, parts: Uint8Array[], sent?: unknown): number;
+    private pumpWrites;
+    private flushShutdown;
+    private writeNext;
+    private finishWrite;
+    close(callback?: () => void, reset?: boolean): number;
+    private finishClose;
+    receive(event: Exclude<NativeStreamEvent, {
+        type: 'closed';
+    }>): void;
+    ownerStopped(): void;
+}
+export {};

package/dist/native-stream-owner.d.ts

@@ -0,0 +1,121 @@
+/** Host-owned native handles. Node's JS socket and IPC libraries stay in the guest. */
+import { type SockName } from './node-lib/binding/tcp_wrap';
+export interface NativeStreamDescriptor {
+    id: number;
+    kind: 'tcp' | 'pipe';
+    type: number;
+}
+export interface NativeStreamLimits {
+    maxHandles: number;
+    maxReadChunkBytes: number;
+    maxQueuedBytes: number;
+    /** Per connection, like maxQueuedBytes; includes unread IPC descriptor copies. */
+    maxQueuedHandles: number;
+    maxPendingWriteBytes: number;
+}
+export type NativeStreamEvent = {
+    type: 'closed';
+} | {
+    type: 'read';
+    id: number;
+    status: number;
+    bytes?: Uint8Array;
+    handle?: NativeStreamDescriptor;
+} | {
+    type: 'connection';
+    id: number;
+    status: number;
+    handle?: NativeStreamDescriptor;
+} | {
+    type: 'connect' | 'shutdown' | 'close';
+    id: number;
+    request: number;
+    status: number;
+};
+export type NativeStreamOperation = {
+    operation: 'create';
+    kind: 'tcp' | 'pipe';
+    type: number;
+} | {
+    operation: 'fdType';
+    fd: number;
+} | {
+    operation: 'pair';
+    id: number;
+    peer: number;
+} | {
+    operation: 'duplicate';
+    id: number;
+} | {
+    operation: 'bind';
+    id: number;
+    address: string;
+    port?: number;
+    ipv6?: boolean;
+    flags?: number;
+} | {
+    operation: 'listen';
+    id: number;
+    backlog: number;
+} | {
+    operation: 'connect';
+    id: number;
+    request: number;
+    address: string;
+    port?: number;
+    ipv6?: boolean;
+} | {
+    operation: 'open';
+    id: number;
+    fd: number;
+} | {
+    operation: 'readStart' | 'readStop' | 'ref' | 'unref' | 'getsockname' | 'getpeername';
+    id: number;
+} | {
+    operation: 'shutdown' | 'close' | 'reset';
+    id: number;
+    request: number;
+};
+export interface NativeStreamReply {
+    status: number;
+    handle?: NativeStreamDescriptor;
+    handleType?: 'TCP' | 'PIPE';
+    address?: Partial<SockName>;
+}
+export interface NativeStreamTransport {
+    readonly limits: Readonly<NativeStreamLimits>;
+    call(operation: NativeStreamOperation): NativeStreamReply;
+    write(id: number, bytes: Uint8Array, handle?: number): Promise<number>;
+    onEvent(listener: (event: NativeStreamEvent) => void): () => void;
+}
+/**
+ * One capability namespace per worker. Only the trusted host can inherit a
+ * descriptor from another scope; wire operations can name this scope's IDs only.
+ */
+export declare class NativeStreamScope {
+    private readonly emit;
+    private readonly entries;
+    private readonly descriptors;
+    private readonly writes;
+    private readonly connects;
+    private nextId;
+    private pendingWriteBytes;
+    private disposed;
+    private readonly limits;
+    constructor(limits: NativeStreamLimits, emit: (event: NativeStreamEvent) => void);
+    private entry;
+    private publish;
+    private claim;
+    /** Synchronous operations return libuv status; completions use the event door. */
+    call(operation: NativeStreamOperation): NativeStreamReply;
+    /**
+     * Transport chunks are bounded and serialized per handle. Waiting for native
+     * receive capacity retains at most one chunk per writer, within the scope's
+     * explicit aggregate ceiling. No polling or copying a whole guest write.
+     */
+    write(id: number, bytes: Uint8Array, sentId?: number): Promise<number>;
+    /** Trusted parent-to-child inheritance; this is deliberately absent from call(). */
+    inherit(fd: number, source: NativeStreamScope, id: number): NativeStreamReply;
+    private close;
+    dispose(): void;
+}

package/dist/node-lib/binding/duplex_stream.d.ts

@@ -0,0 +1,26 @@
+/** A Node Duplex as a libuv stream handle. Node still owns both socket APIs. */
+import { LibuvStreamWrap, type WriteWrap, type ShutdownWrap } from './stream_wrap';
+interface DuplexTransport {
+    write(chunk: Uint8Array, callback: (error?: Error | null) => void): boolean;
+    end(callback: () => void): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    on(event: string, listener: (...args: any[]) => void): void;
+}
+/** No listener or network address is allocated for this internal connection. */
+export declare class DuplexStreamHandle extends LibuvStreamWrap {
+    private readonly transport;
+    private pendingWrite?;
+    constructor(transport: DuplexTransport);
+    readStop(): number;
+    protected flushInbound(): void;
+    protected dispatchWrite(req: WriteWrap, buffer: Uint8Array): number;
+    shutdown(req: ShutdownWrap): number;
+    protected onCloseHandle(): void;
+    getsockname(): number;
+    getpeername(): number;
+    setNoDelay(): number;
+    setKeepAlive(): number;
+}
+export {};

package/dist/node-lib/binding/fds.d.ts

@@ -15,10 +15,18 @@
 import type { ProcessToken } from '../../process-tokens';
 /** What libuv answers for a descriptor. */
 export type HandleType = 'TCP' | 'TTY' | 'UDP' | 'FILE' | 'PIPE' | 'UNKNOWN';
+/** Files and streams occupy one descriptor namespace, as on the OS. */
+export declare function allocateFd(): number;
 /** Record a descriptor a run is started with, under that run's name. */
 export declare function registerRunFd(token: ProcessToken, fd: number, type: HandleType, handle: unknown): void;
 /** A run that has ended was started with nothing. */
 export declare function releaseRunFds(token: ProcessToken): void;
+/** Trusted process admission reads copies of this run's descriptor entries. */
+export declare function inheritedRunFds(token: ProcessToken): Array<{
+    fd: number;
+    type: HandleType;
+    handle: unknown;
+}>;
 /** Record a handle under a descriptor of the engine's own, and answer the number. */
 export declare function registerFd(type: HandleType, handle: unknown): number;
 /** The handle a descriptor names, for `Pipe.open(fd)` and `TCP.open(fd)`. */

package/dist/node-lib/binding/fs.d.ts

@@ -1,4 +1,5 @@
 import type { VirtualFS } from '../../virtual-fs';
+import { Buffer as NodeBuffer } from '../buffer-module';
 /** The key the engine hangs a run's filesystem off its guest process. */
 export declare const kRunFilesystem: unique symbol;
 export declare function withFilesystem<T>(tree: VirtualFS, work: () => T): T;
@@ -7,89 +8,236 @@ interface FSReq {
     oncomplete?: (error: Error | null, ...rest: unknown[]) => void;
 }
 /**
- * The request object `fs.js` makes for every asynchronous call and hangs its
- * callback off. Node's is a C++ handle the event loop owns; here it carries
- * the callback and nothing else, because `answer` above is the whole of what
- * makes a call asynchronous in a realm with one thread.
+ * A name the binding answers, in the encoding Node handed. `fs.rm` recursive
+ * (rimraf) readdir's with encoding `buffer` and `Buffer.concat`s each child
+ * onto the path; a string child threw `list[1]`/`list[2]` must be a Buffer,
+ * received `'exthost1'`.
  */
-export declare class FSReqCallback {
-    bigint: boolean;
-    oncomplete: ((error: Error | null, ...rest: unknown[]) => void) | undefined;
-    context: unknown;
-    constructor(bigint?: boolean);
-}
-/** The symbol `fs.promises` passes where a callback would go. */
-export declare const kUsePromises: unique symbol;
-/**
- * `internalBinding('fs_dir')`'s handle: an open directory, read a batch at a
- * time. Node's own `Dir` and `Dirent` are built on it; what a handle owes is
- * a flat list of name and type, and `null` when there is nothing left.
- */
-export declare class DirHandle {
-    #private;
-    constructor(path: string, encoding?: unknown);
-    read(encoding?: string, bufferSize?: number, req?: FSReq): unknown;
-    close(req?: FSReq): undefined;
-}
-export declare const fsDirBinding: {
-    opendirSync(path: unknown, encoding?: unknown): DirHandle;
-    opendir(path: unknown, encoding: string, req?: FSReq): DirHandle | undefined;
-};
-/**
- * `internalBinding('fs_event_wrap')`'s `FSEvent`: what `fs.watch` is. The
- * engine's tree reports its own changes, and this is the shape Node's
- * `FSWatcher` expects around them -- a start that takes a path and answers
- * an errno, a close, and `onchange(status, event, filename)`.
- */
-export declare class FSEvent {
-    #private;
-    onchange: ((status: number, event: string, filename: string) => void) | null;
-    initialized: boolean;
-    start(path: unknown, persistent?: boolean, recursive?: boolean, _encoding?: string): number;
-    close(): void;
-    ref(): void;
-    unref(): void;
-    getAsyncId(): number;
-    hasRef(): boolean;
-}
-/**
- * `StatWatcher`: what `fs.watchFile` is. It polls, as libuv's does, and the
- * interval is the one the program asked for.
- */
-export declare class StatWatcher {
-    #private;
-    bigint: boolean;
-    onchange: ((current: Float64Array | BigInt64Array, previous: Float64Array | BigInt64Array) => void) | null;
-    constructor(bigint?: boolean);
-    start(path: unknown, interval?: number): number;
-    stop(): void;
-    close(): void;
-    ref(): void;
-    unref(): void;
-    getAsyncId(): number;
-    hasRef(): boolean;
-}
-export declare const fsEventWrapBinding: {
-    FSEvent: typeof FSEvent;
+export declare function createFsBindings(Bytes?: () => typeof NodeBuffer): {
+    fsBinding: {
+        FSReqCallback: {
+            new (bigint?: boolean): {
+                oncomplete: ((error: Error | null, ...rest: unknown[]) => void) | undefined;
+                context: unknown;
+                bigint: boolean;
+            };
+        };
+        kUsePromises: symbol;
+        StatWatcher: {
+            new (bigint?: boolean): {
+                onchange: ((current: Float64Array | BigInt64Array, previous: Float64Array | BigInt64Array) => void) | null;
+                "__#private@#timer": ReturnType<typeof setInterval> | null;
+                "__#private@#previous": Float64Array | BigInt64Array | null;
+                bigint: boolean;
+                start(path: unknown, interval?: number): number;
+                stop(): void;
+                close(): void;
+                ref(): void;
+                unref(): void;
+                getAsyncId(): number;
+                hasRef(): boolean;
+            };
+        };
+        /** `fs.promises.open`: the same open, answered as a promise with a handle. */
+        openFileHandle(path: unknown, flags: number, mode: number, usePromises?: unknown): Promise<{
+            fd: number;
+            close(): Promise<void>;
+            release(): void;
+            getAsyncId(): number;
+        }> | {
+            fd: number;
+            close(): Promise<void>;
+            release(): void;
+            getAsyncId(): number;
+        };
+        open(path: unknown, flags: number, _mode: number, req?: FSReq): number | undefined;
+        close(fd: number, req?: FSReq): undefined;
+        read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number, req?: FSReq): number | undefined;
+        readBuffers(fd: number, buffers: Uint8Array[], position: number, req?: FSReq): number | undefined;
+        /** Node's fast path for `readFile` with an encoding it can decode itself. */
+        readFileUtf8(path: unknown, flags: number): string;
+        writeBuffer(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, req?: FSReq): number | undefined;
+        writeBuffers(fd: number, buffers: Uint8Array[], position: number | null, req?: FSReq): number | undefined;
+        writeString(fd: number, value: string, position: number | null, encoding: string | undefined, req?: FSReq): number | undefined;
+        writeFileUtf8(path: unknown, data: string, flags: number, mode: number): undefined;
+        stat(path: unknown, bigint: boolean, req?: FSReq, throwIfNoEntry?: boolean): Float64Array | BigInt64Array | undefined;
+        lstat(path: unknown, bigint: boolean, req?: FSReq, throwIfNoEntry?: boolean): Float64Array | BigInt64Array | undefined;
+        fstat(fd: number, bigint: boolean, req?: FSReq): Float64Array | BigInt64Array | undefined;
+        /**
+         * `statfs`: a tab's filesystem is the page's memory, and it has no device
+         * of its own. The numbers are a filesystem's shape rather than a lie about
+         * a disk: a block size, and a count no program can exhaust.
+         */
+        statfs(_path: unknown, bigint: boolean, req?: FSReq): Float64Array | BigInt64Array | undefined;
+        access(path: unknown, mode: number, req?: FSReq): undefined;
+        existsSync(path: unknown): boolean;
+        /**
+         * Node's `cpSync` asks this before it copies: a directory is not a file,
+         * and without `recursive` the copy of one is `ERR_FS_EISDIR`.
+         */
+        cpSyncCheckPaths(src: unknown, dest: unknown, dereference: boolean, recursive: boolean): undefined;
+        /** Node's C++ `cp` of a file onto an existing dest. */
+        cpSyncOverrideFile(src: unknown, dest: unknown, _mode: number, _preserveTimestamps: boolean): undefined;
+        /** Node's C++ recursive directory copy, without a JS filter. */
+        cpSyncCopyDir(src: unknown, dest: unknown, force: boolean, dereference: boolean, errorOnExist: boolean, _verbatimSymlinks: boolean, _preserveTimestamps: boolean): undefined;
+        /**
+         * What the module loader asks of a path before it reads it: 0 for a file,
+         * 1 for a directory, and a negative errno for neither.
+         *
+         * Node has called this with a receiver in front of the path and without
+         * one across versions; the three vendored call sites here -- `fs.js`'s
+         * `glob` twice and `internal/fs/promises.js`'s once -- pass the path alone,
+         * so the path is whichever argument is one.
+         */
+        internalModuleStat(receiver: unknown, path?: unknown): number;
+        readdir(path: unknown, encoding: string, withFileTypes: boolean, req?: FSReq): unknown;
+        mkdir(path: unknown, mode: number, recursive: boolean, req?: FSReq): string | undefined;
+        rmdir(path: unknown, req?: FSReq): undefined;
+        unlink(path: unknown, req?: FSReq): undefined;
+        rename(from: unknown, to: unknown, req?: FSReq): undefined;
+        copyFile(from: unknown, to: unknown, mode: number, req?: FSReq): undefined;
+        link(from: unknown, to: unknown, req?: FSReq): undefined;
+        symlink(target: unknown, path: unknown, _type: unknown, req?: FSReq): undefined;
+        readlink(path: unknown, encoding: string, req?: FSReq): string | Uint8Array | undefined;
+        realpath(path: unknown, encoding: string, req?: FSReq): string | Uint8Array | undefined;
+        mkdtemp(prefix: unknown, encoding: string, req?: FSReq): string | Uint8Array | undefined;
+        chmod(path: unknown, mode: number, req?: FSReq): undefined;
+        fchmod(fd: number, mode: number, req?: FSReq): undefined;
+        chown(_path: unknown, _uid: number, _gid: number, req?: FSReq): undefined;
+        fchown(_fd: number, _uid: number, _gid: number, req?: FSReq): undefined;
+        lchown(_path: unknown, _uid: number, _gid: number, req?: FSReq): undefined;
+        utimes(path: unknown, atime: number, mtime: number, req?: FSReq): undefined;
+        futimes(fd: number, atime: number, mtime: number, req?: FSReq): undefined;
+        lutimes(path: unknown, atime: number, mtime: number, req?: FSReq): undefined;
+        fsync(_fd: number, req?: FSReq): undefined;
+        fdatasync(_fd: number, req?: FSReq): undefined;
+        ftruncate(fd: number, length: number, req?: FSReq): undefined;
+    };
+    fsDirBinding: {
+        opendirSync(path: unknown, encoding?: unknown): {
+            "__#private@#entries": Array<[string, number]>;
+            "__#private@#at": number;
+            "__#private@#encoding": unknown;
+            read(encoding?: string, bufferSize?: number, req?: FSReq): unknown;
+            close(req?: FSReq): undefined;
+        };
+        opendir(path: unknown, encoding: string, req?: FSReq): {
+            "__#private@#entries": Array<[string, number]>;
+            "__#private@#at": number;
+            "__#private@#encoding": unknown;
+            read(encoding?: string, bufferSize?: number, req?: FSReq): unknown;
+            close(req?: FSReq): undefined;
+        } | undefined;
+    };
+    fsEventWrapBinding: {
+        FSEvent: {
+            new (): {
+                onchange: ((status: number, event: string, filename: string | Uint8Array) => void) | null;
+                "__#private@#watcher": {
+                    close(): void;
+                } | null;
+                initialized: boolean;
+                start(path: unknown, persistent?: boolean, recursive?: boolean, encoding?: string): number;
+                close(): void;
+                ref(): void;
+                unref(): void;
+                getAsyncId(): number;
+                hasRef(): boolean;
+            };
+        };
+    };
+    FSReqCallback: {
+        new (bigint?: boolean): {
+            oncomplete: ((error: Error | null, ...rest: unknown[]) => void) | undefined;
+            context: unknown;
+            bigint: boolean;
+        };
+    };
+    DirHandle: {
+        new (path: string, encoding?: unknown): {
+            "__#private@#entries": Array<[string, number]>;
+            "__#private@#at": number;
+            "__#private@#encoding": unknown;
+            read(encoding?: string, bufferSize?: number, req?: FSReq): unknown;
+            close(req?: FSReq): undefined;
+        };
+    };
+    FSEvent: {
+        new (): {
+            onchange: ((status: number, event: string, filename: string | Uint8Array) => void) | null;
+            "__#private@#watcher": {
+                close(): void;
+            } | null;
+            initialized: boolean;
+            start(path: unknown, persistent?: boolean, recursive?: boolean, encoding?: string): number;
+            close(): void;
+            ref(): void;
+            unref(): void;
+            getAsyncId(): number;
+            hasRef(): boolean;
+        };
+    };
+    StatWatcher: {
+        new (bigint?: boolean): {
+            onchange: ((current: Float64Array | BigInt64Array, previous: Float64Array | BigInt64Array) => void) | null;
+            "__#private@#timer": ReturnType<typeof setInterval> | null;
+            "__#private@#previous": Float64Array | BigInt64Array | null;
+            bigint: boolean;
+            start(path: unknown, interval?: number): number;
+            stop(): void;
+            close(): void;
+            ref(): void;
+            unref(): void;
+            getAsyncId(): number;
+            hasRef(): boolean;
+        };
+    };
+    FileHandle: {
+        new (fd: number): {
+            fd: number;
+            close(): Promise<void>;
+            release(): void;
+            getAsyncId(): number;
+        };
+    };
 };
-/**
- * What `fs.promises.open` is handed: a descriptor with a close of its own.
- * Node's is a C++ handle whose destructor closes the file; here it is the
- * same number this file's table keeps, with the same close.
- */
-export declare class FileHandle {
-    fd: number;
-    constructor(fd: number);
-    close(): Promise<void>;
-    release(): void;
-    getAsyncId(): number;
-}
+export declare const kUsePromises: unique symbol;
 export declare const fsBinding: {
-    FSReqCallback: typeof FSReqCallback;
+    FSReqCallback: {
+        new (bigint?: boolean): {
+            oncomplete: ((error: Error | null, ...rest: unknown[]) => void) | undefined;
+            context: unknown;
+            bigint: boolean;
+        };
+    };
     kUsePromises: symbol;
-    StatWatcher: typeof StatWatcher;
+    StatWatcher: {
+        new (bigint?: boolean): {
+            onchange: ((current: Float64Array | BigInt64Array, previous: Float64Array | BigInt64Array) => void) | null;
+            "__#private@#timer": ReturnType<typeof setInterval> | null;
+            "__#private@#previous": Float64Array | BigInt64Array | null;
+            bigint: boolean;
+            start(path: unknown, interval?: number): number;
+            stop(): void;
+            close(): void;
+            ref(): void;
+            unref(): void;
+            getAsyncId(): number;
+            hasRef(): boolean;
+        };
+    };
     /** `fs.promises.open`: the same open, answered as a promise with a handle. */
-    openFileHandle(path: unknown, flags: number, mode: number, usePromises?: unknown): Promise<FileHandle> | FileHandle;
+    openFileHandle(path: unknown, flags: number, mode: number, usePromises?: unknown): Promise<{
+        fd: number;
+        close(): Promise<void>;
+        release(): void;
+        getAsyncId(): number;
+    }> | {
+        fd: number;
+        close(): Promise<void>;
+        release(): void;
+        getAsyncId(): number;
+    };
     open(path: unknown, flags: number, _mode: number, req?: FSReq): number | undefined;
     close(fd: number, req?: FSReq): undefined;
     read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number, req?: FSReq): number | undefined;
@@ -152,5 +300,90 @@ export declare const fsBinding: {
     fsync(_fd: number, req?: FSReq): undefined;
     fdatasync(_fd: number, req?: FSReq): undefined;
     ftruncate(fd: number, length: number, req?: FSReq): undefined;
+}, fsDirBinding: {
+    opendirSync(path: unknown, encoding?: unknown): {
+        "__#private@#entries": Array<[string, number]>;
+        "__#private@#at": number;
+        "__#private@#encoding": unknown;
+        read(encoding?: string, bufferSize?: number, req?: FSReq): unknown;
+        close(req?: FSReq): undefined;
+    };
+    opendir(path: unknown, encoding: string, req?: FSReq): {
+        "__#private@#entries": Array<[string, number]>;
+        "__#private@#at": number;
+        "__#private@#encoding": unknown;
+        read(encoding?: string, bufferSize?: number, req?: FSReq): unknown;
+        close(req?: FSReq): undefined;
+    } | undefined;
+}, fsEventWrapBinding: {
+    FSEvent: {
+        new (): {
+            onchange: ((status: number, event: string, filename: string | Uint8Array) => void) | null;
+            "__#private@#watcher": {
+                close(): void;
+            } | null;
+            initialized: boolean;
+            start(path: unknown, persistent?: boolean, recursive?: boolean, encoding?: string): number;
+            close(): void;
+            ref(): void;
+            unref(): void;
+            getAsyncId(): number;
+            hasRef(): boolean;
+        };
+    };
+}, FSReqCallback: {
+    new (bigint?: boolean): {
+        oncomplete: ((error: Error | null, ...rest: unknown[]) => void) | undefined;
+        context: unknown;
+        bigint: boolean;
+    };
+}, DirHandle: {
+    new (path: string, encoding?: unknown): {
+        "__#private@#entries": Array<[string, number]>;
+        "__#private@#at": number;
+        "__#private@#encoding": unknown;
+        read(encoding?: string, bufferSize?: number, req?: FSReq): unknown;
+        close(req?: FSReq): undefined;
+    };
+}, FSEvent: {
+    new (): {
+        onchange: ((status: number, event: string, filename: string | Uint8Array) => void) | null;
+        "__#private@#watcher": {
+            close(): void;
+        } | null;
+        initialized: boolean;
+        start(path: unknown, persistent?: boolean, recursive?: boolean, encoding?: string): number;
+        close(): void;
+        ref(): void;
+        unref(): void;
+        getAsyncId(): number;
+        hasRef(): boolean;
+    };
+}, StatWatcher: {
+    new (bigint?: boolean): {
+        onchange: ((current: Float64Array | BigInt64Array, previous: Float64Array | BigInt64Array) => void) | null;
+        "__#private@#timer": ReturnType<typeof setInterval> | null;
+        "__#private@#previous": Float64Array | BigInt64Array | null;
+        bigint: boolean;
+        start(path: unknown, interval?: number): number;
+        stop(): void;
+        close(): void;
+        ref(): void;
+        unref(): void;
+        getAsyncId(): number;
+        hasRef(): boolean;
+    };
+}, FileHandle: {
+    new (fd: number): {
+        fd: number;
+        close(): Promise<void>;
+        release(): void;
+        getAsyncId(): number;
+    };
 };
+export type FSReqCallback = InstanceType<typeof FSReqCallback>;
+export type DirHandle = InstanceType<typeof DirHandle>;
+export type FSEvent = InstanceType<typeof FSEvent>;
+export type StatWatcher = InstanceType<typeof StatWatcher>;
+export type FileHandle = InstanceType<typeof FileHandle>;
 export default fsBinding;

package/dist/node-lib/binding/misc.d.ts

@@ -58,6 +58,7 @@ export declare const encodingBinding: {
  * Node without ICU does, and is the one thing `buffer.js` loses here.
  */
 export declare const configBinding: {
+    getDefaultLocale: () => string;
     hasIntl: boolean;
     hasSmallICU: boolean;
     hasNodeOptions: boolean;

package/dist/node-lib/binding/pipe_wrap.d.ts

@@ -60,13 +60,13 @@ export declare class Pipe extends LibuvStreamWrap {
      *
      * The handle becomes the receiving run's. Node's `send(message, socket)`
      * duplicates the sender's descriptor into the other process, and from then
-     * on the socket is an active handle of that process's loop; here parent and
-     * child are one realm and there is nothing to duplicate, so the move is the
-     * run ownership the engine counts. Without it, openvscode-server's extension
+     * on the socket is an active handle of that process's loop. The binding
+     * duplicates the wrapper and assigns that reference to the receiver.
+     * Without that ownership, openvscode-server's extension
      * host -- a program whose only handle is the socket its parent sent it --
      * read as idle and was settled with exit 0.
      */
-    writeUtf8String(req: WriteWrap, text: string, handle?: unknown): number;
+    protected dispatchWrite(req: WriteWrap, bytes: Uint8Array, handle?: unknown): number;
     protected onCloseHandle(): void;
 }
 declare const _default: {