@volter/tabnode 0.2.14-volter.88

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

@@ -0,0 +1,122 @@
+/** The callback slots Node hangs off a parser, by the index its C++ uses. */
+declare const kOnMessageBegin = 0;
+declare const kOnHeaders = 1;
+declare const kOnHeadersComplete = 2;
+declare const kOnBody = 3;
+declare const kOnMessageComplete = 4;
+declare const kOnExecute = 5;
+declare const kOnTimeout = 6;
+type ParserCallback = ((...args: never[]) => unknown) | null;
+export declare class HTTPParser {
+    #private;
+    static readonly REQUEST = 1;
+    static readonly RESPONSE = 2;
+    static readonly kOnMessageBegin = 0;
+    static readonly kOnHeaders = 1;
+    static readonly kOnHeadersComplete = 2;
+    static readonly kOnBody = 3;
+    static readonly kOnMessageComplete = 4;
+    static readonly kOnExecute = 5;
+    static readonly kOnTimeout = 6;
+    /** Node's lenient flags. Each one llhttp itself can be told about is passed on. */
+    static readonly kLenientNone = 0;
+    static readonly kLenientHeaders = 1;
+    static readonly kLenientChunkedLength = 2;
+    static readonly kLenientKeepAlive = 4;
+    static readonly kLenientTransferEncoding = 8;
+    static readonly kLenientVersion = 16;
+    static readonly kLenientDataAfterClose = 32;
+    static readonly kLenientOptionalLFAfterCR = 64;
+    static readonly kLenientOptionalCRLFAfterChunk = 128;
+    static readonly kLenientOptionalCRBeforeLF = 256;
+    static readonly kLenientSpacesAfterChunkSize = 512;
+    static readonly kLenientAll = 1023;
+    [kOnMessageBegin]: ParserCallback;
+    [kOnHeaders]: ParserCallback;
+    [kOnHeadersComplete]: ParserCallback;
+    [kOnBody]: ParserCallback;
+    [kOnMessageComplete]: ParserCallback;
+    [kOnExecute]: ParserCallback;
+    [kOnTimeout]: ParserCallback;
+    /** The socket `_http_server.js` hangs on a parser, and reads off one here. */
+    socket?: {
+        destroy(): void;
+    } | null;
+    /** When this connection's current head and current message began, in ms. */
+    headersStart: number;
+    messageStart: number;
+    /** Whether a message is in flight, which is what `idle()` is the absence of. */
+    active: boolean;
+    /**
+     * `parser.initialize(type, resource, maxHeaderSize, lenient, headersTimeout)`,
+     * which Node calls for every parser it takes off its free list.
+     */
+    initialize(type: number, _resource?: unknown, maxHeaderSize?: number, lenient?: number, connections?: ConnectionsList): void;
+    /** Node's `parser.free()`: back on the free list, holding no llhttp state. */
+    free(): void;
+    /** Node's `parser.remove()`, which only matters for a consumed stream. */
+    remove(): void;
+    close(): void;
+    pause(): void;
+    resume(): void;
+    /** The engine's handles are not stream bases, so Node never consumes one. */
+    consume(): void;
+    unconsume(): void;
+    getCurrentBuffer(): Uint8Array;
+    /**
+     * `parser.execute(buffer)`: the bytes through llhttp, answering how many it
+     * took, or an `Error` carrying `bytesParsed`, the llhttp code and llhttp's
+     * own reason -- which is the shape `_http_server.js` reads to decide
+     * between a 400 and a destroyed socket.
+     */
+    execute(buffer: Uint8Array): number | Error;
+    /** `parser.finish()`: the stream ended; llhttp says whether that was legal. */
+    finish(): number | Error | undefined;
+    onMessageBegin(): number;
+    onUrl(at: number, length: number): number;
+    onStatus(at: number, length: number): number;
+    onHeaderField(at: number, length: number): number;
+    onHeaderValue(at: number, length: number): number;
+    onHeadersComplete(statusCode: number, upgrade: boolean, shouldKeepAlive: boolean): number;
+    onBody(at: number, length: number): number;
+    onMessageComplete(): number;
+    /** Off the list it was initialized onto; `free` is where Node lets one go. */
+    detach(): void;
+}
+/**
+ * `internalBinding('http_parser')`'s `ConnectionsList`: the parsers a server
+ * has open, which is how `_http_server.js` closes its connections and
+ * enforces `headersTimeout` and `requestTimeout`. Node keeps the list in C++
+ * beside the parsers themselves; here it is a set of the same parsers, and
+ * each answers from the timestamps llhttp's own callbacks set on it.
+ */
+export declare class ConnectionsList {
+    #private;
+    add(parser: HTTPParser): void;
+    remove(parser: HTTPParser): void;
+    all(): HTTPParser[];
+    /** A connection with no message in flight. */
+    idle(): HTTPParser[];
+    /** A connection with one. */
+    active(): HTTPParser[];
+    /**
+     * The connections that have taken too long: one whose head is still
+     * arriving after `headersTimeout`, or whose message has been in flight past
+     * `requestTimeout`. A timeout of 0 is off, as it is in Node.
+     */
+    expired(headersTimeout: number, requestTimeout: number): HTTPParser[];
+}
+/** The binding object, built on the first ask. */
+export declare const httpParserBinding: {
+    HTTPParser: typeof HTTPParser;
+    ConnectionsList: typeof ConnectionsList;
+    /**
+     * `http.METHODS`: the HTTP methods, which are the ones llhttp lists before
+     * `PRI` -- that is where its RTSP block begins, and RTSP's verbs are not
+     * HTTP's. Read off the same table as `allMethods`, so the two cannot drift.
+     */
+    readonly methods: string[];
+    readonly allMethods: string[];
+};
+export default httpParserBinding;
+//# sourceMappingURL=http_parser.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+export declare function nodeLibBinding(name: string): (() => unknown) | undefined;
+export { __ownedHandleCount, __releaseOwnedHandles, __adoptHandle, currentOwner, } from './handles';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/index.ts"],"names":[],"mappings":"AAwCA,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CAgCxE;AAED,OAAO,EACL,kBAAkB,EAAE,qBAAqB,EAAE,aAAa,EAAE,YAAY,GACvE,MAAM,WAAW,CAAC"}

package/dist/node-lib/binding/llhttp-wasm.d.ts

@@ -0,0 +1,22 @@
+/**
+ * llhttp, compiled to WebAssembly.
+ *
+ * VENDORED ARTIFACT, UNMODIFIED. This is the build undici ships -- llhttp is
+ * the parser Node itself links, and undici is the one project that already
+ * compiles it for a runtime with no C in it, which is what a tab is.
+ *
+ *   source:  undici 6.28.0, lib/llhttp/llhttp-wasm.js
+ *   bytes:   48615
+ *   sha256:  b96063c7ce14045f91f17489d8b30a2bf5129308bd801d7dde715579d16d0e21
+ *   license: MIT (llhttp, nodejs/llhttp; undici, nodejs/undici)
+ *
+ * The base64 below is that file's own payload, byte for byte; nothing here is
+ * edited. `./http_parser.ts` instantiates it and gives Node's own
+ * `_http_common.js` the `HTTPParser` it expects on top.
+ *
+ * The non-SIMD build is the one taken: a tab's WebAssembly does not promise
+ * SIMD, and llhttp's SIMD path buys throughput this engine is nowhere near
+ * needing.
+ */
+export declare const LLHTTP_WASM_BASE64: string;
+//# sourceMappingURL=llhttp-wasm.d.ts.map

package/dist/node-lib/binding/llhttp-wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llhttp-wasm.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/llhttp-wasm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kBAAkB,QAyoBP,CAAC"}

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

@@ -0,0 +1,123 @@
+export declare const constantsBinding: Record<string, unknown>;
+export declare const osBinding: {
+    /** Node's `os.type()`, `release()` and `version()`, in that order. */
+    getOSInformation: () => string[];
+    getHostname: () => string;
+    getHomeDirectory: () => string;
+    getUptime: () => number;
+    getTotalMem: () => number;
+    getFreeMem: () => number;
+    getLoadAvg: (array: Float64Array) => void;
+    getAvailableParallelism: () => number;
+    isBigEndian: boolean;
+    /**
+     * Node reads its CPU list as a flat array: a model and a speed, then the
+     * five time counters, for each core.
+     */
+    getCPUs: () => Array<string | number>;
+    /**
+     * The same shape for interfaces: name, address, netmask, family, mac,
+     * scope id, then the CIDR, per address.
+     */
+    getInterfaceAddresses: () => Array<string | number | boolean>;
+    getUserInfo: () => Record<string, unknown>;
+    /**
+     * A process's niceness. A tab has no scheduler to hand it to, but the pair
+     * still has to agree: a program that sets a priority and reads it back must
+     * see what it set, which is what `test-os.js` checks. The value is this
+     * engine's, per pid, and changes nothing about how anything runs.
+     */
+    getPriority: (pid: number) => number;
+    setPriority: (pid: number, priority: number) => number;
+};
+/**
+ * `internalBinding('credentials')`: the one name `os.js` takes from it. A tab
+ * has no environment of its own to read `TMPDIR` from, so the answer is the
+ * directory the engine's `os` calls its temporary one.
+ */
+export declare const credentialsBinding: {
+    /**
+     * Where a temporary file goes. Node reads `TMPDIR`, then `TMP`, then
+     * `TEMP` from the environment and falls back to the platform's directory,
+     * dropping a trailing slash; a program that sets `TMPDIR` expects to be
+     * obeyed, which is what `test-os.js` checks.
+     */
+    getTempDir: () => string;
+};
+/**
+ * `internalBinding('encoding_binding')`: the punycode conversion `url.js`
+ * makes for a host name, out of the engine's own `punycode`.
+ */
+export declare const encodingBinding: {
+    toASCII: (value: string) => string;
+    toUnicode: (value: string) => string;
+};
+/**
+ * `internalBinding('config')`: the build switches Node's own files read. The
+ * engine has no ICU, so `buffer.transcode` is not defined -- which is what
+ * Node without ICU does, and is the one thing `buffer.js` loses here.
+ */
+export declare const configBinding: {
+    hasIntl: boolean;
+    hasSmallICU: boolean;
+    hasNodeOptions: boolean;
+    hasInspector: boolean;
+    noBrowserGlobals: boolean;
+    bits: number;
+    hasOpenSSL: boolean;
+    fipsMode: boolean;
+    hasDtrace: boolean;
+};
+/**
+ * `internalBinding('fs')`: `internal/net.js`'s `makeSyncWrite` writes a
+ * descriptor synchronously, which Node does only for Windows' stdout and
+ * stderr. The engine's platform is `linux` and nothing reaches it.
+ */
+export declare const fsBinding: {
+    writeBuffer: (_fd: number, _buffer: Uint8Array, _offset: number, _length: number, _position: unknown, _req: unknown, ctx: {
+        errno?: number;
+        syscall?: string;
+    }) => number;
+};
+/**
+ * `internalBinding('types')`: V8's own type tests. The engine answers them
+ * out of the realm's built-ins, and `internal/util/types` is the same object
+ * -- Node's own `util.types` is that binding with a doc comment on it.
+ */
+export { internalUtilTypes as typesBinding } from '../internals/util';
+/**
+ * `internalBinding('string_decoder')`: `internal/util.js` reads the table of
+ * encoding names out of it to normalize one.
+ */
+export declare const stringDecoderBinding: {
+    encodings: string[];
+};
+/**
+ * `internalBinding('trace_events')`: the tracing category buffer
+ * `internal/util/debuglog.js` reads to decide whether a section is traced.
+ * Nothing in a tab is traced, so every category reads 0 -- which is what
+ * `debuglog` checks before it formats anything.
+ */
+export declare const traceEventsBinding: {
+    getCategoryEnabledBuffer: () => Uint8Array;
+    trace: () => void;
+};
+/**
+ * `internalBinding('messaging')`: `internal/util.js` reaches for
+ * `DOMException` through it, which the realm already has.
+ */
+export declare const messagingBinding: {
+    readonly DOMException: unknown;
+};
+/**
+ * `internalBinding('errors')`: the one call `diagnostics_channel.js` makes
+ * into it. A subscriber that throws must not be swallowed and must not take
+ * the publisher with it, so Node hands the error to the process as an
+ * uncaught exception. The engine has that door already -- it is how a run
+ * reports a throw nobody caught -- and this reaches it through the realm's
+ * own process, which is the run's.
+ */
+export declare const errorsBinding: {
+    triggerUncaughtException: (error: unknown, fromPromise?: boolean) => void;
+};
+//# sourceMappingURL=misc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/misc.ts"],"names":[],"mappings":"AAuDA,eAAO,MAAM,gBAAgB,yBAc3B,CAAC;AAUH,eAAO,MAAM,SAAS;IACpB,sEAAsE;4BAChD,MAAM,EAAE;uBACb,MAAM;4BACD,MAAM;qBACb,MAAM;uBACJ,MAAM;sBACP,MAAM;wBACF,YAAY,KAAG,IAAI;mCAIV,MAAM;;IAEnC;;;OAGG;mBACU,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;IAOnC;;;OAGG;iCACwB,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;uBAU1C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACxC;;;;;OAKG;uBACgB,MAAM,KAAG,MAAM;uBACf,MAAM,YAAY,MAAM,KAAG,MAAM;CAKrD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;;;;OAKG;sBACa,MAAM;CAMvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe;qBACT,MAAM,KAAG,MAAM;uBACb,MAAM,KAAG,MAAM;CACnC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAUzB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS;uBACD,MAAM,WAAW,UAAU,WAAW,MAAM,WAAW,MAAM,aACnE,OAAO,QAAQ,OAAO,OAAO;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAG,MAAM;CAKxF,CAAC;AAGF;;;;GAIG;AACH,OAAO,EAAE,iBAAiB,IAAI,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtE;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;CAEhC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;oCACC,UAAU;iBAC7B,IAAI;CAChB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;CAE5B,CAAC;AAGF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;sCACU,OAAO,4BAAwB,IAAI;CAatE,CAAC"}

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

@@ -0,0 +1,84 @@
+/**
+ * `internalBinding('pipe_wrap')`: the same loopback, named by a path.
+ *
+ * VS Code's extension host is started by its parent and connects back to it
+ * over a unix-domain socket path: the parent runs `server.listen(path)` and
+ * the child `net.connect(path)`. A path is a name in one registry here, as a
+ * port is a number in the other; nothing on the path is `ENOENT`, which is
+ * what Node answers, and a path a live server already holds is `EADDRINUSE`.
+ *
+ * The IPC flavour is the same stream with one extra: a write may carry a
+ * handle, which is set on the peer before the peer's read, and that is how
+ * `setupChannel` in `internal/child_process.js` receives a sent socket.
+ */
+import { LibuvStreamWrap, type WriteWrap } from './stream_wrap';
+/** libuv's `uv_pipe_t` flavours, and the two chmod bits `listen` reads. */
+export declare const constants: {
+    SOCKET: number;
+    SERVER: number;
+    IPC: number;
+    UV_READABLE: number;
+    UV_WRITABLE: number;
+};
+/** Node's `PipeConnectWrap`: the request a pipe connect is answered through. */
+export declare class PipeConnectWrap {
+    oncomplete: ((status: number, handle: unknown, req: unknown, readable: boolean, writable: boolean) => void) | null;
+    address: string;
+}
+/** The listening pipe a connect to this path reaches, if any. */
+export declare function listenerOnPath(path: string): Pipe | undefined;
+export declare class Pipe extends LibuvStreamWrap {
+    readonly type: number;
+    listening: boolean;
+    onconnection: ((status: number, clientHandle: Pipe) => void) | null;
+    private path;
+    private ownFd;
+    constructor(type?: number);
+    bind(path: string): number;
+    listen(_backlog: number): number;
+    connect(req: PipeConnectWrap, path: string): number;
+    /**
+     * The descriptor of a handle the engine itself opened — a forked child's IPC
+     * channel among them. There is nothing else to open: the engine has no
+     * descriptors of its own beyond the ones it hands out. Opening one takes
+     * over that end of its pairing, with whatever arrived on it before anyone
+     * opened it, because a child's channel is written to before the child runs.
+     */
+    open(fd: number): number;
+    /** The descriptor this handle can be reached at, for a child's stdio table. */
+    toFd(): number;
+    /** libuv's `dup()`: the same pairing, under the same flavour. */
+    duplicate(): Pipe;
+    /** There is no filesystem entry behind an engine pipe to change the mode of. */
+    fchmod(_mode: number): number;
+    /** Windows asks for more pipe instances; the engine has one realm and one. */
+    setPendingInstances(_count: number): number;
+    /**
+     * An IPC write may carry a handle. The peer is given it before the bytes, so
+     * `setupChannel`'s reader sees `channel.pendingHandle` when the message it
+     * belongs to arrives, which is the order Node delivers them in.
+     *
+     * 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
+     * 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 onCloseHandle(): void;
+}
+declare const _default: {
+    Pipe: typeof Pipe;
+    PipeConnectWrap: typeof PipeConnectWrap;
+    constants: {
+        SOCKET: number;
+        SERVER: number;
+        IPC: number;
+        UV_READABLE: number;
+        UV_WRITABLE: number;
+    };
+};
+export default _default;
+//# sourceMappingURL=pipe_wrap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pipe_wrap.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/pipe_wrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAKhE,2EAA2E;AAC3E,eAAO,MAAM,SAAS;;;;;;CAMrB,CAAC;AAEF,gFAAgF;AAChF,qBAAa,eAAe;IAC1B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;IAC1H,OAAO,SAAM;CACd;AAKD,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAG7D;AAED,qBAAa,IAAK,SAAQ,eAAe;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,SAAS,UAAS;IAClB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;IAE3E,OAAO,CAAC,IAAI,CAAuB;IACnC,OAAO,CAAC,KAAK,CAAuB;gBAExB,IAAI,GAAE,MAAyB;IAK3C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQ1B,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAMhC,OAAO,CAAC,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAoBnD;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IASxB,+EAA+E;IAC/E,IAAI,IAAI,MAAM;IAKd,iEAAiE;IACxD,SAAS,IAAI,IAAI;IAM1B,gFAAgF;IAChF,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAI7B,8EAA8E;IAC9E,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAI3C;;;;;;;;;;;;OAYG;IACM,eAAe,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM;cAgB7D,aAAa,IAAI,IAAI;CAMzC;;;;;;;;;;;;AAED,wBAAoD"}

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

@@ -0,0 +1,173 @@
+/**
+ * `internalBinding('process_wrap')`: one run of the engine, seen as libuv sees
+ * a child process.
+ *
+ * libuv's `uv_spawn` starts a program with its descriptors already wired and
+ * answers through `onexit` when it ends; `uv_process_kill` ends it. That is
+ * the whole of what `internal/child_process.js` asks of a process, and it is
+ * the whole of this file. Nothing here knows about `ChildProcess`, `stdio`
+ * streams, `exec`'s buffering, `fork`'s IPC protocol or what a signal means:
+ * those are Node's own and are vendored.
+ *
+ * What the engine already did for a spawned command stays and becomes this
+ * file's implementation, through the one door the engine's process model
+ * installs below: the routing of a command to the engine's `node`, to a
+ * program the page registered, to a WALI pack, or to the shell. A `pipe`
+ * stdio entry is paired with an end of its own here, so the child's writes to
+ * fd 1 are reads on the parent's handle and the parent's writes to the stdin
+ * handle are the child's fd 0 -- which is what a `uv_stdio_container_t` with
+ * `UV_CREATE_PIPE` is.
+ */
+import { LibuvStreamWrap } from './stream_wrap';
+import { Pipe } from './pipe_wrap';
+import { type OwnedHandle } from './handles';
+import type { ProcessToken } from '../../process-tokens';
+/** One entry of Node's `options.stdio`, as `getValidStdio` builds it. */
+export interface StdioEntry {
+    type: 'pipe' | 'overlapped' | 'ignore' | 'inherit' | 'fd' | 'wrap';
+    handle?: LibuvStreamWrap;
+    fd?: number;
+    ipc?: boolean;
+    readable?: boolean;
+    writable?: boolean;
+}
+/** What `ChildProcess.prototype.spawn` hands `Process.spawn`. */
+export interface ProcessSpawnOptions {
+    file: string;
+    args?: string[];
+    cwd?: string;
+    envPairs?: string[];
+    stdio: StdioEntry[];
+    detached?: boolean;
+    windowsHide?: boolean;
+    uid?: number;
+    gid?: number;
+}
+/** The channel a forked child is started with, at the descriptor it is told. */
+export interface RunChannel {
+    /** The number the child's `NODE_CHANNEL_FD` names. */
+    fd: number;
+    /** The child's end of the channel, which its own `Pipe.open(fd)` finds. */
+    pipe: Pipe;
+    /** `json` or `advanced`, as `NODE_CHANNEL_SERIALIZATION_MODE` says. */
+    serialization: string;
+}
+/** What the binding asks the engine's process model to run. */
+export interface RunRequest {
+    /** The program, as the caller named it: a path, a name, or the shell. */
+    file: string;
+    /** argv, the file first, as Node builds it. */
+    args: string[];
+    cwd?: string;
+    env: Record<string, string>;
+    detached: boolean;
+    /** Where the child's fd 1 goes; null where nothing reads it. */
+    stdout: ((text: string) => void) | null;
+    /** Where the child's fd 2 goes; null where nothing reads it. */
+    stderr: ((text: string) => void) | null;
+    /**
+     * True when fd 2 is a pipe the parent holds. A run that ends uncaught or
+     * with a nonzero `process.exit` on that pipe writes one receipt to the
+     * host realm's console, because the parent may never read the pipe — the
+     * tab's extension host dies this way, its stderr going into `@vscode/spdlog`
+     * which does not load. Inherit and the host's own stdio are false.
+     */
+    stderrIsPipe: boolean;
+    /** True when the child's fd 0 is a pipe whose writer has not closed. */
+    stdinIsPipe: boolean;
+    /** The IPC channel the child is started with, where it has one. */
+    channel?: RunChannel;
+    /** Called once, when the run has ended. */
+    exit(code: number, signal: string | null): void;
+}
+/** One run in flight, as the engine's process model hands it back. */
+export interface StartedRun {
+    /** The run's own name, so a handle it holds is counted as its own. */
+    token: ProcessToken | null;
+    /** The run's process number, which is what its own `process.pid` reports. */
+    pid?: number;
+    /** libuv's `uv_process_kill`: 0, or `UV_ESRCH` for a run already over. */
+    kill(signal: string): number;
+    /** Bytes the parent wrote to the child's fd 0. */
+    writeStdin(bytes: Uint8Array): void;
+    /** The parent closed the child's fd 0. */
+    endStdin(): void;
+}
+/**
+ * The engine's process model, installed by `initChildProcess`. Until it is
+ * there is no engine to run anything, and a spawn answers `ENOENT`, which is
+ * what a machine carrying no such program answers.
+ */
+export interface ProcessRunner {
+    /** Whether the engine has a program under this name at all. */
+    resolves(request: RunRequest): boolean;
+    start(request: RunRequest): StartedRun;
+}
+/** The engine's process model takes this door once, when the VFS is known. */
+export declare function setProcessRunner(next: ProcessRunner): void;
+/**
+ * libuv's `uv_process_t`.
+ *
+ * The handle registers with the run that made it, as every handle here does,
+ * so a parent waiting on a child is not idle: Node's loop holds a process
+ * handle exactly that way, and `unref()` is how a program gives it up.
+ */
+export declare class Process implements OwnedHandle {
+    /** Set by `internal/child_process.js`; the only way an end is reported. */
+    onexit: ((exitCode: number, signalCode: string | null) => void) | null;
+    /**
+     * A process that never started has no pid, and `ChildProcess` copies this
+     * one straight onto itself: a child whose `spawn` answered `ENOENT` reports
+     * `pid === undefined`, as Node's does, rather than a number naming nothing.
+     */
+    pid: number | undefined;
+    private run;
+    private ended;
+    private closed;
+    /** The stdio entries this run was started with, and their far ends. */
+    private stdio;
+    private readonly asyncId;
+    constructor();
+    getAsyncId(): number;
+    ref(): void;
+    unref(): void;
+    hasRef(): boolean;
+    /**
+     * libuv's `uv_spawn`. Answers 0 for a run that started and a `UV_*` code for
+     * one that could not, which is what `ChildProcess.prototype.spawn` turns
+     * into an `error` event or a throw.
+     */
+    spawn(options: ProcessSpawnOptions): number;
+    /**
+     * libuv's `uv_process_kill`: the run ends, or it was over already. Signal 0
+     * is the question "is it still there?", which kills nothing and answers 0
+     * for a run in flight and `ESRCH` for one that has ended.
+     */
+    kill(signal: number | string): number;
+    close(callback?: () => void): void;
+    /**
+     * The other half of a `pipe` entry: the end the child holds. It belongs to
+     * no run -- the parent holds the handle Node gave it and the child holds the
+     * one it opens; this is the wire between them.
+     */
+    private pairFarEnd;
+    /** The far end of fd `index`, whoever holds it now. */
+    private farEndAt;
+    private closeFarEnds;
+    /** The child wrote to fd `index`; the parent's handle reads it. */
+    private toPipe;
+    /** Bytes the parent writes reach the child's fd 0; the parent's EOF ends it. */
+    private readStdinFrom;
+    /**
+     * The run has ended. The child's ends of the pairings close, so the parent's
+     * streams read EOF as they do when a real child's descriptors go, and
+     * `onexit` fires once, after them: Node's `flushStdio` runs on the tick
+     * after `onexit` and must find the bytes already delivered.
+     */
+    private reportExit;
+}
+declare const _default: {
+    Process: typeof Process;
+};
+export default _default;
+//# sourceMappingURL=process_wrap.d.ts.map

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

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

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

@@ -0,0 +1,30 @@
+/** One entry of Node's `options.stdio`, as `getValidStdio(stdio, true)` builds it. */
+interface SyncStdioEntry {
+    type: 'pipe' | 'overlapped' | 'ignore' | 'inherit' | 'fd' | 'wrap';
+    fd?: number;
+    input?: Uint8Array;
+}
+/** What `child_process.js`'s `spawnSync` hands the binding. */
+interface SyncSpawnOptions {
+    file: string;
+    args?: string[];
+    cwd?: string;
+    envPairs?: string[];
+    stdio?: SyncStdioEntry[];
+    maxBuffer?: number;
+    killSignal?: number;
+}
+/** What libuv answers for one synchronous child. */
+interface SyncSpawnResult {
+    pid: number;
+    output: Array<Uint8Array | null> | null;
+    status: number | null;
+    signal: string | null;
+    error?: number;
+}
+declare function spawn(options: SyncSpawnOptions): SyncSpawnResult;
+declare const _default: {
+    spawn: typeof spawn;
+};
+export default _default;
+//# sourceMappingURL=spawn_sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spawn_sync.d.ts","sourceRoot":"","sources":["../../../src/node-lib/binding/spawn_sync.ts"],"names":[],"mappings":"AAiBA,sFAAsF;AACtF,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,QAAQ,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAAC;IACnE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB;AAED,+DAA+D;AAC/D,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,oDAAoD;AACpD,UAAU,eAAe;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;IACxC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAqCD,iBAAS,KAAK,CAAC,OAAO,EAAE,gBAAgB,GAAG,eAAe,CA2DzD;;;;AAED,wBAAyB"}