@volter/tabnode 0.2.14-volter.88

package/src/node-lib/internals/addresses.ts

@@ -0,0 +1,159 @@
+/**
+ * `internal/socketaddress` and `internal/blocklist`, bound by hand.
+ *
+ * `net.js` exposes both as `net.SocketAddress` and `net.BlockList` and asks
+ * one thing of each: `BlockList.isBlockList(value)` when a program hands one
+ * to `createServer` or `connect`, and `blockList.check(address, family)` for
+ * every connection. They validate and hold, and the check is address
+ * arithmetic; nothing here reaches the network, because there is none.
+ */
+import { libRequire } from '../require-hook';
+import { convertIpv6StringToBuffer } from '../binding/cares_wrap';
+
+function isIP(value: string): number {
+  return (libRequire('internal/net') as { isIP(s: string): number }).isIP(value);
+}
+
+/** An address as a big integer, so a range and a subnet are comparisons. */
+function toNumber(address: string, family: string): bigint {
+  if (family === 'ipv4') {
+    let value = 0n;
+    for (const part of address.split('.')) value = (value << 8n) | BigInt(Number(part) & 255);
+    return value;
+  }
+  let value = 0n;
+  for (const byte of convertIpv6StringToBuffer(address)) value = (value << 8n) | BigInt(byte);
+  return value;
+}
+
+const kAddress = Symbol('address');
+const kPort = Symbol('port');
+const kFamily = Symbol('family');
+const kFlowLabel = Symbol('flowlabel');
+
+export class SocketAddress {
+  constructor(options: { address?: string; port?: number; family?: string; flowlabel?: number } = {}) {
+    const family = (options.family ?? 'ipv4').toLowerCase();
+    if (family !== 'ipv4' && family !== 'ipv6') {
+      throw Object.assign(new TypeError(`The argument 'options.family' must be one of: 'ipv4', 'ipv6'. Received '${options.family}'`), { code: 'ERR_INVALID_ARG_VALUE' });
+    }
+    const address = options.address ?? (family === 'ipv4' ? '127.0.0.1' : '::');
+    if (typeof address !== 'string' || isIP(address) === 0) {
+      throw Object.assign(new TypeError(`The argument 'options.address' is invalid. Received '${address}'`), { code: 'ERR_INVALID_ARG_VALUE' });
+    }
+    const port = options.port ?? 0;
+    if (typeof port !== 'number' || !Number.isInteger(port) || port < 0 || port > 65535) {
+      throw Object.assign(new RangeError(`The value of "options.port" is out of range. It must be >= 0 && <= 65535. Received ${port}`), { code: 'ERR_OUT_OF_RANGE' });
+    }
+    (this as Record<symbol, unknown>)[kAddress] = address;
+    (this as Record<symbol, unknown>)[kPort] = port;
+    (this as Record<symbol, unknown>)[kFamily] = family;
+    (this as Record<symbol, unknown>)[kFlowLabel] = options.flowlabel ?? 0;
+  }
+
+  get address(): string { return (this as unknown as Record<symbol, string>)[kAddress]; }
+  get port(): number { return (this as unknown as Record<symbol, number>)[kPort]; }
+  get family(): string { return (this as unknown as Record<symbol, string>)[kFamily]; }
+  get flowlabel(): number { return (this as unknown as Record<symbol, number>)[kFlowLabel]; }
+
+  toJSON(): { address: string; port: number; family: string; flowlabel: number } {
+    return { address: this.address, port: this.port, family: this.family, flowlabel: this.flowlabel };
+  }
+
+  static isSocketAddress(value: unknown): value is SocketAddress {
+    return value instanceof SocketAddress;
+  }
+
+  /** Node's `SocketAddress.parse('host:port')`; null for anything it cannot read. */
+  static parse(input: string): SocketAddress | undefined {
+    try {
+      const url = new URL(`http://${input}`);
+      const host = url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname;
+      const family = isIP(host) === 6 ? 'ipv6' : 'ipv4';
+      return new SocketAddress({ address: host, port: Number(url.port || 0), family });
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+type Rule =
+  | { kind: 'address'; family: string; value: bigint; text: string }
+  | { kind: 'range'; family: string; start: bigint; end: bigint; text: string }
+  | { kind: 'subnet'; family: string; network: bigint; mask: bigint; text: string };
+
+export class BlockList {
+  private entries: Rule[] = [];
+
+  private static familyOf(family?: string): string {
+    const name = (family ?? 'ipv4').toLowerCase();
+    if (name !== 'ipv4' && name !== 'ipv6') {
+      throw Object.assign(new TypeError(`The argument 'family' must be one of: 'ipv4', 'ipv6'. Received '${family}'`), { code: 'ERR_INVALID_ARG_VALUE' });
+    }
+    return name;
+  }
+
+  private static addressOf(value: string | SocketAddress, family: string): string {
+    if (value instanceof SocketAddress) return value.address;
+    if (typeof value !== 'string' || isIP(value) === 0) {
+      throw Object.assign(new TypeError(`The argument 'address' is invalid. Received '${String(value)}'`), { code: 'ERR_INVALID_ARG_VALUE' });
+    }
+    void family;
+    return value;
+  }
+
+  addAddress(address: string | SocketAddress, family?: string): void {
+    const name = address instanceof SocketAddress ? address.family : BlockList.familyOf(family);
+    const text = BlockList.addressOf(address, name);
+    this.entries.push({ kind: 'address', family: name, value: toNumber(text, name), text: `Address: ${name.toUpperCase()} ${text}` });
+  }
+
+  addRange(start: string | SocketAddress, end: string | SocketAddress, family?: string): void {
+    const name = start instanceof SocketAddress ? start.family : BlockList.familyOf(family);
+    const from = BlockList.addressOf(start, name);
+    const to = BlockList.addressOf(end, name);
+    const low = toNumber(from, name);
+    const high = toNumber(to, name);
+    if (high < low) {
+      throw Object.assign(new TypeError("The argument 'end' is invalid."), { code: 'ERR_INVALID_ARG_VALUE' });
+    }
+    this.entries.push({ kind: 'range', family: name, start: low, end: high, text: `Range: ${name.toUpperCase()} ${from}-${to}` });
+  }
+
+  addSubnet(network: string | SocketAddress, prefix: number, family?: string): void {
+    const name = network instanceof SocketAddress ? network.family : BlockList.familyOf(family);
+    const text = BlockList.addressOf(network, name);
+    const bits = name === 'ipv4' ? 32 : 128;
+    if (typeof prefix !== 'number' || !Number.isInteger(prefix) || prefix < 0 || prefix > bits) {
+      throw Object.assign(new RangeError(`The value of "prefix" is out of range. It must be >= 0 && <= ${bits}. Received ${prefix}`), { code: 'ERR_OUT_OF_RANGE' });
+    }
+    const mask = prefix === 0 ? 0n : ((1n << BigInt(prefix)) - 1n) << BigInt(bits - prefix);
+    this.entries.push({ kind: 'subnet', family: name, network: toNumber(text, name) & mask, mask, text: `Subnet: ${name.toUpperCase()} ${text}/${prefix}` });
+  }
+
+  check(address: string | SocketAddress, family?: string): boolean {
+    const name = address instanceof SocketAddress ? address.family : (family ?? 'ipv4').toLowerCase();
+    if (name !== 'ipv4' && name !== 'ipv6') return false;
+    const text = address instanceof SocketAddress ? address.address : address;
+    if (typeof text !== 'string' || isIP(text) === 0) return false;
+    const value = toNumber(text, name);
+    for (const rule of this.entries) {
+      if (rule.family !== name) continue;
+      if (rule.kind === 'address' && rule.value === value) return true;
+      if (rule.kind === 'range' && value >= rule.start && value <= rule.end) return true;
+      if (rule.kind === 'subnet' && (value & rule.mask) === rule.network) return true;
+    }
+    return false;
+  }
+
+  get rules(): string[] {
+    return this.entries.map((rule) => rule.text);
+  }
+
+  static isBlockList(value: unknown): value is BlockList {
+    return value instanceof BlockList;
+  }
+}
+
+export const internalSocketAddress = { SocketAddress, kSocketAddressHandle: Symbol('kSocketAddressHandle') };
+export const internalBlockList = { BlockList };

package/src/node-lib/internals/buffer-and-streams.ts

@@ -0,0 +1,224 @@
+/**
+ * The internals Node's `buffer` and `stream` name that neither `net` nor
+ * `child_process` did.
+ *
+ * Each object holds exactly the names the vendored files destructure from it.
+ * Where a name stands for something a tab cannot have -- a web-stream
+ * adapter, ICU's transcoder -- it refuses and says so at the site, rather
+ * than answering with something that is not it.
+ */
+import { libRequire } from '../require-hook';
+import { createBlobFromFilePath } from '../binding/blob';
+
+/** Node's `once(fn)`: the same function, run at most once. */
+export function once<F extends (...args: never[]) => unknown>(
+  callback: F, options?: { preserveReturnValue?: boolean },
+): F {
+  let called = false;
+  let returned: unknown;
+  function ran(this: unknown, ...args: never[]): unknown {
+    if (called) return returned;
+    called = true;
+    const result = Reflect.apply(callback, this, args);
+    returned = options?.preserveReturnValue === true ? result : undefined;
+    return result;
+  }
+  return ran as unknown as F;
+}
+
+/**
+ * Node's `defineLazyProperties`: each key becomes a getter that loads the
+ * named module on first read. `buffer.js` hangs `Blob`, `File` and
+ * `resolveObjectURL` off its exports this way, so a program that never asks
+ * for a Blob never loads one.
+ */
+export function defineLazyProperties(target: object, id: string, keys: string[], enumerable = true): void {
+  const descriptors: PropertyDescriptorMap = {};
+  let module: Record<string, unknown> | undefined;
+  for (const key of keys) {
+    let value: unknown;
+    let loaded = false;
+    descriptors[key] = {
+      configurable: true,
+      enumerable,
+      get(): unknown {
+        if (!loaded) {
+          module ??= libRequire(id) as Record<string, unknown>;
+          value = module[key];
+          loaded = true;
+        }
+        return value;
+      },
+      set(next: unknown): void { value = next; loaded = true; },
+    };
+  }
+  Object.defineProperties(target, descriptors);
+}
+
+/** Node's `lazyDOMException`: the realm's own, which every realm here has. */
+export function lazyDOMException(message: string, name: string): Error {
+  const Exception = (globalThis as unknown as { DOMException?: new (m: string, n: string) => Error }).DOMException;
+  if (typeof Exception === 'function') return new Exception(message, name);
+  return Object.assign(new Error(message), { name });
+}
+
+/**
+ * Node's `encodingsMap`: the number each encoding is to the buffer binding,
+ * from `enum encoding` in `node_buffer.h`. Only `buffer.js` and the binding
+ * exchange them.
+ */
+export const encodingsMap: Record<string, number> = {
+  ascii: 0, utf8: 1, 'utf-8': 1, base64: 2, ucs2: 3, 'ucs-2': 3,
+  utf16le: 3, 'utf-16le': 3, binary: 4, latin1: 4, hex: 5, buffer: 6, base64url: 7,
+};
+
+/** Node's `customInspectSymbol` and the symbol `Buffer.isEncoding` is marked with. */
+export const customInspectSymbol = Symbol.for('nodejs.util.inspect.custom');
+export const kIsEncodingSymbol = Symbol('kIsEncodingSymbol');
+
+/** `internal/abort_controller`: the realm's own, which is the web's. */
+export const internalAbortController = {
+  AbortController: globalThis.AbortController,
+  AbortSignal: globalThis.AbortSignal,
+  aborted: (signal: AbortSignal): boolean => signal.aborted,
+};
+
+/**
+ * `internal/blob` and `internal/file`: the realm's own `Blob` and `File`,
+ * which every realm the engine runs in has. `resolveObjectURL` answers
+ * nothing, because the engine registers no blob URLs of its own.
+ * `createBlobFromFilePath` is the blob binding's, which `fs.openAsBlob` is.
+ */
+export const internalBlob = {
+  Blob: globalThis.Blob,
+  isBlob: (value: unknown): boolean => typeof Blob === 'function' && value instanceof Blob,
+  resolveObjectURL: (): undefined => undefined,
+  createBlobFromFilePath,
+};
+export const internalFile = {
+  File: (globalThis as unknown as { File?: unknown }).File,
+};
+
+/**
+ * `internal/webstreams/adapters`: what `Readable.toWeb`, `Readable.fromWeb`,
+ * `Writable.toWeb`, `Writable.fromWeb` and the `Duplex` pair reach for.
+ *
+ * Node's own is pure JavaScript over Node's own `ReadableStream` and
+ * `WritableStream`, which are themselves a port of the web's. A tab HAS the
+ * web's, so this is the one place where the platform is the implementation
+ * rather than a thing to port: each adapter is written against the realm's
+ * `ReadableStream`/`WritableStream`, which is what a server bundle turning a
+ * `node:http` request into a `Request` gets. The engine carried these same
+ * six bodies as patches over its hand-written streams; they move here,
+ * unchanged in behaviour, now that the streams above them are Node's.
+ *
+ * What is not here is what Node's adapters add on top: a byte-mode
+ * `ReadableStream` with BYOB readers, and the `AbortSignal` options. Named,
+ * not guessed at.
+ */
+type AnyStream = Record<string, (...args: never[]) => unknown> & Record<string, unknown>;
+
+function streamModule(): Record<string, new (options?: unknown) => AnyStream> {
+  return libRequire('stream') as Record<string, new (options?: unknown) => AnyStream>;
+}
+
+function newReadableStreamFromStreamReadable(readable: AnyStream): ReadableStream {
+  return new ReadableStream({
+    start(controller) {
+      (readable.on as (e: string, l: (v: unknown) => void) => void)('data', (chunk) => {
+        controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(Buffer_from(chunk)));
+      });
+      (readable.on as (e: string, l: () => void) => void)('end', () => { try { controller.close(); } catch { /* a stream closed twice is closed */ } });
+      (readable.on as (e: string, l: (v: unknown) => void) => void)('error', (error) => { try { controller.error(error); } catch { /* likewise */ } });
+    },
+    cancel() { (readable.destroy as () => void)(); },
+  });
+}
+
+/** The bytes of a chunk that is not already one, without importing `buffer` at load. */
+function Buffer_from(chunk: unknown): Uint8Array {
+  const { Buffer } = libRequire('buffer') as { Buffer: { from(value: unknown): Uint8Array } };
+  return Buffer.from(chunk);
+}
+
+function newStreamReadableFromReadableStream(web: ReadableStream): AnyStream {
+  const { Readable } = streamModule() as unknown as { Readable: { from(source: unknown): AnyStream } };
+  return Readable.from({
+    [Symbol.asyncIterator]() {
+      const reader = web.getReader();
+      return {
+        [Symbol.asyncIterator]() { return this; },
+        async next() {
+          const step = await reader.read();
+          return step.done ? { value: undefined, done: true } : { value: step.value, done: false };
+        },
+        async return(value: unknown) { await reader.cancel(); return { value, done: true }; },
+      };
+    },
+  });
+}
+
+function newWritableStreamFromStreamWritable(writable: AnyStream): WritableStream {
+  return new WritableStream({
+    write(chunk) {
+      return new Promise<void>((resolve, reject) => {
+        (writable.write as (c: unknown, cb: (e: unknown) => void) => void)(chunk, (error) => (error ? reject(error as Error) : resolve()));
+      });
+    },
+    close() { return new Promise<void>((resolve) => { (writable.end as (cb: () => void) => void)(resolve); }); },
+    abort(reason) { (writable.destroy as (e?: Error) => void)(reason instanceof Error ? reason : undefined); },
+  });
+}
+
+function newStreamWritableFromWritableStream(web: WritableStream): AnyStream {
+  const { Writable } = streamModule() as unknown as { Writable: new (options: unknown) => AnyStream };
+  const writer = web.getWriter();
+  return new Writable({
+    write(chunk: unknown, _encoding: unknown, callback: (error?: Error | null) => void) {
+      writer.write(chunk instanceof Uint8Array ? chunk : Buffer_from(chunk)).then(() => callback(null), callback);
+    },
+    final(callback: (error?: Error | null) => void) {
+      writer.close().then(() => callback(null), callback);
+    },
+    destroy(error: Error | null, callback: (error?: Error | null) => void) {
+      writer.abort(error ?? undefined).then(() => callback(error), callback);
+    },
+  });
+}
+
+function newReadableWritablePairFromDuplex(duplex: AnyStream): { readable: ReadableStream; writable: WritableStream } {
+  return {
+    readable: newReadableStreamFromStreamReadable(duplex),
+    writable: newWritableStreamFromStreamWritable(duplex),
+  };
+}
+
+function newStreamDuplexFromReadableWritablePair(pair: { readable: ReadableStream; writable: WritableStream }): AnyStream {
+  const { Duplex } = streamModule() as unknown as { Duplex: new (options: unknown) => AnyStream };
+  const writer = pair.writable.getWriter();
+  const reader = pair.readable.getReader();
+  const duplex: AnyStream = new Duplex({
+    read() {
+      reader.read().then(
+        (step) => { (duplex.push as (c: unknown) => void)(step.done ? null : step.value); },
+        (error: Error) => { (duplex.destroy as (e: Error) => void)(error); },
+      );
+    },
+    write(chunk: unknown, _encoding: unknown, callback: (error?: Error | null) => void) {
+      writer.write(chunk instanceof Uint8Array ? chunk : Buffer_from(chunk)).then(() => callback(null), callback);
+    },
+    final(callback: (error?: Error | null) => void) {
+      writer.close().then(() => callback(null), callback);
+    },
+  });
+  return duplex;
+}
+
+export const internalWebStreamsAdapters = {
+  newReadableStreamFromStreamReadable,
+  newStreamReadableFromReadableStream,
+  newWritableStreamFromStreamWritable,
+  newStreamWritableFromWritableStream,
+  newReadableWritablePairFromDuplex,
+  newStreamDuplexFromReadableWritablePair,
+};

package/src/node-lib/internals/child-process.ts

@@ -0,0 +1,64 @@
+/**
+ * The internals Node's `child_process` names that `net` did not.
+ *
+ * Each object holds exactly the names `child_process.js` and
+ * `internal/child_process.js` destructure from it, over the engine's own
+ * modules. Node's real `internal/fs/utils` is two thousand lines about a
+ * kernel's descriptors; what `child_process.js` takes from it is one
+ * validator, run on the module path a `fork` was given.
+ */
+import { libRequire } from '../require-hook';
+import { fileURLToPath } from '../../shims/url';
+
+/** The codes the validators below raise, from the vendored `internal/errors.js`. */
+interface ErrorCodes {
+  codes: {
+    ERR_INVALID_ARG_TYPE: new (name: string, expected: unknown, actual: unknown) => Error;
+    ERR_INVALID_ARG_VALUE: new (name: string, value: unknown, reason?: string) => Error;
+  };
+}
+
+function errorCodes(): ErrorCodes['codes'] {
+  return (libRequire('internal/errors') as ErrorCodes).codes;
+}
+
+/**
+ * Node's `validatePath`: a path is a string or a `Uint8Array`, and it carries
+ * no NUL. `fork('a\u0000b')` is a program's own bug and Node says so rather
+ * than opening a file whose name stops at the NUL.
+ */
+function validatePath(path: unknown, propName = 'path'): void {
+  const codes = errorCodes();
+  const isString = typeof path === 'string';
+  const isBytes = path instanceof Uint8Array;
+  if (!isString && !isBytes) {
+    throw new codes.ERR_INVALID_ARG_TYPE(propName, ['string', 'Buffer', 'URL'], path);
+  }
+  if (isString ? !path.includes('\u0000') : !(path as Uint8Array).includes(0)) return;
+  throw new codes.ERR_INVALID_ARG_VALUE(
+    propName, path, 'must be a string, Uint8Array, or URL without null bytes',
+  );
+}
+
+/**
+ * Node's `getValidatedPath`: a `file:` URL is the path it names, and anything
+ * else is validated as it stands. `fork(new URL('file:///app/child.js'))` is
+ * an ordinary call and `test-child-process-fork-url.mjs` makes it.
+ */
+function getValidatedPath(fileURLOrPath: unknown, propName = 'path'): string | Uint8Array {
+  const path = fileURLOrPath instanceof URL || (typeof fileURLOrPath === 'string' && fileURLOrPath.startsWith('file://'))
+    ? fileURLToPath(fileURLOrPath as URL | string)
+    : fileURLOrPath;
+  validatePath(path, propName);
+  return path as string | Uint8Array;
+}
+
+export const internalFsUtils = { getValidatedPath, validatePath };
+
+/**
+ * `internal/dgram`: the one name `internal/child_process.js` reads from it,
+ * the symbol a `dgram.Socket` keeps its handle under. The engine's `dgram` is
+ * a stub with no handle, so nothing is ever sent this way; the symbol exists
+ * because the conversion table names it while it is built.
+ */
+export const internalDgram = { kStateSymbol: Symbol('state symbol') };

package/src/node-lib/internals/events-util.ts

@@ -0,0 +1,105 @@
+import { readlineModule as nodeLibPublicReadline } from './readline-access';
+
+/**
+ * The internals Node's `events`, `util` and `internal/util/inspect` name that
+ * are not vendored.
+ *
+ * Each is the whole of what those files take from it. Every one of them is
+ * required lazily, inside the function that needs it -- Node wrote them that
+ * way to break its own cycles -- so nothing here is built unless a program
+ * walks the path that asks.
+ */
+
+/** `internal/console/global`: the realm's console, which `util.debuglog` logs through. */
+export const internalConsoleGlobal = new Proxy({} as Record<string, unknown>, {
+  get: (_target, key) => Reflect.get(globalThis.console as unknown as object, key),
+});
+
+/**
+ * `internal/process/execution`: the one call `internal/util.js` makes into
+ * it, reading the working directory where a failure to read it is not an
+ * error but an empty answer.
+ */
+export const internalProcessExecution = {
+  tryGetCwd: (): string => {
+    try { return (globalThis as { process?: { cwd?: () => string } }).process?.cwd?.() ?? ''; }
+    catch { return ''; }
+  },
+};
+
+/**
+ * `internal/process/warning`: Node emits a warning on the next tick through
+ * `process.emitWarning`, and synchronously through this one where the tick
+ * would come too late -- a deprecation raised while the process is exiting.
+ */
+export const internalProcessWarning = {
+  emitWarningSync: (warning: unknown, type?: string, code?: string): void => {
+    const realm = (globalThis as { process?: { emitWarning?: (w: unknown, t?: string, c?: string) => void } }).process;
+    if (typeof realm?.emitWarning === 'function') { realm.emitWarning(warning, type, code); return; }
+    try { console.error(String(warning)); } catch { /* a console that refuses is no reason to fail */ }
+  },
+};
+
+/**
+ * `internal/source_map/source_map_cache`: a tab compiles no source maps into
+ * the engine's own error stacks. Each name answers the way Node's does with
+ * source maps switched off.
+ */
+export const internalSourceMapCache = {
+  findSourceMap: (): undefined => void 0,
+  maybeCacheSourceMap: (): void => {},
+  sourceMapCacheToObject: (): undefined => void 0,
+  getSourceMapsSupport: (): { enabled: boolean; nodeModules: boolean; generatedCode: boolean } =>
+    ({ enabled: false, nodeModules: false, generatedCode: false }),
+  setSourceMapsSupport: (): void => {},
+  rekeySourceMap: (): void => {},
+};
+
+/**
+ * `internal/deps/undici/undici`: what `http.js` reaches for when a program
+ * touches `http.WebSocket`, `http.CloseEvent` or `http.MessageEvent`.
+ *
+ * Node bundles undici to have those classes at all. A tab already has them --
+ * they are the platform's, and they are what `new WebSocket(url)` means
+ * everywhere else on the page -- so the realm's own are what the engine
+ * answers with, rather than a second implementation of the same three names.
+ */
+export const internalUndici = {
+  get WebSocket() { return (globalThis as { WebSocket?: unknown }).WebSocket; },
+  get CloseEvent() { return (globalThis as { CloseEvent?: unknown }).CloseEvent; },
+  get MessageEvent() { return (globalThis as { MessageEvent?: unknown }).MessageEvent; },
+};
+
+/**
+ * `internal/readline/interface`: the one name `internal/fs/promises.js`
+ * takes from it, at its top, so every use of `fs/promises` needs it.
+ * `filehandle.readLines()` builds one of these over the file's own stream;
+ * the engine's `readline` already has that class, over the same streams.
+ */
+export const internalReadlineInterface = {
+  get Interface() { return readlineInterface(); },
+};
+
+// eslint-disable-next-line no-var, vars-on-top
+var readlineInterfaceCache: unknown;
+function readlineInterface(): unknown {
+  // Required late, not imported: `readline` is an EventEmitter, and this file
+  // is on the loader's own path.
+  return readlineInterfaceCache ??= (nodeLibPublicReadline() as { Interface: unknown }).Interface;
+}
+
+/**
+ * `internal/worker/js_transferable`: the marks Node puts on an object that
+ * can cross a `postMessage`. `internal/fs/promises.js` marks its `FileHandle`
+ * so one can be sent to a worker. Nothing crosses a thread boundary here --
+ * a handle is a number in this engine's own table -- so the marks are the
+ * symbols and a no-op, which is what an unmarked object gets anyway.
+ */
+export const internalJsTransferable = {
+  markTransferMode: (): void => {},
+  kDeserialize: Symbol.for('nodejs.transfer.deserialize'),
+  kTransfer: Symbol.for('nodejs.transfer.transfer'),
+  kTransferList: Symbol.for('nodejs.transfer.transferList'),
+  kClone: Symbol.for('nodejs.transfer.clone'),
+  setDeserializerCreateObjectFunction: (): void => {},
+};

package/src/node-lib/internals/index.ts

@@ -0,0 +1,66 @@
+/**
+ * The internals Node's own files name that are not vendored.
+ *
+ * Node's own `internal/util`, `internal/async_hooks`, `internal/timers` and
+ * the rest are large files whose subject is a Node the engine does not have:
+ * an async-hooks graph, a timer wheel, a snapshot builder. What the vendored
+ * files actually take from each is a handful of names, so each is bound by
+ * hand to exactly those, over the engine's own modules. This table is the
+ * whole list; anything a vendored file asks for that is not here, not
+ * vendored and not a public module fails loudly in `load.ts` rather than
+ * arriving as `undefined` inside Node's code.
+ */
+import { internalUtilTypes } from './util';
+import {
+  internalConsoleGlobal, internalProcessExecution,
+  internalProcessWarning, internalSourceMapCache, internalUndici, internalReadlineInterface, internalJsTransferable,
+} from './events-util';
+import {
+  internalAsyncHooks, internalTimers, internalStreamsState, internalTaskQueues,
+  internalEventTarget, internalOptions, internalPerfObserve, internalAssert,
+  internalStartupSnapshot, internalPermission,
+} from './runtime';
+import { internalSocketAddress, internalBlockList } from './addresses';
+import { internalFsUtils, internalDgram } from './child-process';
+import {
+  internalAbortController, internalBlob, internalFile, internalWebStreamsAdapters,
+} from './buffer-and-streams';
+import { internalBootstrapRealm, internalUrl, internalEncoding } from './modules';
+
+/** Built on the first ask, for the reason `./binding/index.ts` gives. */
+// eslint-disable-next-line no-var, vars-on-top
+var __table: Record<string, () => unknown> | undefined;
+export function nodeLibInternal(name: string): (() => unknown) | undefined {
+  __table ??= {
+  'internal/util/types': () => internalUtilTypes,
+  'internal/async_hooks': () => internalAsyncHooks,
+  'internal/timers': () => internalTimers,
+  'internal/streams/state': () => internalStreamsState,
+  'internal/process/task_queues': () => internalTaskQueues,
+  'internal/process/permission': () => internalPermission,
+  'internal/event_target': () => internalEventTarget,
+  'internal/options': () => internalOptions,
+  'internal/perf/observe': () => internalPerfObserve,
+  'internal/assert': () => internalAssert,
+  'internal/v8/startup_snapshot': () => internalStartupSnapshot,
+  'internal/fs/utils': () => internalFsUtils,
+  'internal/dgram': () => internalDgram,
+  'internal/abort_controller': () => internalAbortController,
+  'internal/blob': () => internalBlob,
+  'internal/file': () => internalFile,
+  'internal/webstreams/adapters': () => internalWebStreamsAdapters,
+  'internal/socketaddress': () => internalSocketAddress,
+  'internal/blocklist': () => internalBlockList,
+  'internal/bootstrap/realm': () => internalBootstrapRealm,
+  'internal/url': () => internalUrl,
+  'internal/encoding': () => internalEncoding,
+  'internal/console/global': () => internalConsoleGlobal,
+  'internal/process/execution': () => internalProcessExecution,
+  'internal/process/warning': () => internalProcessWarning,
+  'internal/source_map/source_map_cache': () => internalSourceMapCache,
+  'internal/deps/undici/undici': () => internalUndici,
+  'internal/readline/interface': () => internalReadlineInterface,
+  'internal/worker/js_transferable': () => internalJsTransferable,
+};;
+  return __table[name];
+}