@volter/tabnode 0.2.14-volter.88

package/src/host-globals.ts

@@ -0,0 +1,121 @@
+/**
+ * The realm belongs to whoever owns the process.
+ *
+ * The engine corrects globals so that a guest behaves like Node: a timer that
+ * answers `unref`, a `Request` that keeps the headers it was built with, a
+ * `Proxy` `util.types.isProxy` can recognise, an AsyncLocalStorage store
+ * carried into every continuation. In a tab those corrections are right,
+ * because the realm exists to run guests and there is nobody else in it.
+ *
+ * Imported into a Node process the engine is a library, and the realm is the
+ * host's: its `setTimeout` is the one its own code scheduled on, its
+ * `Promise.prototype.then` is the one its own promises resolve through, and a
+ * channel the engine opened is a handle its loop counts. `node --test` over a
+ * file that only imported the engine never exited, because a module-scope
+ * `BroadcastChannel` held the loop open; the substrate's gate ran it with
+ * `--test-force-exit`.
+ *
+ * So the rule is: importing the engine changes nothing and opens nothing.
+ * A realm correction is registered here at load and installed by a `Runtime`
+ * — the act of asking for a guest — and every property it takes is
+ * remembered, so `restoreHostGlobals()` gives the realm back exactly as it
+ * was found.
+ */
+
+type Undo = () => void;
+
+const installers: Array<() => void> = [];
+const undos: Undo[] = [];
+let installed = false;
+
+/**
+ * A correction a guest needs from the realm. It runs when a runtime exists,
+ * not when this module is loaded, and it must be idempotent: a later runtime
+ * runs it again. Registering after a runtime is already up installs at once,
+ * since the guest is already there.
+ */
+export function forGuestRealm(install: () => void): void {
+  installers.push(install);
+  if (installed) install();
+}
+
+/**
+ * Replace a property of the realm for a guest, remembering what the host had
+ * under it. A name the host did not have is deleted on restore; one it had is
+ * put back with its own descriptor, flags and all.
+ */
+export function takeFromHost(target: object, key: PropertyKey, value: unknown): void {
+  const previous = Object.getOwnPropertyDescriptor(target, key);
+  undos.push(() => {
+    if (previous) Object.defineProperty(target, key, previous);
+    else Reflect.deleteProperty(target, key);
+  });
+  Object.defineProperty(target, key, {
+    value,
+    writable: previous ? previous.writable !== false : true,
+    enumerable: previous ? previous.enumerable : false,
+    configurable: true,
+  });
+}
+
+/**
+ * Define a property of the realm for a guest with a descriptor of its own — a
+ * getter, or a flag the value form cannot carry — remembering the host's.
+ */
+export function defineOnHost(target: object, key: PropertyKey, descriptor: PropertyDescriptor): void {
+  const previous = Object.getOwnPropertyDescriptor(target, key);
+  undos.push(() => {
+    if (previous) Object.defineProperty(target, key, previous);
+    else Reflect.deleteProperty(target, key);
+  });
+  Object.defineProperty(target, key, descriptor);
+}
+
+/**
+ * Install every registered correction. Called by each `Runtime`, because a
+ * realm a guest has been running in may have lost one — a guest that assigns
+ * to its own `globalThis` assigns to the realm — and every correction is
+ * written to notice its own work and do nothing the second time. Nothing here
+ * runs when this module is merely loaded.
+ */
+export function installGuestRealm(): void {
+  installed = true;
+  for (const install of installers) install();
+}
+
+/** Whether the realm currently carries the engine's corrections. */
+export function guestRealmInstalled(): boolean {
+  return installed;
+}
+
+/**
+ * Give the realm back. Every property the engine took returns to what the
+ * host had, newest first. A host that created a runtime inside its own
+ * process and is done with it gets its own globals back; a runtime created
+ * afterwards installs them again.
+ */
+export function restoreHostGlobals(): void {
+  installed = false;
+  while (undos.length) {
+    const undo = undos.pop();
+    try { undo!(); } catch { /* a realm that refuses the restore keeps the patch */ }
+  }
+}
+
+/**
+ * Work the host is doing on a guest's behalf, counted while it is in flight,
+ * so the run loop waits for a build that prints nothing. The engine's parts
+ * share the count through `globalThis` when more than one bundle is loaded in
+ * a realm; until a guest exists the count is this module's own object, so
+ * importing the engine adds no name to the host's global.
+ */
+const ownHeldWork = { count: 0 };
+
+export function heldWork(): { count: number } {
+  return (globalThis as { __browserRuntimeHeldWork?: { count: number } }).__browserRuntimeHeldWork ?? ownHeldWork;
+}
+
+forGuestRealm(() => {
+  const realm = globalThis as { __browserRuntimeHeldWork?: { count: number } };
+  if (!realm.__browserRuntimeHeldWork) takeFromHost(globalThis, '__browserRuntimeHeldWork', ownHeldWork);
+});

package/src/index.ts

@@ -0,0 +1,235 @@
+/**
+ * tabnode's public surface.
+ *
+ * The engine is a library the substrate embeds: a filesystem, a runtime, a
+ * container over the two, the npm client that fills the tree, the bridge a
+ * page's requests reach a guest's server through, and the resolver. What a
+ * guest requires is not here -- a guest reaches its builtins through the
+ * runtime's own module table, which is `runtime.ts`.
+ */
+
+// Importing this module changes nothing in the realm it is loaded into and
+// opens no handle in it; a `Runtime` installs what a guest needs, and this
+// hands the host's own globals back. See `host-globals.ts`.
+export { restoreHostGlobals, guestRealmInstalled } from './host-globals';
+export { VirtualFS } from './virtual-fs';
+export type { FSNode, Stats, FSWatcher, WatchListener, WatchEventType } from './virtual-fs';
+export { Runtime, execute } from './runtime';
+export type { Module, RuntimeOptions, RequireFunction } from './runtime';
+export { createRuntime, WorkerRuntime } from './create-runtime';
+export type { IRuntime, IExecuteResult, CreateRuntimeOptions, IRuntimeOptions, VFSSnapshot } from './runtime-interface';
+export { createFsShim } from './shims/fs';
+export type { FsShim } from './shims/fs';
+export { createProcess } from './shims/process';
+export type { Process, ProcessEnv } from './shims/process';
+export * as path from './shims/path';
+export { httpModule as http, httpsModule as https } from './node-lib/http-module';
+import { __releaseOwnedServers, __ownedServerPorts } from './node-lib/net-module';
+export { netModule as net } from './node-lib/net-module';
+export { eventsModule as events } from './node-lib/events-module';
+export { streamModule as stream } from './node-lib/stream-module';
+export { bufferModule as buffer } from './node-lib/buffer-module';
+export * as url from './shims/url';
+export { utilModule as util } from './node-lib/util-module';
+export * as npm from './npm';
+export { PackageManager, install } from './npm';
+export { ServerBridge, getServerBridge, resetServerBridge } from './server-bridge';
+export type { InitServiceWorkerOptions } from './server-bridge';
+/** What a page's request is answered with, the shape the bridge answers. */
+export type { ResponseData } from './node-lib/http-bridge';
+// The bundlers' own wasm builds, as doors: a host that builds outside a run
+// (the substrate's rolldown pass) reaches them here rather than through a
+// guest's `require`.
+export * as esbuild from './shims/esbuild';
+export * as rollup from './shims/rollup';
+export * as module from './shims/module';
+export * as perf_hooks from './shims/perf_hooks';
+export * as worker_threads from './shims/worker_threads';
+
+import { VirtualFS } from './virtual-fs';
+import { Runtime, RuntimeOptions } from './runtime';
+import { PackageManager } from './npm';
+import { ServerBridge, getServerBridge } from './server-bridge';
+import { runCommand, registerRunStreams, releaseRunStreams, sendStdin } from './shims/child_process';
+import { Server as NetServer, __releaseOwnedHandles, type Socket as NetSocket } from './node-lib/net-module';
+
+import { __currentProcessToken, __runFor, __stopOwnedProcess, runPid, processByPid } from './process-tokens';
+export { runPid, processByPid };
+
+export interface RunResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface RunOptions {
+  cwd?: string;
+  /** The environment the command runs in, as `child_process.exec` takes it. */
+  env?: Record<string, string>;
+  /** What the shell reads on stdin, so a builtin reads what was piped to it. */
+  stdin?: string;
+  /** Callback for streaming stdout chunks as they arrive (for long-running commands like vitest watch) */
+  onStdout?: (data: string) => void;
+  /** Callback for streaming stderr chunks as they arrive */
+  onStderr?: (data: string) => void;
+  /** AbortSignal to cancel long-running commands */
+  signal?: AbortSignal;
+  /**
+   * A name for this run. The `node` command records the guest process it
+   * creates under it for the run's lifetime, and the container answers
+   * `pendingTimers`, `processPorts` and `stopProcess` about that name.
+   */
+  processToken?: string;
+  /**
+   * The host keeps this run open (a watch or an interactive shell); a run that
+   * is not held ends when its loop has nothing left, as Node's does. A
+   * `signal` alone is an abort handle, not a hold.
+   */
+  held?: boolean;
+}
+
+/** Names for runs the caller did not name; a run's state is kept under its name. */
+let __nextRunName = 1;
+
+export interface ContainerOptions extends RuntimeOptions {
+  /** The filesystem the container runs on; one is built in memory when absent. */
+  vfs?: VirtualFS;
+  baseUrl?: string;
+  onServerReady?: (port: number, url: string) => void;
+}
+
+/**
+ * Create a new WebContainer-like environment
+ */
+export function createContainer(options?: ContainerOptions): {
+  vfs: VirtualFS;
+  runtime: Runtime;
+  npm: PackageManager;
+  serverBridge: ServerBridge;
+  execute: (code: string, filename?: string) => { exports: unknown };
+  runFile: (filename: string) => { exports: unknown };
+  run: (command: string, options?: RunOptions) => Promise<RunResult>;
+  pendingTimers: (token: string) => number;
+  processPorts: (token: string) => number[];
+  stopProcess: (token: string) => boolean;
+  /**
+   * Input for one run's guest, by its process token; without a token, the most
+   * recently started held run, which is the prompt a person is typing to.
+   */
+  sendInput: (data: string, token?: string) => void;
+  /** The run whose guest code is executing, for a caller attributing a child. */
+  currentProcessToken: () => string | null;
+  /** The numbers a named run, or the current one, was started with. */
+  runPid: (token?: string | null) => { pid: number; ppid: number } | undefined;
+  /** The numbers a live process carries, looked up by its own pid. */
+  processByPid: (pid: number) => { pid: number; ppid: number } | undefined;
+  listenNet: (port: number, onConnection: (socket: NetSocket) => void) => () => void;
+  createREPL: () => { eval: (code: string) => unknown };
+  on: (event: string, listener: (...args: unknown[]) => void) => void;
+} {
+  // A container takes the filesystem it is given. Building its own in memory
+  // with no way to hand it another left the worker that owns the origin's store
+  // unable to give it one that keeps the index in memory and the bytes in the
+  // pack.
+  const vfs = (options && options.vfs) || new VirtualFS();
+  const runtime = new Runtime(vfs, options);
+  const npmManager = new PackageManager(vfs);
+  // A container owns its servers. One process-wide bridge meant two runtimes in
+  // one page shared a port space: the second dev server to claim 5173 took the
+  // first one's requests, and a consumer that asked for two isolated runtimes
+  // got one. Each container holds its own bridge, and the page decides which of
+  // them a preview or a service worker is wired to.
+  const serverBridge = new ServerBridge({
+    baseUrl: options?.baseUrl,
+    onServerReady: options?.onServerReady,
+  });
+
+  return {
+    vfs,
+    runtime,
+    npm: npmManager,
+    serverBridge,
+    execute: (code: string, filename?: string) => runtime.execute(code, filename),
+    runFile: (filename: string) => runtime.runFile(filename),
+    run: (command: string, runOptions?: RunOptions): Promise<RunResult> => {
+      // If signal is already aborted, resolve immediately
+      if (runOptions?.signal?.aborted) {
+        return Promise.resolve({ stdout: '', stderr: '', exitCode: 130 });
+      }
+
+      // Every run has a name, because what the host gave this run — its
+      // streams, its signal, whether it is held — is kept under that name and
+      // not in a module global a child's run would overwrite.
+      const processToken = typeof runOptions?.processToken === 'string' && runOptions.processToken.length > 0
+        ? runOptions.processToken
+        : `run-${__nextRunName++}`;
+      registerRunStreams(processToken, {
+        onStdout: runOptions?.onStdout,
+        onStderr: runOptions?.onStderr,
+        signal: runOptions?.signal,
+        held: runOptions?.held === true,
+      });
+
+      return new Promise((resolve) => {
+        // `container.run("cat", { stdin })` used to reach the engine's shell
+        // without its stdin: the run dropped it before exec, and exec dropped
+        // it before the shell. Both forward it, so a builtin reads what was
+        // piped, as it does in a Node shell.
+        runCommand(command, { cwd: runOptions?.cwd, env: runOptions?.env, stdin: typeof runOptions?.stdin === 'string' ? runOptions.stdin : undefined, processToken, vfs }, (error, stdout, stderr) => {
+          releaseRunStreams(processToken);
+          resolve({
+            stdout: String(stdout),
+            stderr: String(stderr),
+            exitCode: error ? (error.code ?? 1) : 0,
+          });
+        });
+      });
+    },
+    // What a host that named a run can ask about it, and the one thing it can
+    // do to it. A run nobody named, and a name nothing runs under, answer as
+    // an absent process does: no timers, no ports, and a stop that does
+    // nothing.
+    /** The timers the named run's guest still holds, as Node's loop counts them. */
+    pendingTimers: (token: string): number => __runFor(token)?.pendingTimers() ?? 0,
+    /** The ports the servers the named run opened are listening on. */
+    processPorts: (token: string): number[] => __ownedServerPorts(token),
+    /** End the named run: its timers stop and its servers are released. */
+    stopProcess: (token: string): boolean => {
+      const known = __runFor(token) !== undefined || __ownedServerPorts(token).length > 0;
+      // The servers first, and their timers here rather than on a tick of
+      // their own: a caller that asks is told what it may then read back.
+      __releaseOwnedServers(token, false);
+      __releaseOwnedHandles(token);
+      __stopOwnedProcess(token);
+      return known;
+    },
+    /**
+     * Input for one run's guest, by its process token; without a token, the most
+     * recently started held run, which is the prompt a person is typing to.
+     */
+    sendInput: (data: string, token?: string) => sendStdin(data, token),
+    currentProcessToken: () => __currentProcessToken(),
+    runPid: (token) => runPid(token === undefined ? __currentProcessToken() : token),
+    processByPid,
+    // A door for a program of the page to listen on a loopback port with a
+    // socket handler of its own, so a guest's `net.connect` reaches it: the
+    // registry a connect consults is the `net` shim's, and a server of the
+    // shim's own class is what registers in it. The call answers a disposer.
+    listenNet: (port: number, onConnection: (socket: NetSocket) => void) => {
+      const server = new NetServer(onConnection);
+      server.listen(port);
+      return () => { server.close(); };
+    },
+    createREPL: () => runtime.createREPL(),
+    on: (event: string, listener: (...args: unknown[]) => void) => {
+      serverBridge.on(event, listener);
+    },
+  };
+}
+
+export default createContainer;
+
+// Node's module resolution as a function over any filesystem, for a host
+// that resolves the way the engine does (the substrate's stand-ins do).
+export { createNodeResolver } from './node-resolution';
+export type { ResolutionFs, ExportsResolver, NodeResolverOptions, NodeResolver } from './node-resolution';

package/src/node-internals.ts

@@ -0,0 +1,283 @@
+/**
+ * The Node internals a vendored `lib/*.js` file asks its binding for:
+ * `internal/errors` codes and `internal/validators`, with Node's messages.
+ *
+ * A guest reads `err.code` and `err.message`, and Node's own tests read both
+ * (test-path-parse-format.js asserts the ERR_INVALID_ARG_TYPE text word for
+ * word; test-wasi-options-validation.js matches the property names), so each
+ * message is assembled the way lib/internal/errors.js assembles it. These
+ * began in `shims/path.ts`, the first Node file run on a binding; `shims/wasi.ts`
+ * is the second, and both bind here.
+ */
+
+import { inspect } from './node-lib/util-module';
+
+/** Node's util.inspect, for the primitives that reach an error message. */
+export function inspectValue(value: unknown): string {
+  if (typeof value === 'string') {
+    const escaped = value.replace(/\n/g, '\\n');
+    if (!escaped.includes("'")) return `'${escaped}'`;
+    if (!escaped.includes('"')) return `"${escaped}"`;
+    return `\`${escaped}\``;
+  }
+  if (typeof value === 'bigint') return `${value}n`;
+  if (typeof value === 'symbol') return value.toString();
+  return String(value);
+}
+
+/**
+ * lib/internal/errors.js `determineSpecificType`, the "Received ..." tail of
+ * every ERR_INVALID_ARG_TYPE. Node switches on `typeof` and never inspects a
+ * function: a function is `function <name>`, and an anonymous one is
+ * `function ` with the empty name, not `type function (() => {\n})`. The engine
+ * inspected it, so every builtin that validated an argument printed a
+ * program's own source back at it where Node prints a name
+ * (`node:wasi`'s `new WASI(() => {})`, test-wasi-options-validation.js).
+ * Transcribed from Node 22's source, case for case.
+ */
+export function determineSpecificType(value: unknown): string {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+
+  const type = typeof value;
+
+  switch (type) {
+    case 'bigint':
+      return `type bigint (${value}n)`;
+    case 'number': {
+      const number = value as number;
+      if (number === 0) return 1 / number === -Infinity ? 'type number (-0)' : 'type number (0)';
+      if (number !== number) return 'type number (NaN)';
+      if (number === Infinity) return 'type number (Infinity)';
+      if (number === -Infinity) return 'type number (-Infinity)';
+      return `type number (${number})`;
+    }
+    case 'boolean':
+      return value ? 'type boolean (true)' : 'type boolean (false)';
+    case 'symbol':
+      return `type symbol (${String(value)})`;
+    case 'function':
+      return `function ${(value as { name?: string }).name}`;
+    case 'object': {
+      const ctor = (value as { constructor?: object }).constructor;
+      if (ctor && 'name' in ctor) return `an instance of ${(ctor as { name?: string }).name}`;
+      // Node: inspect(value, { depth: -1 }). The engine's util.inspect answers
+      // `[Object]` where Node answers `[Object: null prototype]`; reached only
+      // by an object whose constructor is gone, which Node's tests do not.
+      return `${inspect(value, { depth: -1 })}`;
+    }
+    case 'string': {
+      let text = value as string;
+      if (text.length > 28) text = `${text.slice(0, 25)}...`;
+      if (text.indexOf("'") === -1) return `type string ('${text}')`;
+      return `type string (${JSON.stringify(text)})`;
+    }
+    default: {
+      let inspected = inspect(value, { colors: false });
+      if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
+      return `type ${type} (${inspected})`;
+    }
+  }
+}
+
+const kTypes = [
+  'string', 'function', 'number', 'object',
+  'Function', 'Object', 'boolean', 'bigint', 'symbol',
+];
+/** lib/internal/errors.js: an expectation spelled as a class name. */
+const classRegExp = /^([A-Z][a-z0-9]*)+$/;
+
+/**
+ * lib/internal/errors.js ERR_INVALID_ARG_TYPE. Node sorts each expectation
+ * into three buckets — a primitive `type`, a class `instance`, anything else —
+ * and the engine had only two, so every validator that expects a class said
+ * "must be an Array" where Node says "must be an instance of Array"
+ * (`node:wasi`'s `validateArray(options.args)`,
+ * test-wasi-options-validation.js).
+ */
+export class ERR_INVALID_ARG_TYPE extends TypeError {
+  code = 'ERR_INVALID_ARG_TYPE';
+  constructor(name: string, expected: string | string[], actual: unknown) {
+    const expectations = Array.isArray(expected) ? [...expected] : [expected];
+    let message = 'The ';
+    if (name.endsWith(' argument')) {
+      message += `${name} `;
+    } else {
+      message += `"${name}" ${name.includes('.') ? 'property' : 'argument'} `;
+    }
+    message += 'must be ';
+
+    const types: string[] = [];
+    const instances: string[] = [];
+    const other: string[] = [];
+    for (const value of expectations) {
+      if (kTypes.includes(value)) types.push(value.toLowerCase());
+      else if (classRegExp.exec(value) !== null) instances.push(value);
+      else other.push(value);
+    }
+
+    // Node: where a class is also expected, plain `object` becomes `Object`,
+    // so the message tells the instances apart.
+    if (instances.length > 0) {
+      const pos = types.indexOf('object');
+      if (pos !== -1) {
+        types.splice(pos, 1);
+        instances.push('Object');
+      }
+    }
+
+    if (types.length > 0) {
+      if (types.length > 2) {
+        const last = types.pop();
+        message += `one of type ${types.join(', ')}, or ${last}`;
+      } else if (types.length === 2) {
+        message += `one of type ${types[0]} or ${types[1]}`;
+      } else {
+        message += `of type ${types[0]}`;
+      }
+      if (instances.length > 0 || other.length > 0) message += ' or ';
+    }
+
+    if (instances.length > 0) {
+      if (instances.length > 2) {
+        const last = instances.pop();
+        message += `an instance of ${instances.join(', ')}, or ${last}`;
+      } else {
+        message += `an instance of ${instances[0]}`;
+        if (instances.length === 2) message += ` or ${instances[1]}`;
+      }
+      if (other.length > 0) message += ' or ';
+    }
+
+    if (other.length > 0) {
+      if (other.length > 2) {
+        const last = other.pop();
+        message += `one of ${other.join(', ')}, or ${last}`;
+      } else if (other.length === 2) {
+        message += `one of ${other[0]} or ${other[1]}`;
+      } else {
+        if (other[0].toLowerCase() !== other[0]) message += 'an ';
+        message += `${other[0]}`;
+      }
+    }
+
+    message += `. Received ${determineSpecificType(actual)}`;
+    super(message);
+    // Node restores the built-in name and carries the code beside it, so a
+    // guest's `err instanceof TypeError` and `err.name === 'TypeError'` hold.
+    this.name = 'TypeError';
+  }
+}
+
+export class ERR_INVALID_ARG_VALUE extends TypeError {
+  code = 'ERR_INVALID_ARG_VALUE';
+  constructor(name: string, value: unknown, reason = 'is invalid') {
+    const type = name.includes('.') ? 'property' : 'argument';
+    super(`The ${type} '${name}' ${reason}. Received ${inspectValue(value)}`);
+    this.name = 'TypeError';
+  }
+}
+
+/**
+ * lib/internal/errors.js `addNumericSeparator`: Node groups a large integer's
+ * digits in an out-of-range message, so `281474976710656` is reported as
+ * `281_474_976_710_656` (test-crypto-random.js asserts that form for
+ * `crypto.randomInt`'s range). The engine printed the bare digits.
+ */
+function addNumericSeparator(value: string): string {
+  let tail = '';
+  let index = value.length;
+  const start = value[0] === '-' ? 1 : 0;
+  for (; index >= start + 4; index -= 3) tail = `_${value.slice(index - 3, index)}${tail}`;
+  return `${value.slice(0, index)}${tail}`;
+}
+
+export class ERR_OUT_OF_RANGE extends RangeError {
+  code = 'ERR_OUT_OF_RANGE';
+  constructor(name: string, range: string, value: unknown) {
+    // Node separates the digits of an integer past 2**32, and of a bigint
+    // past the same, and inspects everything else.
+    let received: string;
+    if (typeof value === 'number' && Number.isInteger(value) && Math.abs(value) > 2 ** 32) {
+      received = addNumericSeparator(String(value));
+    } else if (typeof value === 'bigint') {
+      received = String(value);
+      if (value > 2n ** 32n || value < -(2n ** 32n)) received = addNumericSeparator(received);
+      received += 'n';
+    } else {
+      received = inspectValue(value);
+    }
+    super(`The value of "${name}" is out of range. It must be ${range}. Received ${received}`);
+    this.name = 'RangeError';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// internal/validators — the names path.js and wasi.js take from it.
+// ---------------------------------------------------------------------------
+
+export function validateString(value: unknown, name: string): void {
+  if (typeof value !== 'string') throw new ERR_INVALID_ARG_TYPE(name, 'string', value);
+}
+
+export function validateObject(value: unknown, name: string): void {
+  if (value === null || Array.isArray(value) || typeof value !== 'object') {
+    throw new ERR_INVALID_ARG_TYPE(name, 'Object', value);
+  }
+}
+
+export function validateArray(value: unknown, name: string, minLength = 0): void {
+  if (!Array.isArray(value)) throw new ERR_INVALID_ARG_TYPE(name, 'Array', value);
+  if (value.length < minLength) {
+    throw new ERR_INVALID_ARG_VALUE(name, value, `must be longer than ${minLength}`);
+  }
+}
+
+export function validateBoolean(value: unknown, name: string): void {
+  if (typeof value !== 'boolean') throw new ERR_INVALID_ARG_TYPE(name, 'boolean', value);
+}
+
+export function validateFunction(value: unknown, name: string): void {
+  if (typeof value !== 'function') throw new ERR_INVALID_ARG_TYPE(name, 'Function', value);
+}
+
+/** lib/internal/errors.js ERR_UNKNOWN_ENCODING, as `new StringDecoder('x')` raises it. */
+export class ERR_UNKNOWN_ENCODING extends TypeError {
+  code = 'ERR_UNKNOWN_ENCODING';
+  constructor(encoding: unknown) {
+    super(`Unknown encoding: ${String(encoding)}`);
+    this.name = 'TypeError';
+  }
+}
+
+/** lib/internal/errors.js ERR_INVALID_THIS: a prototype method called off an instance. */
+export class ERR_INVALID_THIS extends TypeError {
+  code = 'ERR_INVALID_THIS';
+  constructor(type: string) {
+    super(`Value of "this" must be of type ${type}`);
+    this.name = 'TypeError';
+  }
+}
+
+/** lib/internal/errors.js ERR_STRING_TOO_LONG: past V8's longest string. */
+export class ERR_STRING_TOO_LONG extends RangeError {
+  code = 'ERR_STRING_TOO_LONG';
+  constructor(max: number) {
+    super(`Cannot create a string longer than 0x${max.toString(16)} characters`);
+    this.name = 'RangeError';
+  }
+}
+
+export function validateNumber(value: unknown, name: string): void {
+  if (typeof value !== 'number') throw new ERR_INVALID_ARG_TYPE(name, 'number', value);
+}
+
+export function validateUndefined(value: unknown, name: string): void {
+  if (value !== undefined) throw new ERR_INVALID_ARG_TYPE(name, 'undefined', value);
+}
+
+export function validateInt32(value: unknown, name: string, min = -2147483648, max = 2147483647): void {
+  if (typeof value !== 'number') throw new ERR_INVALID_ARG_TYPE(name, 'number', value);
+  if (!Number.isInteger(value)) throw new ERR_OUT_OF_RANGE(name, 'an integer', value);
+  if (value < min || value > max) throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
+}

package/src/node-lib/LICENSE

@@ -0,0 +1,47 @@
+Node.js is licensed for use as follows:
+
+"""
+Copyright Node.js contributors. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+"""
+
+This license applies to parts of Node.js originating from the
+https://github.com/joyent/node repository:
+
+"""
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+"""