@volter/tabnode 0.2.14-volter.88

package/dist/node-lib/internals/runtime.d.ts

@@ -0,0 +1,150 @@
+/**
+ * The internals Node's `net` names that are neither vendored nor a binding:
+ * async ids, timers, stream defaults, the option table, and the three
+ * one-line answers (`assert`, `hasObserver`, `isBuildingSnapshot`).
+ *
+ * Each object holds exactly the names the vendored files destructure.
+ */
+export declare const internalAsyncHooks: {
+    symbols: {
+        async_id_symbol: symbol;
+        trigger_async_id_symbol: symbol;
+        owner_symbol: symbol;
+        init_symbol: symbol;
+        destroy_symbol: symbol;
+        async_id_fields: symbol;
+    };
+    newAsyncId: () => number;
+    /**
+     * Node's `getOrSetAsyncId`: the id an object already carries, or a new one
+     * put on it. `_http_server.js` asks it of every socket it accepts, to name
+     * the scope the connection listener runs in.
+     */
+    getOrSetAsyncId: (object: Record<symbol, unknown>) => number;
+    getDefaultTriggerAsyncId: () => number;
+    defaultTriggerAsyncIdScope: <A extends unknown[], R>(_triggerAsyncId: number, block: (...args: A) => R, ...args: A) => R;
+    initHooksExist: () => boolean;
+    afterHooksExist: () => boolean;
+    destroyHooksExist: () => boolean;
+    emitInit: () => void;
+    emitBefore: () => void;
+    emitAfter: () => void;
+    emitDestroy: () => void;
+    hasAsyncIdStack: () => boolean;
+    registerDestroyHook: () => void;
+};
+export declare class AsyncResource {
+    #private;
+    constructor(_type: string, options?: {
+        triggerAsyncId?: number;
+        requireManualDestroy?: boolean;
+    });
+    runInAsyncScope<T>(fn: (...args: never[]) => T, thisArg?: unknown, ...args: never[]): T;
+    emitDestroy(): this;
+    asyncId(): number;
+    triggerAsyncId(): number;
+    static bind<T extends (...args: never[]) => unknown>(fn: T, _type?: string): T;
+}
+/**
+ * What `setUnrefTimeout` answers: a timer that can be refreshed in place, as
+ * Node's `Timeout` can, and that `timers.clearTimeout` here knows how to stop.
+ */
+export declare class UnrefTimeout {
+    private id;
+    private readonly onTimeout;
+    private readonly msecs;
+    constructor(onTimeout: () => void, msecs: number);
+    refresh(): this;
+    stop(): void;
+    ref(): this;
+    unref(): this;
+    hasRef(): boolean;
+}
+export declare const TIMEOUT_MAX: number;
+export declare const internalTimers: {
+    kTimeout: symbol;
+    TIMEOUT_MAX: number;
+    setUnrefTimeout: (fn: () => void, msecs: number) => UnrefTimeout;
+    /** Node's `getTimerDuration`: a number in range, and 1 for anything under it. */
+    getTimerDuration(msecs: unknown, name: string): number;
+};
+/** `internal/streams/state`: Node's default high-water marks. */
+export declare const internalStreamsState: {
+    getDefaultHighWaterMark: (objectMode?: boolean) => number;
+    setDefaultHighWaterMark: () => void;
+};
+/** `internal/process/task_queues`: the realm's own microtask queue. */
+export declare const internalTaskQueues: {
+    queueMicrotask: (fn: () => void) => void;
+    setHasTickScheduled: () => void;
+    runNextTicks: () => void;
+};
+export declare const internalEventTarget: {
+    kResistStopPropagation: symbol;
+    /** `internal/streams/operators.js` marks its abort listener weak with this. */
+    kWeakHandler: symbol;
+    /**
+     * Whether a thing is an `EventTarget`. `events.js` asks before it treats a
+     * value as one -- `once`, `on`, `getEventListeners` and `setMaxListeners`
+     * all take either an emitter or a target. Node's own `EventTarget` is a
+     * class in `internal/event_target.js`; the engine's is the realm's, which
+     * is where that class comes from in the first place.
+     */
+    isEventTarget: (value: unknown) => boolean;
+    /**
+     * The map Node keeps its own EventTarget's listeners in.
+     *
+     * THE LOSS, named: the realm's `EventTarget` keeps its listeners where no
+     * JavaScript can reach them. The DOM has no way to ask what is listening --
+     * `addEventListener` is a door in, and there is no door out -- so
+     * `events.getEventListeners(target)` cannot answer for one. It reads this
+     * map unguarded, so every target answers with an empty one: the call
+     * reports no listeners rather than throwing at a program that asked a fair
+     * question. An `EventEmitter` is unaffected; it answers from its own
+     * `listeners()`, which is the branch above this one in `events.js`.
+     */
+    kEvents: symbol;
+    kNewListener: symbol;
+    kRemoveListener: symbol;
+};
+export declare const internalOptions: {
+    getOptionValue: (name: string) => unknown;
+    getEmbedderOptions: () => {
+        shouldNotRegisterESMLoader: boolean;
+        noGlobalSearchPaths: boolean;
+        noBrowserGlobals: boolean;
+    };
+};
+/** `internal/perf/observe`: nothing observes `net` in the engine. */
+export declare const internalPerfObserve: {
+    hasObserver: () => boolean;
+    startPerf: () => void;
+    stopPerf: () => void;
+};
+/** `internal/assert`: Node's internal assertion, which no program should ever see. */
+export declare function internalAssert(value: unknown, message?: string): asserts value;
+export declare namespace internalAssert {
+    var fail: (message?: string) => never;
+    var ok: typeof internalAssert;
+}
+/** `internal/v8/startup_snapshot`: the engine never builds one. */
+export declare const internalStartupSnapshot: {
+    namespace: {
+        isBuildingSnapshot: () => boolean;
+        addSerializeCallback: () => void;
+        addDeserializeCallback: () => void;
+        setDeserializeMainFunction: () => void;
+    };
+    runDeserializeCallbacks: () => void;
+};
+/**
+ * `internal/process/permission`: the engine runs no permission model, so
+ * nothing is denied and there are no flags for `child_process.js` to copy
+ * into a child's `NODE_OPTIONS`.
+ */
+export declare const internalPermission: {
+    isEnabled: () => boolean;
+    has: () => boolean;
+    availableFlags: () => string[];
+};
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/node-lib/internals/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmBH,eAAO,MAAM,kBAAkB;;;;;;;;;sBAEb,MAAM;IACtB;;;;OAIG;8BACuB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM;oCAM5B,MAAM;iCACP,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,mBAChC,MAAM,SAAS,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,KAC5D,CAAC;0BACgB,OAAO;2BACN,OAAO;6BACL,OAAO;oBAChB,IAAI;sBACF,IAAI;qBACL,IAAI;uBACF,IAAI;2BACA,OAAO;+BACH,IAAI;CAC9B,CAAC;AAWF,qBAAa,aAAa;;gBAIZ,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,oBAAoB,CAAC,EAAE,OAAO,CAAA;KAAE;IAKhG,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC;IAIvF,WAAW,IAAI,IAAI;IACnB,OAAO,IAAI,MAAM;IACjB,cAAc,IAAI,MAAM;IAExB,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC;CAG/E;AA2BD;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,EAAE,CAAiB;IAC3B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAa;IACvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,SAAS,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM;IAMhD,OAAO,IAAI,IAAI;IAMf,IAAI,IAAI,IAAI;IAKZ,GAAG,IAAI,IAAI;IACX,KAAK,IAAI,IAAI;IACb,MAAM,IAAI,OAAO;CAClB;AAED,eAAO,MAAM,WAAW,QAAc,CAAC;AAEvC,eAAO,MAAM,cAAc;;;0BAGH,MAAM,IAAI,SAAS,MAAM,KAAG,YAAY;IAC9D,iFAAiF;4BACzD,OAAO,QAAQ,MAAM,GAAG,MAAM;CAWvD,CAAC;AAEF,iEAAiE;AACjE,eAAO,MAAM,oBAAoB;2CACQ,OAAO,KAAG,MAAM;mCAC1B,IAAI;CAClC,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,kBAAkB;yBACR,MAAM,IAAI,KAAG,IAAI;+BACb,IAAI;wBACX,IAAI;CACvB,CAAC;AAkBF,eAAO,MAAM,mBAAmB;;IAE9B,+EAA+E;;IAE/E;;;;;;OAMG;2BACoB,OAAO,KAAG,OAAO;IAExC;;;;;;;;;;;OAWG;;;;CAIJ,CAAC;AAiBF,eAAO,MAAM,eAAe;2BACH,MAAM,KAAG,OAAO;;;;;;CAExC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,mBAAmB;uBACb,OAAO;qBACT,IAAI;oBACL,IAAI;CACnB,CAAC;AAEF,sFAAsF;AACtF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAE9E;yBAFe,cAAc;yBAGG,MAAM,KAAG,KAAK;;;AAK/C,mEAAmE;AACnE,eAAO,MAAM,uBAAuB;;kCAER,OAAO;oCACL,IAAI;sCACF,IAAI;0CACA,IAAI;;mCAET,IAAI;CAClC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;qBACd,OAAO;eACb,OAAO;0BACI,MAAM,EAAE;CAC7B,CAAC"}

package/dist/node-lib/internals/util.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `internal/util/types`, bound by hand -- which is also `util.types`, because
+ * Node's `util.types` IS this module.
+ *
+ * Node's own is `internalBinding('types')`, V8 asking a value what it is from
+ * the outside. The engine asks the one question a tab can ask: the value's
+ * own `Object.prototype.toString` tag, which V8 fills in from the same
+ * internal type and which a program cannot forge without saying so. A
+ * `Symbol.toStringTag` a program sets IS such a statement, and Node's answer
+ * and this one differ only for an object that has lied about itself.
+ *
+ * Two exceptions, each for a reason a tab cannot get around:
+ *
+ * A `Proxy` shows the tag of the thing it wraps, by design, so no tag can
+ * find one. The engine's realm records every proxy it makes -- `runtime.ts`
+ * replaces the realm's `Proxy` for a guest -- and `isProxy` answers from that
+ * record. undici's `Headers` guard asks it of every init it converts, and a
+ * proxy the host made before the guest's realm existed is not in the record.
+ *
+ * `isExternal` is always false: nothing in a tab is a native handle.
+ *
+ * `internal/util` itself is no longer here: it is Node's own file now, and
+ * every name the vendored files used to take from a hand-bound object is
+ * Node's own code, on the bindings under `../binding/`.
+ */
+/**
+ * Every proxy a guest's realm has made. `runtime.ts` fills it, from the
+ * `Proxy` it installs for a guest; this module reads it.
+ */
+export declare const recordedProxies: WeakSet<object>;
+/** `internal/util/types`, which is `util.types`. */
+export declare const internalUtilTypes: Record<string, (value: unknown) => boolean>;
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/node-lib/internals/util.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe,iBAAwB,CAAC;AAmBrD,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAqCzE,CAAC"}

package/dist/node-lib/lazy.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A vendored module object, whose properties are read when they are asked for.
+ *
+ * A module object is a program's to write on, and packages do: `graceful-fs`
+ * -- which half of npm loads, openvscode-server through `fs-extra` and
+ * `@vscode/deviceid` -- defines `Symbol.for('graceful-fs.queue')` on `fs` with
+ * `Object.defineProperty` and then clones the module, which walks its keys.
+ * Every trap here read the loaded module and none read the proxy's own target,
+ * where a define with no trap of its own lands: the read came back
+ * `undefined`, `key in fs` answered false, and `Reflect.ownKeys(fs)` threw
+ * `'ownKeys' on proxy: trap result did not include
+ * 'Symbol(graceful-fs.queue)'` -- a proxy may neither hide nor deny a
+ * non-configurable own key of its target. graceful-fs threw out of its own
+ * module load, so every program that loads it died there: in the substrate's
+ * tab, openvscode-server's server at boot and its extension host, which exited
+ * 1 without a word because a forked host's console goes to its parent over IPC
+ * and the server drops those messages.
+ *
+ * So a define lands on the module, as it would in Node, and a
+ * non-configurable one lands on the target as well because the proxy has to
+ * report it from there; every read answers the target first and the module
+ * after. This is the shape the guest global's proxy in `src/runtime.ts` uses,
+ * for the same reason.
+ */
+export declare function lazyModule<T extends object>(name: string): T;
+/**
+ * One export of a vendored module that is a class or a function: callable,
+ * constructible, and the same object to `instanceof` as the real one.
+ */
+export declare function lazyExport<T>(name: string, key: string): T;
+//# sourceMappingURL=lazy.d.ts.map

package/dist/node-lib/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/node-lib/lazy.ts"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAsC5D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,CA2D1D"}

package/dist/node-lib/load.d.ts

@@ -0,0 +1,27 @@
+export declare function primordialsOf(): Record<string, unknown>;
+export declare function nodeLibProcessOf(): Record<string, unknown>;
+/**
+ * A vendored file, evaluated as Node's `BuiltinModule.compileForInternalLoader`
+ * evaluates one and cached under its name. The record is cached before the
+ * body runs, as Node's is, so a cycle between two vendored files sees a
+ * partly-filled `exports` rather than looping.
+ */
+export declare function loadNodeLib(name: string): unknown;
+export declare function esmNamespaceOf(mod: unknown): Record<string, unknown>;
+/** Node's `module.syncBuiltinESMExports`: newly assigned CJS keys appear on the namespace. */
+export declare function syncBuiltinESMExports(): void;
+export declare function loadNodeLibInstance(name: string): unknown;
+export declare function loadNodeLibFor(owner: object, name: string): unknown;
+/**
+ * What a hand-bound internal, a binding or `./lazy.ts` calls to reach a
+ * vendored file.
+ *
+ * A function DECLARATION, not a `const`: a name that stands for a vendored
+ * class is read while the bundle is still evaluating -- `class Foo extends
+ * EventEmitter` runs `getPrototypeOf` on the proxy at the moment the class is
+ * defined, which is module-evaluation time, before this file's own bindings
+ * are initialized. A hoisted function is already callable then; a `const` is
+ * in its temporal dead zone and the engine failed to load at all.
+ */
+export declare function nodeLibInternalRequire(specifier: string): unknown;
+//# sourceMappingURL=load.d.ts.map

package/dist/node-lib/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/node-lib/load.ts"],"names":[],"mappings":"AAyCA,wBAAgB,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQvD;AA8ED,wBAAgB,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsB1D;AAgBD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAkBjD;AAqBD,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgBpE;AAED,8FAA8F;AAC9F,wBAAgB,qBAAqB,IAAI,IAAI,CAY5C;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIzD;AAcD,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAkBnE;AAgGD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEjE"}

package/dist/node-lib/module-hooks.d.ts

@@ -0,0 +1,89 @@
+/** A resolve hook's answer, as `internal/modules/esm/hooks.js` validates one. */
+export interface ResolveResult {
+    url: string;
+    format?: string;
+    importAttributes?: Record<string, string>;
+    shortCircuit?: boolean;
+}
+/** A load hook's answer. */
+export interface LoadResult {
+    format?: string;
+    source?: string | ArrayBuffer | ArrayBufferView | null;
+    shortCircuit?: boolean;
+}
+type ResolveContext = {
+    parentURL?: string;
+    importAttributes?: Record<string, string>;
+    conditions?: string[];
+};
+type LoadContext = {
+    format?: string;
+    importAttributes?: Record<string, string>;
+    conditions?: string[];
+};
+/** What the vendored `internal/modules/customization_hooks.js` exports. */
+interface CustomizationHooks {
+    resolveHooks: unknown[];
+    loadHooks: unknown[];
+    registerHooks(hooks: {
+        resolve?: unknown;
+        load?: unknown;
+    }): {
+        deregister(): void;
+    };
+    resolveWithHooks(specifier: string, parentURL: string | undefined, importAttributes: Record<string, string> | undefined, conditions: string[], defaultResolve: (specifier: string, context: ResolveContext) => ResolveResult): ResolveResult;
+    loadWithHooks(url: string, format: string | undefined, importAttributes: Record<string, string> | undefined, conditions: string[], defaultLoad: (url: string, context: LoadContext) => LoadResult): LoadResult;
+    convertCJSFilenameToURL(filename: string): string;
+    convertURLToCJSFilename(url: string): string;
+}
+/** The conditions a `require` resolves under, as Node's `getCjsConditions()` reports them. */
+declare const CJS_CONDITIONS: string[];
+/**
+ * Node's own `import()` conditions. The engine resolves an import the way it
+ * resolves a require, so this is what a hook is told, not a second resolver.
+ */
+declare const ESM_CONDITIONS: string[];
+export declare class RunModuleHooks {
+    #private;
+    /** The vendored file's own instance, this run's alone. */
+    readonly sync: CustomizationHooks;
+    /**
+     * Which chain has anything in it. The loader asks before it builds
+     * anything: a run that registered no hook pays for none, which is the fast
+     * path Node keeps in `Module._load` and `loadSource` too.
+     */
+    get hasSyncResolve(): boolean;
+    get hasSyncLoad(): boolean;
+    get hasAsyncResolve(): boolean;
+    get hasAsyncLoad(): boolean;
+    /**
+     * `module.register(specifier[, parentURL][, options])`.
+     *
+     * The argument shuffle is Node's own (`internal/modules/esm/loader.js`): a
+     * second argument that is an object and not a URL is the options. The hook
+     * module is loaded through the engine's own loader, which is what answers a
+     * `data:` URL, a `file:` URL and a bare specifier alike.
+     */
+    register(specifier: unknown, parentURL: unknown, options: {
+        parentURL?: unknown;
+        data?: unknown;
+        transferList?: unknown;
+    } | undefined, load: (specifier: string, from: string) => unknown): void;
+    /**
+     * `Hooks.addCustomLoader`: the three names a hook module may export, each
+     * onto its chain, and `initialize` called with the data.
+     */
+    addLoader(url: string, exports: Record<string, unknown> | undefined, data: unknown): void;
+    /** Every `initialize` still settling, awaited before the chain serves anything. */
+    ready(): Promise<void>;
+    /**
+     * The resolve chain of `module.register`, awaited. `defaultResolve` is the
+     * engine's own resolution, the bottom of the chain.
+     */
+    resolve(specifier: string, parentURL: string | undefined, importAttributes: Record<string, string> | undefined, defaultResolve: (specifier: string, context: ResolveContext) => ResolveResult | Promise<ResolveResult>): Promise<ResolveResult>;
+    /** The load chain of `module.register`, awaited. */
+    load(url: string, format: string | undefined, importAttributes: Record<string, string> | undefined, defaultLoad: (url: string, context: LoadContext) => LoadResult | Promise<LoadResult>): Promise<LoadResult>;
+}
+export { CJS_CONDITIONS, ESM_CONDITIONS };
+export type { ResolveContext, LoadContext };
+//# sourceMappingURL=module-hooks.d.ts.map

package/dist/node-lib/module-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-hooks.d.ts","sourceRoot":"","sources":["../../src/node-lib/module-hooks.ts"],"names":[],"mappings":"AAoCA,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,4BAA4B;AAC5B,MAAM,WAAW,UAAU;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,eAAe,GAAG,IAAI,CAAC;IACvD,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,KAAK,cAAc,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAC/G,KAAK,WAAW,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAMzG,2EAA2E;AAC3E,UAAU,kBAAkB;IAC1B,YAAY,EAAE,OAAO,EAAE,CAAC;IACxB,SAAS,EAAE,OAAO,EAAE,CAAC;IACrB,aAAa,CAAC,KAAK,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG;QAAE,UAAU,IAAI,IAAI,CAAA;KAAE,CAAC;IACpF,gBAAgB,CACd,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACtG,UAAU,EAAE,MAAM,EAAE,EAAE,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,KAAK,aAAa,GAClG,aAAa,CAAC;IACjB,aAAa,CACX,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EAC7F,UAAU,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,KAAK,UAAU,GACnF,UAAU,CAAC;IACd,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAClD,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9C;AAcD,8FAA8F;AAC9F,QAAA,MAAM,cAAc,UAAqC,CAAC;AAE1D;;;GAGG;AACH,QAAA,MAAM,cAAc,UAAqB,CAAC;AAE1C,qBAAa,cAAc;;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAqF;IAMtH;;;;OAIG;IACH,IAAI,cAAc,IAAI,OAAO,CAA8C;IAC3E,IAAI,WAAW,IAAI,OAAO,CAA2C;IACrE,IAAI,eAAe,IAAI,OAAO,CAA0C;IACxE,IAAI,YAAY,IAAI,OAAO,CAAuC;IAElE;;;;;;;OAOG;IACH,QAAQ,CACN,SAAS,EAAE,OAAO,EAClB,SAAS,EAAE,OAAO,EAClB,OAAO,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,EACpF,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,GACjD,IAAI;IAWP;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI;IA4BzF,mFAAmF;IAC7E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;;OAGG;IACG,OAAO,CACX,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACpD,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,KAAK,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,GACrG,OAAO,CAAC,aAAa,CAAC;IAUzB,oDAAoD;IAC9C,IAAI,CACR,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACpD,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GACnF,OAAO,CAAC,UAAU,CAAC;CAuDvB;AAmBD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC;AAC1C,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC"}

package/dist/node-lib/net-module.d.ts

@@ -0,0 +1,181 @@
+import type { DuplexLike } from './stream-module';
+import type { EventEmitter } from './events-module';
+import type { ProcessToken } from '../process-tokens';
+import { __ownedHandleCount, __releaseOwnedHandles } from './binding/handles';
+import { LibuvStreamWrap } from './binding/stream_wrap';
+export type { ProcessToken };
+/** Node's `server.address()` / `socket.address()` for a TCP endpoint. */
+export interface AddressInfo {
+    address: string;
+    family: string;
+    port: number;
+}
+/** What a program hands `new net.Socket(...)`. */
+export interface SocketOptions {
+    fd?: number;
+    handle?: unknown;
+    allowHalfOpen?: boolean;
+    readable?: boolean;
+    writable?: boolean;
+    signal?: AbortSignal;
+    noDelay?: boolean;
+    keepAlive?: boolean;
+    keepAliveInitialDelay?: number;
+    onread?: {
+        buffer: Uint8Array | (() => Uint8Array);
+        callback: (bytes: number, buffer: Uint8Array) => boolean;
+    };
+}
+/** What a program hands `net.connect(...)`. */
+export interface ConnectOptions {
+    port?: number;
+    host?: string;
+    path?: string;
+    localAddress?: string;
+    localPort?: number;
+    family?: number;
+    timeout?: number;
+    autoSelectFamily?: boolean;
+    autoSelectFamilyAttemptTimeout?: number;
+    signal?: AbortSignal;
+    noDelay?: boolean;
+    keepAlive?: boolean;
+    keepAliveInitialDelay?: number;
+}
+/** What a program hands `server.listen(...)`. */
+export interface ListenOptions {
+    port?: number;
+    host?: string;
+    path?: string;
+    backlog?: number;
+    exclusive?: boolean;
+    readableAll?: boolean;
+    writableAll?: boolean;
+    ipv6Only?: boolean;
+    reusePort?: boolean;
+    signal?: AbortSignal;
+}
+/** Node's `net.Socket`, as the engine's own parts read it. */
+export interface Socket extends DuplexLike {
+    connecting: boolean;
+    pending: boolean;
+    readyState: string;
+    bufferSize: number | undefined;
+    bytesRead: number;
+    bytesWritten: number | undefined;
+    localAddress: string | undefined;
+    localPort: number | undefined;
+    localFamily: string | undefined;
+    remoteAddress: string | undefined;
+    remotePort: number | undefined;
+    remoteFamily: string | undefined;
+    timeout?: number;
+    server: Server | null;
+    _server: Server | null;
+    /** The libuv handle this socket is a stream over; null once it is destroyed. */
+    _handle: LibuvStreamWrap | null;
+    address(): AddressInfo | Record<string, never>;
+    connect(options: ConnectOptions | number | string, host?: string | (() => void), connectListener?: () => void): this;
+    setTimeout(timeout: number, callback?: () => void): this;
+    setNoDelay(enable?: boolean): this;
+    setKeepAlive(enable?: boolean, initialDelay?: number): this;
+    resetAndDestroy(): this;
+    destroySoon(): void;
+    ref(): this;
+    unref(): this;
+    cork(): void;
+    uncork(): void;
+}
+/** Node's `net.Server`. */
+export interface Server extends EventEmitter {
+    listening: boolean;
+    maxConnections?: number;
+    allowHalfOpen: boolean;
+    pauseOnConnect: boolean;
+    /** The libuv handle the server listens on; null once it is closed. */
+    _handle: LibuvStreamWrap | null;
+    address(): AddressInfo | string | null;
+    listen(...args: unknown[]): this;
+    close(callback?: (error?: Error) => void): this;
+    getConnections(callback: (error: Error | null, count: number) => void): this;
+    ref(): this;
+    unref(): this;
+}
+/** The whole of Node's `net` module object. */
+export interface NetModule {
+    Socket: new (options?: SocketOptions | number) => Socket;
+    Server: new (options?: unknown, connectionListener?: (socket: Socket) => void) => Server;
+    Stream: new (options?: SocketOptions | number) => Socket;
+    createServer(options?: unknown, connectionListener?: (socket: Socket) => void): Server;
+    createConnection(...args: unknown[]): Socket;
+    connect(...args: unknown[]): Socket;
+    isIP(input: string): number;
+    isIPv4(input: string): boolean;
+    isIPv6(input: string): boolean;
+    BlockList: new () => unknown;
+    SocketAddress: new (options?: unknown) => unknown;
+    getDefaultAutoSelectFamily(): boolean;
+    setDefaultAutoSelectFamily(value: boolean): void;
+    getDefaultAutoSelectFamilyAttemptTimeout(): number;
+    setDefaultAutoSelectFamilyAttemptTimeout(value: number): void;
+    _normalizeArgs(args: unknown[]): unknown[];
+    _createServerHandle(...args: unknown[]): unknown;
+    _setSimultaneousAccepts(handle?: unknown): void;
+}
+/** The loaded module: Node's own `net.js`, evaluated once. */
+export declare const netModule: NetModule;
+export declare const Socket: new (options?: SocketOptions | number) => Socket;
+export declare const Server: new (options?: unknown, connectionListener?: (socket: Socket) => void) => Server;
+export declare const createServer: (options?: unknown, connectionListener?: (socket: Socket) => void) => Server;
+export declare const createConnection: (...args: unknown[]) => Socket;
+export declare const connect: (...args: unknown[]) => Socket;
+export declare const isIP: (input: string) => number;
+export declare const isIPv4: (input: string) => boolean;
+export declare const isIPv6: (input: string) => boolean;
+/** How many ref'd handles the named run holds, as Node's loop counts them. */
+export { __ownedHandleCount, __releaseOwnedHandles };
+/** The ports a run is listening on, and the release of them when it ends. */
+export { __ownedServerPorts, __releaseOwnedServers } from './binding/handles';
+/** Who is told when a guest starts or stops listening on a port. */
+export { setPortWatchers, listenerOnPort } from './binding/tcp_wrap';
+/**
+ * A socket another run received over IPC is that run's: its handle moves, so
+ * the run whose end closes it is the run that holds it. A socket with no
+ * handle -- one already destroyed -- is nothing to move.
+ */
+export declare function __adoptSocket(socket: Socket, token: ProcessToken | null): void;
+/** The same for a listening server a run received. */
+export declare function __adoptServerHandle(server: Server, token: ProcessToken | null): void;
+/** The bridge's end of a connection whose other end is a `net.Socket`. */
+export interface BridgeEnd {
+    /** Bytes the socket's owner wrote, as the engine hands them over. */
+    onData(listener: (bytes: Uint8Array) => void): void;
+    /** Bytes arriving from the far side, read by the socket as its own. */
+    push(bytes: Uint8Array): void;
+    /** The far side will write no more; the socket reads EOF. */
+    end(): void;
+    /** Close the pairing from this end. */
+    destroy(): void;
+    readonly destroyed: boolean;
+}
+/**
+ * A connection with a `net.Socket` on one end and the page bridge on the
+ * other.
+ *
+ * An `upgrade` listener is handed the connection's own `net.Socket` by Node,
+ * and a program does everything a socket can with it: pause, resume, pipe,
+ * `setEncoding`, `bufferSize`, and being sent to a child over IPC. The engine
+ * used to hand it an object with `write` and `emit('data')` overridden, which
+ * was no socket at all -- VS Code's `NodeSocket.drain` waits on
+ * `bufferSize === 0` and a `drain` event, and waited forever. So the bridge
+ * is a handle now, the far end of a real pairing, and what it holds is the
+ * two calls a bridge needs and nothing of the socket's.
+ *
+ * The bridge's own handle is unref'd: a page's connection is not a guest's
+ * work, and the socket the guest holds is what keeps the guest's run alive.
+ */
+export declare function __bridgeConnection(local: AddressInfo, remote: AddressInfo): {
+    socket: Socket;
+    bridge: BridgeEnd;
+};
+//# sourceMappingURL=net-module.d.ts.map

package/dist/node-lib/net-module.d.ts.map

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

package/dist/node-lib/node-versions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What this engine reports as its Node, in one place.
+ *
+ * Two readers need the same answer and neither may import the other: a guest's
+ * `process`, built in `src/shims/process.ts` per run, and the process a
+ * vendored file is handed where the realm has none, built in
+ * `src/node-lib/load.ts` (`shims/process.ts` imports `node-lib/events-module`,
+ * so the loader cannot import it back). This file imports nothing, so both
+ * can.
+ */
+/** The version a guest reports where its image names none; the current LTS. */
+export declare const NODE_LTS_VERSION = "22.12.0";
+/**
+ * `process.versions`, as this engine answers it. `webcontainer` says what this
+ * runtime is, Node in a browser tab: a program that keeps a wasm build of its
+ * native binding for such runtimes, Next's compiler among them, reads that
+ * name and reaches for the wasm build before trying to load a binary no tab
+ * can run.
+ */
+export declare function nodeVersions(node?: string): {
+    node: string;
+    v8: string;
+    uv: string;
+    webcontainer: string;
+    openssl: string;
+};
+//# sourceMappingURL=node-versions.d.ts.map

package/dist/node-lib/node-versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-versions.d.ts","sourceRoot":"","sources":["../../src/node-lib/node-versions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAE1C;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,GAAE,MAAyB,GAAG;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,CAMA"}

package/dist/node-lib/public-modules.d.ts

@@ -0,0 +1,2 @@
+export declare function nodeLibPublic(name: string): (() => unknown) | undefined;
+//# sourceMappingURL=public-modules.d.ts.map

package/dist/node-lib/public-modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-modules.d.ts","sourceRoot":"","sources":["../../src/node-lib/public-modules.ts"],"names":[],"mappings":"AA6EA,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CA+BvE"}

package/dist/node-lib/require-hook.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The one way a binding or a hand-bound internal reaches a vendored file.
+ *
+ * It exists as a file of its own, importing nothing, because the loader
+ * imports the binding and the internals to build its tables: a binding that
+ * imported the loader back put the two in a cycle, and which of them a bundler
+ * evaluates first is then its own decision. The loader installs itself here
+ * when it loads; everything below it asks through this and is a leaf.
+ */
+export type LibRequire = (specifier: string) => unknown;
+/** The loader takes this door once, at the bottom of its own body. */
+export declare function setLibRequire(lib: LibRequire): void;
+/** A vendored Node file, by the name Node's own `require` calls it. */
+export declare function libRequire(specifier: string): unknown;
+//# sourceMappingURL=require-hook.d.ts.map

package/dist/node-lib/require-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-hook.d.ts","sourceRoot":"","sources":["../../src/node-lib/require-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;AAMxD,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAEnD;AAED,uEAAuE;AACvE,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAKrD"}

package/dist/node-lib/small-modules.d.ts

@@ -0,0 +1,16 @@
+/** `assert` is a callable module -- `assert(value)` is `assert.ok(value)`. */
+export declare const assertModule: Record<string, unknown>;
+export declare const querystringModule: Record<string, unknown>;
+export declare const punycodeModule: Record<string, unknown>;
+export declare const constantsModule: Record<string, unknown>;
+export declare const diagnosticsChannelModule: Record<string, unknown>;
+/** `os`, on a binding of the engine's own host answers. */
+export declare const osModule: Record<string, unknown>;
+/** `tty`, on the `tty_wrap` binding `child_process` already brought. */
+export declare const ttyModule: Record<string, unknown>;
+/** `readline`, with Node's own `Interface`, its key handling and its promises. */
+export declare const readlineModule: Record<string, unknown>;
+export declare const readlinePromisesModule: Record<string, unknown>;
+/** `zlib`, on zlib's own inflate and deflate. */
+export declare const zlibModule: Record<string, unknown>;
+//# sourceMappingURL=small-modules.d.ts.map

package/dist/node-lib/small-modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"small-modules.d.ts","sourceRoot":"","sources":["../../src/node-lib/small-modules.ts"],"names":[],"mappings":"AAgBA,8EAA8E;AAC9E,eAAO,MAAM,YAAY,EAAqE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACtH,eAAO,MAAM,iBAAiB,yBAAqD,CAAC;AACpF,eAAO,MAAM,cAAc,yBAAkD,CAAC;AAC9E,eAAO,MAAM,eAAe,yBAAmD,CAAC;AAChF,eAAO,MAAM,wBAAwB,yBAA6D,CAAC;AAEnG,2DAA2D;AAC3D,eAAO,MAAM,QAAQ,yBAA4C,CAAC;AAElE,wEAAwE;AACxE,eAAO,MAAM,SAAS,yBAA6C,CAAC;AAEpE,kFAAkF;AAClF,eAAO,MAAM,cAAc,yBAAkD,CAAC;AAC9E,eAAO,MAAM,sBAAsB,yBAA2D,CAAC;AAE/F,iDAAiD;AACjD,eAAO,MAAM,UAAU,yBAA8C,CAAC"}

package/dist/node-lib/sources.d.ts

@@ -0,0 +1,4 @@
+/** The Node the vendored files come from, reported in `FORK.md`'s table. */
+export declare const NODE_LIB_VERSION = "v22.18.0";
+export declare const NODE_LIB_SOURCES: Record<string, string>;
+//# sourceMappingURL=sources.d.ts.map

package/dist/node-lib/sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sources.d.ts","sourceRoot":"","sources":["../../src/node-lib/sources.ts"],"names":[],"mappings":"AAuGA,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,aAAa,CAAC;AAE3C,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA6FnD,CAAC"}