@volter/tabnode 0.2.14-volter.88

package/dist/node-internals.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The Node internals a vendored `lib/*.js` file asks its binding for:
+ * `internal/errors` codes and `internal/validators`, with Node's messages.
+ *
+ * A guest reads `err.code` and `err.message`, and Node's own tests read both
+ * (test-path-parse-format.js asserts the ERR_INVALID_ARG_TYPE text word for
+ * word; test-wasi-options-validation.js matches the property names), so each
+ * message is assembled the way lib/internal/errors.js assembles it. These
+ * began in `shims/path.ts`, the first Node file run on a binding; `shims/wasi.ts`
+ * is the second, and both bind here.
+ */
+/** Node's util.inspect, for the primitives that reach an error message. */
+export declare function inspectValue(value: unknown): string;
+/**
+ * lib/internal/errors.js `determineSpecificType`, the "Received ..." tail of
+ * every ERR_INVALID_ARG_TYPE. Node switches on `typeof` and never inspects a
+ * function: a function is `function <name>`, and an anonymous one is
+ * `function ` with the empty name, not `type function (() => {\n})`. The engine
+ * inspected it, so every builtin that validated an argument printed a
+ * program's own source back at it where Node prints a name
+ * (`node:wasi`'s `new WASI(() => {})`, test-wasi-options-validation.js).
+ * Transcribed from Node 22's source, case for case.
+ */
+export declare function determineSpecificType(value: unknown): string;
+/**
+ * lib/internal/errors.js ERR_INVALID_ARG_TYPE. Node sorts each expectation
+ * into three buckets — a primitive `type`, a class `instance`, anything else —
+ * and the engine had only two, so every validator that expects a class said
+ * "must be an Array" where Node says "must be an instance of Array"
+ * (`node:wasi`'s `validateArray(options.args)`,
+ * test-wasi-options-validation.js).
+ */
+export declare class ERR_INVALID_ARG_TYPE extends TypeError {
+    code: string;
+    constructor(name: string, expected: string | string[], actual: unknown);
+}
+export declare class ERR_INVALID_ARG_VALUE extends TypeError {
+    code: string;
+    constructor(name: string, value: unknown, reason?: string);
+}
+export declare class ERR_OUT_OF_RANGE extends RangeError {
+    code: string;
+    constructor(name: string, range: string, value: unknown);
+}
+export declare function validateString(value: unknown, name: string): void;
+export declare function validateObject(value: unknown, name: string): void;
+export declare function validateArray(value: unknown, name: string, minLength?: number): void;
+export declare function validateBoolean(value: unknown, name: string): void;
+export declare function validateFunction(value: unknown, name: string): void;
+/** lib/internal/errors.js ERR_UNKNOWN_ENCODING, as `new StringDecoder('x')` raises it. */
+export declare class ERR_UNKNOWN_ENCODING extends TypeError {
+    code: string;
+    constructor(encoding: unknown);
+}
+/** lib/internal/errors.js ERR_INVALID_THIS: a prototype method called off an instance. */
+export declare class ERR_INVALID_THIS extends TypeError {
+    code: string;
+    constructor(type: string);
+}
+/** lib/internal/errors.js ERR_STRING_TOO_LONG: past V8's longest string. */
+export declare class ERR_STRING_TOO_LONG extends RangeError {
+    code: string;
+    constructor(max: number);
+}
+export declare function validateNumber(value: unknown, name: string): void;
+export declare function validateUndefined(value: unknown, name: string): void;
+export declare function validateInt32(value: unknown, name: string, min?: number, max?: number): void;
+//# sourceMappingURL=node-internals.d.ts.map

package/dist/node-internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-internals.d.ts","sourceRoot":"","sources":["../src/node-internals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAUnD;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CA2C5D;AASD;;;;;;;GAOG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,IAAI,SAA0B;gBAClB,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,MAAM,EAAE,OAAO;CAsEvE;AAED,qBAAa,qBAAsB,SAAQ,SAAS;IAClD,IAAI,SAA2B;gBACnB,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,SAAe;CAKhE;AAgBD,qBAAa,gBAAiB,SAAQ,UAAU;IAC9C,IAAI,SAAsB;gBACd,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;CAgBxD;AAMD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEjE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAIjE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,SAAI,GAAG,IAAI,CAK/E;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAElE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEnE;AAED,0FAA0F;AAC1F,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,IAAI,SAA0B;gBAClB,QAAQ,EAAE,OAAO;CAI9B;AAED,0FAA0F;AAC1F,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,IAAI,SAAsB;gBACd,IAAI,EAAE,MAAM;CAIzB;AAED,4EAA4E;AAC5E,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,IAAI,SAAyB;gBACjB,GAAG,EAAE,MAAM;CAIxB;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEjE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEpE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,SAAc,EAAE,GAAG,SAAa,GAAG,IAAI,CAIrG"}

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

@@ -0,0 +1,12 @@
+/**
+ * Node's `createBlobFromFilePath(path, { type })`: the bytes of that path
+ * as a realm `Blob`. `fs.openAsBlob` is a promise of this value.
+ */
+export declare function createBlobFromFilePath(path: string, options?: {
+    type?: string;
+}): Blob;
+declare const _default: {
+    createBlobFromFilePath: typeof createBlobFromFilePath;
+};
+export default _default;
+//# sourceMappingURL=blob.d.ts.map

package/dist/node-lib/binding/blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/blob.ts"],"names":[],"mappings":"AAuBA;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAKtF;;;;AAED,wBAA0C"}

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

@@ -0,0 +1,144 @@
+/**
+ * `internalBinding('buffer')`: the bytes under Node's own `buffer.js`.
+ *
+ * Node's `Buffer` is a `Uint8Array` subclass whose whole API -- `alloc`,
+ * `concat`, `toString`, `write`, `compare`, `indexOf`, `readInt32BE` and the
+ * rest -- is JavaScript in `lib/buffer.js` and `lib/internal/buffer.js`. What
+ * is native is only the part underneath: encode a string into bytes, decode
+ * bytes into a string, compare two ranges, find one range inside another,
+ * fill, copy, swap. That is this file, over `TextEncoder`, `TextDecoder` and
+ * the realm's own base64, and nothing above it.
+ *
+ * Every function here has the shape Node's own files call it with: the
+ * `*Slice` family is installed as a method and reads `this`; `base64Write`,
+ * `base64urlWrite`, `hexWrite` and `ucs2Write` likewise; `asciiWriteStatic`,
+ * `latin1WriteStatic` and `utf8WriteStatic` take the buffer as their first
+ * argument, which is how `internal/buffer.js` wraps them.
+ */
+/** libuv has no say here: these are V8's, and the engine's realm is V8's. */
+export declare const kMaxLength: number;
+export declare const kStringMaxLength = 536870888;
+/**
+ * Node's encoding numbers, from `enum encoding` in `node_buffer.h`. They are
+ * private to this binding and `internal/util`'s `encodingsMap`, which is the
+ * only thing that hands them over.
+ */
+export declare const ASCII = 0;
+export declare const UTF8 = 1;
+export declare const BASE64 = 2;
+export declare const UCS2 = 3;
+export declare const LATIN1 = 4;
+export declare const HEX = 5;
+export declare const BUFFER = 6;
+export declare const BASE64URL = 7;
+/** Node's `StringWrite<UTF8>`: as many whole code points as fit. */
+export declare function utf8WriteStatic(buf: Uint8Array, string: string, offset?: number, length?: number): number;
+/** Node's `StringWrite<ASCII>`: the low seven bits of each unit, one byte each. */
+export declare function asciiWriteStatic(buf: Uint8Array, string: string, offset?: number, length?: number): number;
+/** Node's `StringWrite<LATIN1>`: the low eight bits of each unit. */
+export declare function latin1WriteStatic(buf: Uint8Array, string: string, offset?: number, length?: number): number;
+/** Node's `StringWrite<UCS2>`: whole 16-bit units, little-endian. */
+export declare function ucs2Write(this: Uint8Array, string: string, offset?: number, length?: number): number;
+/** Node's `StringWrite<HEX>`: whole byte pairs, stopping at the first that is not one. */
+export declare function hexWrite(this: Uint8Array, string: string, offset?: number, length?: number): number;
+/** Node's `StringWrite<BASE64>`. */
+export declare function base64Write(this: Uint8Array, string: string, offset?: number, length?: number): number;
+/** Node's `StringWrite<BASE64URL>`. */
+export declare function base64urlWrite(this: Uint8Array, string: string, offset?: number, length?: number): number;
+export declare function utf8Slice(this: Uint8Array, start?: number, end?: number): string;
+export declare function asciiSlice(this: Uint8Array, start?: number, end?: number): string;
+export declare function latin1Slice(this: Uint8Array, start?: number, end?: number): string;
+export declare function ucs2Slice(this: Uint8Array, start?: number, end?: number): string;
+export declare function hexSlice(this: Uint8Array, start?: number, end?: number): string;
+export declare function base64Slice(this: Uint8Array, start?: number, end?: number): string;
+export declare function base64urlSlice(this: Uint8Array, start?: number, end?: number): string;
+/** Node's `ByteLengthUtf8`. */
+export declare function byteLengthUtf8(string: string): number;
+/** Node's `Compare`: two buffers whole, as `memcmp` orders them. */
+export declare function compare(a: Uint8Array, b: Uint8Array): number;
+/** Node's `CompareOffset`: a range of one against a range of the other. */
+export declare function compareOffset(source: Uint8Array, target: Uint8Array, targetStart?: number, sourceStart?: number, targetEnd?: number, sourceEnd?: number): number;
+/**
+ * Node's `Copy(source, target, targetStart, sourceStart, toCopy)`. The last
+ * argument is a LENGTH, not an end offset: `buffer.js`'s `_copyActual` has
+ * already clamped the range and hands over how many bytes to move.
+ */
+export declare function copy(source: Uint8Array, target: Uint8Array, targetStart?: number, sourceStart?: number, toCopy?: number): number;
+/**
+ * Node's `Fill` for a value that is not a number: a string in some encoding,
+ * or another buffer, repeated over the range. -1 says the value stands for no
+ * bytes at all, which is what `buffer.js` turns into ERR_INVALID_ARG_VALUE.
+ */
+export declare function fill(buf: Uint8Array, value: unknown, start: number, end: number, encoding?: string): number;
+/** The bytes a string stands for in one of Node's encodings. */
+export declare function bytesOfString(value: string, encoding: string): Uint8Array;
+/** Node's `IndexOfNumber`. */
+export declare function indexOfNumber(buffer: Uint8Array, value: number, byteOffset: number, isForward: boolean): number;
+/** Node's `IndexOfBuffer`. */
+export declare function indexOfBuffer(buffer: Uint8Array, value: Uint8Array, byteOffset: number, encoding: number, isForward: boolean): number;
+/** Node's `IndexOfString`. */
+export declare function indexOfString(buffer: Uint8Array, value: string, byteOffset: number, encoding: number, isForward: boolean): number;
+/** Node's `Swap16`/`Swap32`/`Swap64`, in place, answering the same buffer. */
+export declare function swap16(buf: Uint8Array): Uint8Array;
+export declare function swap32(buf: Uint8Array): Uint8Array;
+export declare function swap64(buf: Uint8Array): Uint8Array;
+/** Node's `IsUtf8`: whether the bytes decode without a replacement. */
+export declare function isUtf8(buf: Uint8Array): boolean;
+/** Node's `IsAscii`: every byte under 128. */
+export declare function isAscii(buf: Uint8Array): boolean;
+/** Node's `Atob`: the string a base64 one stands for, -1 for one that is not. */
+export declare function atob(input: string): string | number;
+/** Node's `Btoa`: the base64 of a latin1 string, -1 for a character outside it. */
+export declare function btoa(input: string): string | number;
+export declare function getZeroFillToggle(): Uint32Array;
+/**
+ * Node's `DetachArrayBuffer` and `CopyArrayBuffer`, which `Blob` and the
+ * worker's message port use. A realm can detach through `structuredClone`'s
+ * transfer list, and that is the only detach there is here.
+ */
+export declare function detachArrayBuffer(buffer: ArrayBuffer): void;
+export declare function copyArrayBuffer(dest: ArrayBuffer, destOffset: number, source: ArrayBuffer, sourceOffset: number, length: number): void;
+/** Node's `SetBufferPrototype`: C++ keeps it to build buffers; nothing here does. */
+export declare function setBufferPrototype(_proto: object): void;
+/** Node's `CreateFromString`: `buffer.js` has its own and never calls this. */
+export declare function createFromString(string: string, encoding: number): Uint8Array;
+declare const _default: {
+    byteLengthUtf8: typeof byteLengthUtf8;
+    compare: typeof compare;
+    compareOffset: typeof compareOffset;
+    copy: typeof copy;
+    fill: typeof fill;
+    isAscii: typeof isAscii;
+    isUtf8: typeof isUtf8;
+    indexOfBuffer: typeof indexOfBuffer;
+    indexOfNumber: typeof indexOfNumber;
+    indexOfString: typeof indexOfString;
+    swap16: typeof swap16;
+    swap32: typeof swap32;
+    swap64: typeof swap64;
+    kMaxLength: number;
+    kStringMaxLength: number;
+    atob: typeof atob;
+    btoa: typeof btoa;
+    asciiSlice: typeof asciiSlice;
+    base64Slice: typeof base64Slice;
+    base64urlSlice: typeof base64urlSlice;
+    latin1Slice: typeof latin1Slice;
+    hexSlice: typeof hexSlice;
+    ucs2Slice: typeof ucs2Slice;
+    utf8Slice: typeof utf8Slice;
+    asciiWriteStatic: typeof asciiWriteStatic;
+    base64Write: typeof base64Write;
+    base64urlWrite: typeof base64urlWrite;
+    latin1WriteStatic: typeof latin1WriteStatic;
+    hexWrite: typeof hexWrite;
+    ucs2Write: typeof ucs2Write;
+    utf8WriteStatic: typeof utf8WriteStatic;
+    getZeroFillToggle: typeof getZeroFillToggle;
+    detachArrayBuffer: typeof detachArrayBuffer;
+    copyArrayBuffer: typeof copyArrayBuffer;
+    setBufferPrototype: typeof setBufferPrototype;
+    createFromString: typeof createFromString;
+};
+export default _default;
+//# sourceMappingURL=buffer.d.ts.map

package/dist/node-lib/binding/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/buffer.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,14 @@
+/**
+ * An IPv6 address as its sixteen bytes. `::` fills the gap, and a trailing
+ * IPv4 form (`::ffff:127.0.0.1`) is its four bytes at the end, as inet_pton
+ * reads one.
+ */
+export declare function convertIpv6StringToBuffer(address: string): Uint8Array;
+declare const _default: {
+    readonly isIP: (s: string) => number;
+    readonly isIPv4: (s: string) => boolean;
+    readonly isIPv6: (s: string) => boolean;
+    convertIpv6StringToBuffer: typeof convertIpv6StringToBuffer;
+};
+export default _default;
+//# sourceMappingURL=cares_wrap.d.ts.map

package/dist/node-lib/binding/cares_wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cares_wrap.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/cares_wrap.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CA4BrE;;uBArCiC,MAAM,KAAG,MAAM;yBAAY,MAAM,KAAG,OAAO;yBAAY,MAAM,KAAG,OAAO;;;AAuCzG,wBAKE"}

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

@@ -0,0 +1,30 @@
+/**
+ * The file descriptors a handle can be opened on.
+ *
+ * libuv answers `uv_guess_handle(fd)` from the kernel. The engine has no
+ * kernel and no descriptors of its own beyond the three a process is started
+ * with and the ones a spawn hands a child, so the table is what the engine
+ * itself opened: a `Pipe` or `TCP` registered here by the run that made it,
+ * and the three standard ones, which are pipes because the engine's stdio is
+ * a stream the host reads, never a terminal it owns.
+ *
+ * `net.js` reads it through `internal/util`'s `guessHandleType` when a program
+ * builds a socket on a descriptor (`new net.Socket({ fd })`) and when a server
+ * listens on one.
+ */
+import type { ProcessToken } from '../../process-tokens';
+/** What libuv answers for a descriptor. */
+export type HandleType = 'TCP' | 'TTY' | 'UDP' | 'FILE' | 'PIPE' | 'UNKNOWN';
+/** 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;
+/** 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)`. */
+export declare function handleForFd(fd: number): unknown;
+/** Give a descriptor back; a handle that closes stops answering for one. */
+export declare function releaseFd(fd: number): void;
+/** libuv's `uv_guess_handle`. */
+export declare function guessHandleTypeOfFd(fd: number): HandleType;
+//# sourceMappingURL=fds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fds.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/fds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,2CAA2C;AAC3C,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAmB7E,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAItG;AAED,qDAAqD;AACrD,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAEvD;AAQD,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAIpE;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED,4EAA4E;AAC5E,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAE1C;AAED,iCAAiC;AACjC,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,CAK1D"}

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

@@ -0,0 +1,157 @@
+import type { VirtualFS } from '../../virtual-fs';
+/** 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;
+/** A request object `fs.js` hands an asynchronous call, answered on a tick. */
+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.
+ */
+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;
+};
+/**
+ * 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 fsBinding: {
+    FSReqCallback: typeof FSReqCallback;
+    kUsePromises: symbol;
+    StatWatcher: typeof StatWatcher;
+    /** `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;
+    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;
+};
+export default fsBinding;
+//# sourceMappingURL=fs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/fs.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,81 @@
+/**
+ * Run ownership, as libuv's loop counts handles.
+ *
+ * Node keeps a process alive while its loop holds an active handle: a
+ * listening server, a connected socket, a pending timer. `unref()` takes a
+ * handle out of that count and `ref()` puts it back. The engine counted a
+ * run's timers, the host work it was waiting on, and the ports it was
+ * listening on — three registries written one at a time, each for the program
+ * that died without it — and a program whose only handle was a client socket
+ * read as idle and was settled: VS Code's extension host, ended with exit 0
+ * three times over.
+ *
+ * Here there is one count, and it is the handle's own, because the handle is
+ * now the thing Node's own `net.js` creates and closes. A handle registers
+ * with the run that made it when it is constructed, `ref`/`unref` toggle it,
+ * and closing it gives it up.
+ */
+import { type ProcessToken } from '../../process-tokens';
+/** What the count needs of a handle: a way to close it when its run ends. */
+export interface OwnedHandle {
+    close(callback?: () => void): void;
+}
+/** The run a handle opened in, where a host named one. */
+export declare function currentOwner(): ProcessToken | null;
+/** The run a handle belongs to, for a handle that must belong to another's. */
+export declare function ownerOf(handle: OwnedHandle): ProcessToken | null;
+/** A new handle is the current run's, ref'd and active, as libuv's start. */
+export declare function registerHandle(handle: OwnedHandle): void;
+/**
+ * libuv's `uv__handle_stop`: the handle stays open and stops doing anything,
+ * so it no longer holds its run's loop. A stream calls this when it reads
+ * EOF, as libuv's does.
+ */
+export declare function stopHandle(handle: OwnedHandle): void;
+/** libuv's `uv_ref`. */
+export declare function refHandle(handle: OwnedHandle): void;
+/** libuv's `uv_unref`: the handle stays open and stops holding the loop. */
+export declare function unrefHandle(handle: OwnedHandle): void;
+/** Whether the handle still holds its run's loop open. */
+export declare function handleHasRef(handle: OwnedHandle): boolean;
+/** A closed handle holds nothing. */
+export declare function releaseHandle(handle: OwnedHandle): void;
+/**
+ * How many ref'd handles the named run holds, as Node's loop counts them.
+ * The engine's `node` command asks it to decide whether a program that has
+ * gone quiet is done.
+ */
+export declare function __ownedHandleCount(token: ProcessToken): number;
+/**
+ * Every port the named run is listening on.
+ *
+ * The engine's `node` command asks this to tell a run that has gone quiet but
+ * holds a server from one that is finished, and the page bridge asks it to
+ * name a guest's servers. It used to be a registry the engine's own `http`
+ * kept; `http` is Node's own file now, and a server is a listening handle, so
+ * the answer comes from the handles the run holds.
+ */
+export declare function __ownedServerPorts(token: ProcessToken): number[];
+/**
+ * A process that ends closes the servers it was listening on. This is the
+ * same release as the handles below it -- a server IS a handle here -- kept
+ * under its own name because the engine's own parts call it where a run ends.
+ */
+export declare function __releaseOwnedServers(token: ProcessToken, stopTimers?: boolean, stopProcess?: (token: ProcessToken) => void): void;
+/**
+ * A process that ends closes the handles it held, as Node closes its fds.
+ * Called where the run's servers and timers are released.
+ */
+export declare function __releaseOwnedHandles(token: ProcessToken): void;
+/**
+ * Move a handle to another run, as a descriptor sent over IPC moves.
+ *
+ * Node's `subprocess.send(message, socket)` duplicates the parent's descriptor
+ * into the child, and from then on the socket is an active handle of the
+ * child's loop, not the parent's. The engine has no descriptor to duplicate —
+ * parent and child are one realm and the loopback pairing is the connection —
+ * so the move is this count's. A handle the program `unref`'d stays unref'd
+ * through the move, as Node's does.
+ */
+export declare function __adoptHandle(handle: OwnedHandle | null | undefined, token: ProcessToken | null): void;
+//# sourceMappingURL=handles.d.ts.map

package/dist/node-lib/binding/handles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/handles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAA8C,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAErG,6EAA6E;AAC7E,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;CACpC;AAiBD,0DAA0D;AAC1D,wBAAgB,YAAY,IAAI,YAAY,GAAG,IAAI,CAElD;AAoBD,+EAA+E;AAC/E,wBAAgB,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,GAAG,IAAI,CAEhE;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAKxD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAGpD;AAED,wBAAwB;AACxB,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAGnD;AAED,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAGrD;AAED,0DAA0D;AAC1D,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED,qCAAqC;AACrC,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAKvD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAE9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,EAAE,CAShE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,UAAO,EAAE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,IAAI,CAY/H;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAO/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAKtG"}