@seanhogg/builderforce-webcontainers-core 2026.10.2 → 2026.10.4

package/src/node/assert.ts

@@ -0,0 +1,127 @@
+/**
+ * `assert` (and `assert/strict`): the assertion functions test runners and
+ * defensive library code call, throwing `AssertionError` with Node's fields.
+ */
+import { inspect } from './inspect.js';
+import { isDeepStrictEqual } from './util.js';
+
+export class AssertionError extends Error {
+  code = 'ERR_ASSERTION';
+  actual: unknown;
+  expected: unknown;
+  operator: string;
+  generatedMessage: boolean;
+
+  constructor(options: { message?: string | Error; actual?: unknown; expected?: unknown; operator?: string }) {
+    const generated = options.message === undefined;
+    super(generated ? `${inspect(options.actual)} ${options.operator ?? '=='} ${inspect(options.expected)}` : String(options.message));
+    this.name = 'AssertionError';
+    this.actual = options.actual;
+    this.expected = options.expected;
+    this.operator = options.operator ?? '==';
+    this.generatedMessage = generated;
+  }
+}
+
+function looseDeepEqual(a: unknown, b: unknown): boolean {
+  // eslint-disable-next-line eqeqeq
+  if (a == b) return true;
+  if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) return false;
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  return ka.length === kb.length && ka.every((k) => looseDeepEqual((a as any)[k], (b as any)[k]));
+}
+
+function fail(message: string | Error | undefined, actual: unknown, expected: unknown, operator: string): never {
+  if (message instanceof Error) throw message;
+  throw new AssertionError({ message, actual, expected, operator });
+}
+
+function matchesExpectation(error: unknown, expected: unknown): boolean {
+  if (expected === undefined) return true;
+  if (typeof expected === 'function') {
+    if (expected.prototype !== undefined && error instanceof (expected as new () => unknown)) return true;
+    if (Error.isPrototypeOf(expected)) return false;
+    return (expected as (e: unknown) => boolean)(error) === true;
+  }
+  if (expected instanceof RegExp) return expected.test(String(error instanceof Error ? error.message : error)) || expected.test(String(error));
+  if (typeof expected === 'object' && expected) {
+    return Object.entries(expected).every(([k, v]) => (v instanceof RegExp ? v.test(String((error as any)?.[k])) : isDeepStrictEqual((error as any)?.[k], v)));
+  }
+  return false;
+}
+
+export function createAssertModule(strict = false): Record<string, unknown> {
+  const ok = (value: unknown, message?: string | Error) => {
+    if (!value) fail(message ?? 'The expression evaluated to a falsy value', value, true, '==');
+  };
+  const equal = strict
+    ? (a: unknown, b: unknown, m?: string | Error) => !Object.is(a, b) && fail(m, a, b, 'strictEqual')
+    // eslint-disable-next-line eqeqeq
+    : (a: unknown, b: unknown, m?: string | Error) => a != b && !(Number.isNaN(a) && Number.isNaN(b)) && fail(m, a, b, '==');
+  const deepEqual = strict
+    ? (a: unknown, b: unknown, m?: string | Error) => !isDeepStrictEqual(a, b) && fail(m, a, b, 'deepStrictEqual')
+    : (a: unknown, b: unknown, m?: string | Error) => !looseDeepEqual(a, b) && fail(m, a, b, 'deepEqual');
+
+  const throws = (fn: () => unknown, expected?: unknown, message?: string | Error) => {
+    if (typeof expected === 'string') [message, expected] = [expected, undefined];
+    try {
+      fn();
+    } catch (error) {
+      if (!matchesExpectation(error, expected)) throw error;
+      return;
+    }
+    fail(message ?? 'Missing expected exception.', undefined, expected, 'throws');
+  };
+  const rejects = async (promiseOrFn: Promise<unknown> | (() => Promise<unknown>), expected?: unknown, message?: string | Error) => {
+    if (typeof expected === 'string') [message, expected] = [expected, undefined];
+    try {
+      await (typeof promiseOrFn === 'function' ? promiseOrFn() : promiseOrFn);
+    } catch (error) {
+      if (!matchesExpectation(error, expected)) throw error;
+      return;
+    }
+    fail(message ?? 'Missing expected rejection.', undefined, expected, 'rejects');
+  };
+
+  const assert = ((value: unknown, message?: string | Error) => ok(value, message)) as ((value: unknown, message?: string | Error) => void) & Record<string, unknown>;
+  Object.assign(assert, {
+    ok,
+    equal,
+    notEqual: strict
+      ? (a: unknown, b: unknown, m?: string | Error) => Object.is(a, b) && fail(m, a, b, 'notStrictEqual')
+      // eslint-disable-next-line eqeqeq
+      : (a: unknown, b: unknown, m?: string | Error) => a == b && fail(m, a, b, '!='),
+    strictEqual: (a: unknown, b: unknown, m?: string | Error) => !Object.is(a, b) && fail(m, a, b, 'strictEqual'),
+    notStrictEqual: (a: unknown, b: unknown, m?: string | Error) => Object.is(a, b) && fail(m, a, b, 'notStrictEqual'),
+    deepEqual,
+    notDeepEqual: (a: unknown, b: unknown, m?: string | Error) => (strict ? isDeepStrictEqual(a, b) : looseDeepEqual(a, b)) && fail(m, a, b, 'notDeepEqual'),
+    deepStrictEqual: (a: unknown, b: unknown, m?: string | Error) => !isDeepStrictEqual(a, b) && fail(m, a, b, 'deepStrictEqual'),
+    notDeepStrictEqual: (a: unknown, b: unknown, m?: string | Error) => isDeepStrictEqual(a, b) && fail(m, a, b, 'notDeepStrictEqual'),
+    throws,
+    doesNotThrow: (fn: () => unknown, message?: string | Error) => {
+      try {
+        fn();
+      } catch (error) {
+        fail(message ?? `Got unwanted exception: ${(error as Error)?.message ?? error}`, error, undefined, 'doesNotThrow');
+      }
+    },
+    rejects,
+    doesNotReject: async (p: Promise<unknown> | (() => Promise<unknown>), message?: string | Error) => {
+      try {
+        await (typeof p === 'function' ? p() : p);
+      } catch (error) {
+        fail(message ?? 'Got unwanted rejection.', error, undefined, 'doesNotReject');
+      }
+    },
+    match: (s: string, re: RegExp, m?: string | Error) => !re.test(s) && fail(m ?? `The input did not match the regular expression ${re}. Input: ${inspect(s)}`, s, re, 'match'),
+    doesNotMatch: (s: string, re: RegExp, m?: string | Error) => re.test(s) && fail(m, s, re, 'doesNotMatch'),
+    ifError: (value: unknown) => {
+      if (value !== null && value !== undefined) throw value;
+    },
+    fail: (message?: string | Error) => fail(message ?? 'Failed', undefined, undefined, 'fail'),
+    AssertionError,
+  });
+  assert.strict = strict ? assert : createAssertModule(true);
+  return assert;
+}

package/src/node/buffer.ts

@@ -0,0 +1,304 @@
+/**
+ * Node's Buffer as a Uint8Array subclass — the common surface: encodings
+ * (utf8, hex, base64/base64url, latin1/binary, ascii, utf16le), `from`/`alloc`/
+ * `concat`, view-sharing `slice`, search, and the fixed-width integer and float
+ * readers/writers parsers rely on. Written here rather than pulling in the
+ * CommonJS `buffer` package so the core stays native ESM.
+ */
+
+export type BufferEncoding = 'utf8' | 'utf-8' | 'hex' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'ascii' | 'ucs2' | 'ucs-2' | 'utf16le' | 'utf-16le';
+
+const utf8Encoder = new TextEncoder();
+const utf8Decoder = new TextDecoder();
+
+function normalizeEncoding(encoding: unknown): string {
+  const e = String(encoding ?? 'utf8').toLowerCase();
+  switch (e) {
+    case 'utf8': case 'utf-8': return 'utf8';
+    case 'hex': return 'hex';
+    case 'base64': return 'base64';
+    case 'base64url': return 'base64url';
+    case 'latin1': case 'binary': return 'latin1';
+    case 'ascii': return 'ascii';
+    case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return 'utf16le';
+    default: throw new TypeError(`Unknown encoding: ${String(encoding)}`);
+  }
+}
+
+function base64ToBytes(input: string): Uint8Array {
+  const clean = input.replace(/[^A-Za-z0-9+/\-_]/g, '').replace(/-/g, '+').replace(/_/g, '/');
+  const padded = clean + '='.repeat((4 - (clean.length % 4)) % 4);
+  const binary = atob(clean.length % 4 === 1 ? padded.slice(0, -3) : padded);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+
+function bytesToBinaryString(bytes: Uint8Array): string {
+  let out = '';
+  for (let i = 0; i < bytes.length; i += 0x8000) out += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+  return out;
+}
+
+export function encode(text: string, encoding?: unknown): Uint8Array {
+  switch (normalizeEncoding(encoding)) {
+    case 'utf8': return utf8Encoder.encode(text);
+    case 'hex': {
+      const length = Math.floor(text.length / 2);
+      const out = new Uint8Array(length);
+      for (let i = 0; i < length; i++) {
+        const byte = parseInt(text.substr(i * 2, 2), 16);
+        if (Number.isNaN(byte)) return out.subarray(0, i);
+        out[i] = byte;
+      }
+      return out;
+    }
+    case 'base64': case 'base64url': return base64ToBytes(text);
+    case 'utf16le': {
+      const out = new Uint8Array(text.length * 2);
+      for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        out[i * 2] = code & 0xff;
+        out[i * 2 + 1] = code >> 8;
+      }
+      return out;
+    }
+    default: { // latin1, ascii
+      const out = new Uint8Array(text.length);
+      for (let i = 0; i < text.length; i++) out[i] = text.charCodeAt(i) & 0xff;
+      return out;
+    }
+  }
+}
+
+export function decode(bytes: Uint8Array, encoding?: unknown): string {
+  switch (normalizeEncoding(encoding)) {
+    case 'utf8': return utf8Decoder.decode(bytes);
+    case 'hex': return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+    case 'base64': return btoa(bytesToBinaryString(bytes));
+    case 'base64url': return btoa(bytesToBinaryString(bytes)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    case 'ascii': return bytesToBinaryString(bytes.map((b) => b & 0x7f));
+    case 'utf16le': {
+      let out = '';
+      for (let i = 0; i + 1 < bytes.length; i += 2) out += String.fromCharCode(bytes[i]! | (bytes[i + 1]! << 8));
+      return out;
+    }
+    default: return bytesToBinaryString(bytes);
+  }
+}
+
+type BufferSource = string | ArrayBuffer | ArrayLike<number> | Uint8Array | { type: 'Buffer'; data: number[] };
+
+// Typed loosely: Node's `Buffer.from` overloads are not assignable to Uint8Array.from's.
+const Uint8ArrayBase = Uint8Array as unknown as new (...args: any[]) => Uint8Array<ArrayBuffer>;
+
+export class Buffer extends Uint8ArrayBase {
+  static poolSize = 8192;
+
+  constructor(arg: number | BufferSource, encodingOrOffset?: unknown, length?: number) {
+    if (typeof arg === 'string') super(encode(arg, encodingOrOffset));
+    else if (arg instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && arg instanceof SharedArrayBuffer)) super(arg as ArrayBuffer, encodingOrOffset as number | undefined, length);
+    else super(arg as ArrayLike<number>);
+  }
+
+  static from(value: BufferSource, encodingOrOffset?: unknown, length?: number): Buffer {
+    if (typeof value === 'string') return new Buffer(encode(value, encodingOrOffset));
+    if (value instanceof ArrayBuffer) return new Buffer(value, encodingOrOffset, length);
+    if (ArrayBuffer.isView(value)) return new Buffer(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)); // a copy
+    if (value && (value as { type?: string }).type === 'Buffer' && Array.isArray((value as { data?: unknown }).data)) return new Buffer((value as { data: number[] }).data);
+    if (value && typeof value === 'object' && typeof (value as { length?: unknown }).length === 'number') return new Buffer(value as ArrayLike<number>);
+    throw new TypeError('The first argument must be of type string, Buffer, ArrayBuffer, Array, or Array-like Object.');
+  }
+
+  static alloc(size: number, fill?: string | number | Uint8Array, encoding?: BufferEncoding): Buffer {
+    const buf = new Buffer(size);
+    if (fill !== undefined && fill !== 0) buf.fill(fill, 0, size, encoding);
+    return buf;
+  }
+
+  static allocUnsafe(size: number): Buffer {
+    return new Buffer(size);
+  }
+
+  static allocUnsafeSlow(size: number): Buffer {
+    return new Buffer(size);
+  }
+
+  static isBuffer(value: unknown): value is Buffer {
+    return value instanceof Buffer;
+  }
+
+  static isEncoding(encoding: unknown): boolean {
+    try {
+      normalizeEncoding(encoding);
+      return typeof encoding === 'string';
+    } catch {
+      return false;
+    }
+  }
+
+  static byteLength(value: string | ArrayBuffer | ArrayBufferView, encoding?: BufferEncoding): number {
+    if (typeof value === 'string') return encode(value, encoding).length;
+    return value.byteLength;
+  }
+
+  static concat(list: readonly Uint8Array[], totalLength?: number): Buffer {
+    const total = totalLength ?? list.reduce((n, b) => n + b.length, 0);
+    const out = Buffer.alloc(total);
+    let at = 0;
+    for (const item of list) {
+      if (at >= total) break;
+      out.set(item.subarray(0, total - at), at);
+      at += item.length;
+    }
+    return out;
+  }
+
+  static compare(a: Uint8Array, b: Uint8Array): number {
+    const length = Math.min(a.length, b.length);
+    for (let i = 0; i < length; i++) if (a[i] !== b[i]) return a[i]! < b[i]! ? -1 : 1;
+    return Math.sign(a.length - b.length);
+  }
+
+  get parent(): ArrayBufferLike {
+    return this.buffer;
+  }
+
+  override toString(encoding?: BufferEncoding, start = 0, end = this.length): string {
+    return decode(this.subarray(Math.max(0, start), Math.min(this.length, end)), encoding);
+  }
+
+  toLocaleString(): string {
+    return this.toString();
+  }
+
+  toJSON(): { type: 'Buffer'; data: number[] } {
+    return { type: 'Buffer', data: Array.from(this) };
+  }
+
+  equals(other: Uint8Array): boolean {
+    return Buffer.compare(this, other) === 0;
+  }
+
+  compare(target: Uint8Array, targetStart = 0, targetEnd = target.length, sourceStart = 0, sourceEnd = this.length): number {
+    return Buffer.compare(this.subarray(sourceStart, sourceEnd), target.subarray(targetStart, targetEnd));
+  }
+
+  copy(target: Uint8Array, targetStart = 0, sourceStart = 0, sourceEnd = this.length): number {
+    const chunk = this.subarray(sourceStart, Math.min(sourceEnd, sourceStart + (target.length - targetStart)));
+    target.set(chunk, targetStart);
+    return chunk.length;
+  }
+
+  /** Node's slice is a VIEW, unlike TypedArray#slice. */
+  override slice(start?: number, end?: number): Buffer {
+    return this.subarray(start, end) as Buffer;
+  }
+
+  override subarray(start?: number, end?: number): Buffer {
+    const view = super.subarray(start, end);
+    return new Buffer(view.buffer as ArrayBuffer, view.byteOffset, view.length);
+  }
+
+  write(text: string, offset?: number | string, length?: number | string, encoding?: string): number {
+    if (typeof offset === 'string') [encoding, offset, length] = [offset, 0, undefined];
+    else if (typeof length === 'string') [encoding, length] = [length, undefined];
+    const at = offset ?? 0;
+    const bytes = encode(text, encoding).subarray(0, Math.min((length as number | undefined) ?? Infinity, this.length - at));
+    this.set(bytes, at);
+    return bytes.length;
+  }
+
+  override fill(value: string | number | Uint8Array, start: number | string = 0, end: number = this.length, encoding?: BufferEncoding): this {
+    if (typeof start === 'string') [encoding, start] = [start as BufferEncoding, 0];
+    if (typeof value === 'number') return super.fill(value & 255, start, end);
+    const pattern = typeof value === 'string' ? encode(value, encoding) : value;
+    if (!pattern.length) return super.fill(0, start, end);
+    for (let i = start, j = 0; i < end; i++, j = (j + 1) % pattern.length) this[i] = pattern[j]!;
+    return this;
+  }
+
+  override indexOf(value: string | number | Uint8Array, byteOffset = 0, encoding?: BufferEncoding): number {
+    if (typeof value === 'number') return super.indexOf(value & 255, byteOffset);
+    const needle = typeof value === 'string' ? encode(value, encoding) : value;
+    const from = byteOffset < 0 ? Math.max(0, this.length + byteOffset) : byteOffset;
+    if (!needle.length) return Math.min(from, this.length);
+    outer: for (let i = from; i <= this.length - needle.length; i++) {
+      for (let j = 0; j < needle.length; j++) if (this[i + j] !== needle[j]) continue outer;
+      return i;
+    }
+    return -1;
+  }
+
+  override lastIndexOf(value: string | number | Uint8Array, byteOffset = this.length, encoding?: BufferEncoding): number {
+    if (typeof value === 'number') return super.lastIndexOf(value & 255, byteOffset);
+    const needle = typeof value === 'string' ? encode(value, encoding) : value;
+    outer: for (let i = Math.min(byteOffset, this.length - needle.length); i >= 0; i--) {
+      for (let j = 0; j < needle.length; j++) if (this[i + j] !== needle[j]) continue outer;
+      return i;
+    }
+    return -1;
+  }
+
+  override includes(value: string | number | Uint8Array, byteOffset = 0, encoding?: BufferEncoding): boolean {
+    return this.indexOf(value, byteOffset, encoding) !== -1;
+  }
+
+  private view(): DataView {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength);
+  }
+
+  readUInt8(o = 0) { return this.view().getUint8(o); }
+  readUInt16LE(o = 0) { return this.view().getUint16(o, true); }
+  readUInt16BE(o = 0) { return this.view().getUint16(o); }
+  readUInt32LE(o = 0) { return this.view().getUint32(o, true); }
+  readUInt32BE(o = 0) { return this.view().getUint32(o); }
+  readInt8(o = 0) { return this.view().getInt8(o); }
+  readInt16LE(o = 0) { return this.view().getInt16(o, true); }
+  readInt16BE(o = 0) { return this.view().getInt16(o); }
+  readInt32LE(o = 0) { return this.view().getInt32(o, true); }
+  readInt32BE(o = 0) { return this.view().getInt32(o); }
+  readFloatLE(o = 0) { return this.view().getFloat32(o, true); }
+  readFloatBE(o = 0) { return this.view().getFloat32(o); }
+  readDoubleLE(o = 0) { return this.view().getFloat64(o, true); }
+  readDoubleBE(o = 0) { return this.view().getFloat64(o); }
+  readBigUInt64LE(o = 0) { return this.view().getBigUint64(o, true); }
+  readBigUInt64BE(o = 0) { return this.view().getBigUint64(o); }
+  readBigInt64LE(o = 0) { return this.view().getBigInt64(o, true); }
+  readBigInt64BE(o = 0) { return this.view().getBigInt64(o); }
+  writeUInt8(v: number, o = 0) { this.view().setUint8(o, v); return o + 1; }
+  writeUInt16LE(v: number, o = 0) { this.view().setUint16(o, v, true); return o + 2; }
+  writeUInt16BE(v: number, o = 0) { this.view().setUint16(o, v); return o + 2; }
+  writeUInt32LE(v: number, o = 0) { this.view().setUint32(o, v, true); return o + 4; }
+  writeUInt32BE(v: number, o = 0) { this.view().setUint32(o, v); return o + 4; }
+  writeInt8(v: number, o = 0) { this.view().setInt8(o, v); return o + 1; }
+  writeInt16LE(v: number, o = 0) { this.view().setInt16(o, v, true); return o + 2; }
+  writeInt16BE(v: number, o = 0) { this.view().setInt16(o, v); return o + 2; }
+  writeInt32LE(v: number, o = 0) { this.view().setInt32(o, v, true); return o + 4; }
+  writeInt32BE(v: number, o = 0) { this.view().setInt32(o, v); return o + 4; }
+  writeFloatLE(v: number, o = 0) { this.view().setFloat32(o, v, true); return o + 4; }
+  writeFloatBE(v: number, o = 0) { this.view().setFloat32(o, v); return o + 4; }
+  writeDoubleLE(v: number, o = 0) { this.view().setFloat64(o, v, true); return o + 8; }
+  writeDoubleBE(v: number, o = 0) { this.view().setFloat64(o, v); return o + 8; }
+  writeBigUInt64LE(v: bigint, o = 0) { this.view().setBigUint64(o, v, true); return o + 8; }
+  writeBigUInt64BE(v: bigint, o = 0) { this.view().setBigUint64(o, v); return o + 8; }
+}
+
+// Lower-case aliases (readUint8 etc.) that Node also exposes.
+for (const name of Object.getOwnPropertyNames(Buffer.prototype)) {
+  const alias = name.replace(/UInt/, 'Uint');
+  if (alias !== name) Object.defineProperty(Buffer.prototype, alias, Object.getOwnPropertyDescriptor(Buffer.prototype, name)!);
+}
+
+export function createBufferModule(): Record<string, unknown> {
+  return {
+    Buffer,
+    SlowBuffer: Buffer,
+    kMaxLength: 2 ** 31 - 1,
+    constants: { MAX_LENGTH: 2 ** 31 - 1, MAX_STRING_LENGTH: 2 ** 29 - 24 },
+    INSPECT_MAX_BYTES: 50,
+    Blob: globalThis.Blob,
+    atob: globalThis.atob,
+    btoa: globalThis.btoa,
+  };
+}

package/src/node/builtins.ts

@@ -0,0 +1,123 @@
+/**
+ * The builtin module table for one runtime. Modules are built lazily on first
+ * `require` (most programs touch a handful) and are per-process, because `fs`,
+ * `path` and `process` close over that process's cwd, IO and event loop.
+ */
+import type { VirtualFileSystem } from '../vfs.js';
+import type { ProgramIO, System } from '../system/types.js';
+import type { EventLoop } from './loop.js';
+import type { NodeProcess } from './process.js';
+import { createEventsModule } from './events.js';
+import { createBufferModule } from './buffer.js';
+import { createPathModule } from './path.js';
+import { createUtilModule, types as utilTypes } from './util.js';
+import { createStreamModule } from './stream/index.js';
+import { createFsModule } from './fs/index.js';
+import { constants as fsConstants } from './fs/stats.js';
+import { createCryptoModule } from './crypto.js';
+import { createQuerystringModule, createUrlModule } from './urlqs.js';
+import { createAssertModule } from './assert.js';
+import { createZlibModule } from './zlib.js';
+import { createHttpModule, createNetModule, createFetch } from './http/index.js';
+import { createChildProcessModule } from './childProcess.js';
+import { createReadlineModule } from './readline.js';
+import { createAsyncHooksModule, createDiagnosticsChannelModule, createOsModule, createStringDecoderModule, createStubModules, createTimersModule, createTtyModule, createVmModule } from './misc.js';
+
+
+export interface BuiltinDeps {
+  fs: VirtualFileSystem;
+  process: NodeProcess;
+  loop: EventLoop;
+  system: System;
+  io: ProgramIO;
+  console: Console;
+}
+
+type Factory = (get: (name: string) => any) => unknown;
+
+export function createBuiltins(deps: BuiltinDeps) {
+  const { process: proc, loop, system } = deps;
+  const env = () => proc.env as Record<string, string | undefined>;
+  const stubs = createStubModules();
+  const clientDeps = { system, loop };
+
+  const factories: Record<string, Factory> = {
+    assert: () => createAssertModule(false),
+    'assert/strict': () => createAssertModule(true),
+    async_hooks: () => createAsyncHooksModule(),
+    buffer: () => createBufferModule(),
+    child_process: () =>
+      createChildProcessModule({
+        system,
+        loop,
+        cwd: () => proc.cwd(),
+        env,
+        stdout: (c) => proc.stdout.write(c),
+        stderr: (c) => proc.stderr.write(c),
+      }),
+    console: () => Object.assign(Object.create(deps.console), { Console: function Console() { return deps.console; } }),
+    constants: (get) => ({ ...fsConstants, ...(get('os').constants.signals as object) }),
+    crypto: () => createCryptoModule(),
+    diagnostics_channel: () => createDiagnosticsChannelModule(),
+    'dns/promises': (get) => get('dns').promises,
+    events: () => createEventsModule(),
+    fs: () => createFsModule({ vfs: deps.fs, cwd: () => proc.cwd(), stdout: deps.io.stdout, stderr: deps.io.stderr, hold: () => loop.hold() }),
+    'fs/promises': (get) => get('fs').promises,
+    http: () => createHttpModule(clientDeps, 'http:'),
+    https: () => createHttpModule(clientDeps, 'https:'),
+    net: () => createNetModule(clientDeps),
+    os: () => createOsModule(env),
+    path: () => createPathModule(() => proc.cwd()),
+    'path/posix': (get) => get('path'),
+    'path/win32': (get) => get('path'),
+    process: () => proc,
+    querystring: () => createQuerystringModule(),
+    readline: () => createReadlineModule(),
+    'readline/promises': (get) => get('readline').promises,
+    stream: () => createStreamModule(),
+    'stream/promises': (get) => get('stream').promises,
+    'stream/web': () => ({ ReadableStream, WritableStream, TransformStream, TextEncoderStream, TextDecoderStream, ByteLengthQueuingStrategy, CountQueuingStrategy }),
+    'stream/consumers': () => ({
+      text: async (stream: AsyncIterable<unknown>) => {
+        let out = '';
+        for await (const chunk of stream) out += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk as Uint8Array);
+        return out;
+      },
+      json: async (stream: AsyncIterable<unknown>) => {
+        let out = '';
+        for await (const chunk of stream) out += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk as Uint8Array);
+        return JSON.parse(out);
+      },
+    }),
+    string_decoder: () => createStringDecoderModule(),
+    sys: (get) => get('util'),
+    timers: () => createTimersModule(loop),
+    'timers/promises': (get) => get('timers').promises,
+    tty: () => createTtyModule(!!deps.io.terminal),
+    url: (get) => createUrlModule(get('querystring')),
+    util: () => createUtilModule(env, (message) => proc.stderr.write(message + '\n')),
+    'util/types': () => utilTypes,
+    vm: () => createVmModule(),
+    zlib: () => createZlibModule(),
+  };
+  for (const [name, mod] of Object.entries(stubs)) factories[name] ??= () => mod;
+
+  const cache = new Map<string, unknown>();
+  const get = (name: string): any => {
+    if (cache.has(name)) return cache.get(name);
+    const factory = factories[name];
+    if (!factory) throw Object.assign(new Error(`No such built-in module: ${name}`), { code: 'ERR_UNKNOWN_BUILTIN_MODULE' });
+    const mod = factory(get);
+    cache.set(name, mod);
+    return mod;
+  };
+
+  return {
+    names: [...Object.keys(factories), 'module'].sort(),
+    isBuiltin: (name: string) => name === 'module' || name in factories,
+    get,
+    fetch: createFetch(clientDeps),
+  };
+}
+
+export type Builtins = ReturnType<typeof createBuiltins>;

package/src/node/callable.ts

@@ -0,0 +1,25 @@
+/**
+ * Pre-ES2015 packages subclass Node's constructors the old way:
+ *
+ *     function MyStream(opts) { Readable.call(this, opts); }
+ *     util.inherits(MyStream, Readable);
+ *
+ * Calling an ES class without `new` throws, so the shims we expose are plain
+ * functions wrapping the class: `new`/`extends` construct the class, a bare
+ * call runs its `init` on the caller's `this`. The prototype is shared, so
+ * `instanceof` holds either way.
+ */
+export function callable<C extends abstract new (...args: any[]) => object>(Base: C, init: (self: any, ...args: any[]) => void): C {
+  const Wrapped = function (this: unknown, ...args: unknown[]) {
+    if (!new.target) {
+      init(this, ...args);
+      return this;
+    }
+    return Reflect.construct(Base, args, new.target);
+  } as unknown as C;
+  Object.defineProperty(Wrapped, 'name', { value: Base.name });
+  (Wrapped as unknown as { prototype: object }).prototype = Base.prototype;
+  Object.setPrototypeOf(Wrapped, Base); // statics
+  Object.defineProperty(Base.prototype, 'constructor', { value: Wrapped, writable: true, configurable: true, enumerable: false });
+  return Wrapped;
+}