@seanhogg/builderforce-webcontainers-core 2026.10.2 → 2026.10.4

package/src/node/resolve.ts

@@ -0,0 +1,216 @@
+/**
+ * Node's module resolution over the VFS: builtins (`fs`, `node:fs`), relative and
+ * absolute paths with extension and directory probing, `node_modules` lookup up
+ * the tree, package.json `main`, `exports` (conditions, subpath patterns, arrays,
+ * `null` exclusions), `imports` (`#internal`) and package self-reference.
+ *
+ * Distinct from ../resolve.ts, which resolves the way Vite does for the preview.
+ */
+import type { VirtualFileSystem } from '../vfs.js';
+import { dirname, join, normalizePath } from '../paths.js';
+import { splitPackageSpecifier } from '../resolve.js';
+
+/** Conditions `require()` matches; `import` swaps `require` for `import`. */
+export const REQUIRE_CONDITIONS = ['node', 'require', 'default'] as const;
+export const IMPORT_CONDITIONS = ['node', 'import', 'default'] as const;
+
+const EXTENSIONS = ['.js', '.json', '.cjs', '.mjs', '.node'];
+
+export type Resolution = { builtin: string } | { path: string };
+
+interface PackageJsonLike {
+  name?: string;
+  main?: string;
+  type?: string;
+  exports?: unknown;
+  imports?: unknown;
+}
+
+export function moduleNotFound(request: string, from?: string): Error {
+  const error = new Error(`Cannot find module '${request}'${from ? `\nRequire stack:\n- ${from}` : ''}`) as Error & { code: string; requireStack?: string[] };
+  error.code = 'MODULE_NOT_FOUND';
+  if (from) error.requireStack = [from];
+  return error;
+}
+
+function readPackageJson(fs: VirtualFileSystem, dir: string): PackageJsonLike | undefined {
+  const text = fs.readText(join(dir, 'package.json'));
+  if (text === undefined) return undefined;
+  try {
+    return JSON.parse(text) as PackageJsonLike;
+  } catch {
+    return undefined;
+  }
+}
+
+/** The nearest package.json at or above `dir`: its directory and contents. */
+export function findPackageScope(fs: VirtualFileSystem, dir: string): { dir: string; pkg: PackageJsonLike } | undefined {
+  for (let current = normalizePath(dir); ; current = dirname(current)) {
+    if (!current.endsWith('/node_modules')) {
+      const pkg = readPackageJson(fs, current);
+      if (pkg) return { dir: current, pkg };
+    }
+    if (current === '/') return undefined;
+  }
+}
+
+function loadAsFile(fs: VirtualFileSystem, path: string): string | undefined {
+  if (fs.isFile(path)) return path;
+  for (const ext of EXTENSIONS) if (fs.isFile(path + ext)) return path + ext;
+  return undefined;
+}
+
+function loadIndex(fs: VirtualFileSystem, dir: string): string | undefined {
+  for (const ext of EXTENSIONS) if (fs.isFile(join(dir, 'index' + ext))) return join(dir, 'index' + ext);
+  return undefined;
+}
+
+function loadAsDirectory(fs: VirtualFileSystem, dir: string): string | undefined {
+  if (!fs.isDirectory(dir)) return undefined;
+  const main = readPackageJson(fs, dir)?.main;
+  if (typeof main === 'string' && main) {
+    const target = join(dir, main);
+    const hit = loadAsFile(fs, target) ?? loadIndex(fs, target);
+    if (hit) return hit;
+  }
+  return loadIndex(fs, dir);
+}
+
+function loadPath(fs: VirtualFileSystem, path: string): string | undefined {
+  return loadAsFile(fs, path) ?? loadAsDirectory(fs, path);
+}
+
+/** Resolve one exports/imports target against `conditions`. `null` = explicitly excluded. */
+function resolveTarget(target: unknown, match: string, conditions: readonly string[]): string | null | undefined {
+  if (typeof target === 'string') return target.replace(/\*/g, match);
+  if (Array.isArray(target)) {
+    for (const item of target) {
+      const hit = resolveTarget(item, match, conditions);
+      if (hit !== undefined) return hit;
+    }
+    return undefined;
+  }
+  if (target && typeof target === 'object') {
+    for (const [key, value] of Object.entries(target)) {
+      if (key !== 'default' && !conditions.includes(key)) continue;
+      const hit = resolveTarget(value, match, conditions);
+      if (hit !== undefined) return hit;
+    }
+    return undefined;
+  }
+  return target === null ? null : undefined;
+}
+
+/** Match `subpath` (`.`, `./feature`, `#dep`) in an exports/imports map. */
+export function resolveMap(map: unknown, subpath: string, conditions: readonly string[]): string | null | undefined {
+  const isSugar = typeof map === 'string' || Array.isArray(map) || (map && typeof map === 'object' && !Object.keys(map).some((k) => k.startsWith('.') || k.startsWith('#')));
+  const record = (isSugar ? { '.': map } : map) as Record<string, unknown>;
+  if (!record || typeof record !== 'object') return undefined;
+  if (Object.prototype.hasOwnProperty.call(record, subpath) && !subpath.includes('*')) return resolveTarget(record[subpath], '', conditions);
+
+  let best: { key: string; match: string } | undefined;
+  for (const key of Object.keys(record)) {
+    const star = key.indexOf('*');
+    if (star >= 0) {
+      const prefix = key.slice(0, star);
+      const suffix = key.slice(star + 1);
+      if (subpath.startsWith(prefix) && subpath.length >= key.length - 1 && subpath.endsWith(suffix) && (!best || prefix.length > best.key.indexOf('*'))) {
+        best = { key, match: subpath.slice(prefix.length, subpath.length - suffix.length) };
+      }
+    } else if (key.endsWith('/') && subpath.startsWith(key) && (!best || key.length > best.key.length)) {
+      best = { key, match: '' }; // legacy folder mapping
+    }
+  }
+  if (!best) return undefined;
+  const resolved = resolveTarget(record[best.key], best.match, conditions);
+  if (resolved && best.key.endsWith('/') && !best.key.includes('*')) return resolved + subpath.slice(best.key.length);
+  return resolved;
+}
+
+function exportsError(name: string, subpath: string): Error {
+  const error = new Error(`Package subpath '${subpath}' is not defined by "exports" in /node_modules/${name}/package.json`) as Error & { code: string };
+  error.code = 'ERR_PACKAGE_PATH_NOT_EXPORTED';
+  return error;
+}
+
+function resolvePackage(fs: VirtualFileSystem, pkgDir: string, name: string, subpath: string, conditions: readonly string[], request: string, from?: string): string {
+  const pkg = readPackageJson(fs, pkgDir);
+  if (pkg?.exports !== undefined && pkg.exports !== null) {
+    const key = subpath ? `.${subpath}` : '.';
+    const target = resolveMap(pkg.exports, key, conditions);
+    if (!target) throw exportsError(name, key);
+    const file = join(pkgDir, target);
+    if (fs.isFile(file)) return file;
+    throw moduleNotFound(request, from);
+  }
+  const hit = loadPath(fs, join(pkgDir, subpath || '.'));
+  if (!hit) throw moduleNotFound(request, from);
+  return hit;
+}
+
+export interface NodeResolveOptions {
+  conditions: readonly string[];
+  isBuiltin(name: string): boolean;
+  /** The requiring file, for "Require stack" in errors. */
+  from?: string;
+  /** Extra lookup roots (`require.resolve(x, { paths })`). */
+  paths?: string[];
+}
+
+export function resolveNodeModule(fs: VirtualFileSystem, request: string, fromDir: string, options: NodeResolveOptions): Resolution {
+  const { conditions, from } = options;
+  if (request.startsWith('node:')) {
+    const name = request.slice(5);
+    if (!options.isBuiltin(name)) throw Object.assign(new Error(`No such built-in module: ${request}`), { code: 'ERR_UNKNOWN_BUILTIN_MODULE' });
+    return { builtin: name };
+  }
+  if (options.isBuiltin(request)) return { builtin: request };
+
+  if (request.startsWith('#')) {
+    const scope = findPackageScope(fs, fromDir);
+    const target = scope?.pkg.imports ? resolveMap(scope.pkg.imports, request, conditions) : undefined;
+    if (!target || !scope) throw Object.assign(new Error(`Package import specifier "${request}" is not defined${scope ? ` in package ${scope.dir}/package.json` : ''}`), { code: 'ERR_PACKAGE_IMPORT_NOT_DEFINED' });
+    if (!target.startsWith('./')) return resolveNodeModule(fs, target, scope.dir, options);
+    const file = join(scope.dir, target);
+    if (fs.isFile(file)) return { path: file };
+    throw moduleNotFound(request, from);
+  }
+
+  if (request === '.' || request === '..' || request.startsWith('./') || request.startsWith('../') || request.startsWith('/')) {
+    const base = request.startsWith('/') ? normalizePath(request) : join(fromDir, request);
+    const hit = request.endsWith('/') ? loadAsDirectory(fs, base) : loadPath(fs, base);
+    if (!hit) throw moduleNotFound(request, from);
+    return { path: hit };
+  }
+
+  const { name, subpath } = splitPackageSpecifier(request);
+  // Self-reference: a package importing itself by name through its own "exports".
+  const scope = findPackageScope(fs, fromDir);
+  if (scope?.pkg.name === name && scope.pkg.exports !== undefined) {
+    return { path: resolvePackage(fs, scope.dir, name, subpath, conditions, request, from) };
+  }
+  const roots = options.paths ?? [];
+  const lookup: string[] = [];
+  for (let dir = normalizePath(fromDir); ; dir = dirname(dir)) {
+    if (!dir.endsWith('/node_modules')) lookup.push(join(dir, 'node_modules'));
+    if (dir === '/') break;
+  }
+  for (const root of roots) lookup.push(root.endsWith('node_modules') ? root : join(root, 'node_modules'));
+  for (const nm of lookup) {
+    const pkgDir = join(nm, name);
+    if (fs.isDirectory(pkgDir) || fs.isFile(pkgDir + '.js') || fs.isFile(pkgDir + '.json')) {
+      if (!fs.isDirectory(pkgDir)) return { path: loadAsFile(fs, pkgDir)! };
+      return { path: resolvePackage(fs, pkgDir, name, subpath, conditions, request, from) };
+    }
+  }
+  throw moduleNotFound(request, from);
+}
+
+/** `module.paths` for a directory: every enclosing node_modules. */
+export function nodeModulePaths(fromDir: string): string[] {
+  const out: string[] = [];
+  for (let dir = normalizePath(fromDir); ; dir = dirname(dir)) {
+    if (!dir.endsWith('/node_modules')) out.push(join(dir, 'node_modules'));
+    if (dir === '/') return out;
+  }
+}

package/src/node/runtime.ts

@@ -0,0 +1,184 @@
+/**
+ * One Node process: event loop + process object + builtins + module system,
+ * wired to a program's IO and the system's ports. `startNode` evaluates the
+ * entry and resolves `exit` with the code once the process exits — by
+ * `process.exit()`, an uncaught exception, being killed, or the loop going idle.
+ */
+import type { ProgramIO, System } from '../system/types.js';
+import { Buffer } from './buffer.js';
+import { createBuiltins } from './builtins.js';
+import { createModuleSystem, type ModuleSystem } from './loader.js';
+import { EventLoop } from './loop.js';
+import { createConsole, createProcess, ProcessExit, type NodeProcess } from './process.js';
+import { esmReady } from './esm.js';
+import { inspect } from './inspect.js';
+
+export interface NodeOptions {
+  system: System;
+  io: ProgramIO;
+  cwd: string;
+  env: Record<string, string>;
+  /** `process.argv` from index 1: the script path, then its arguments. */
+  argv: string[];
+  /**
+   * Also install `process`, `Buffer`, `global`, timers and `fetch` on
+   * `globalThis` — for a dedicated worker, where code reaching for globals
+   * directly (`globalThis.process`) must find them. Off when several runtimes
+   * share one realm.
+   */
+  installGlobals?: boolean;
+}
+
+export interface NodeInstance {
+  readonly process: NodeProcess;
+  readonly modules: ModuleSystem;
+  /** Settles with the exit code. */
+  readonly exit: Promise<number>;
+  /** Run code in the process (the entry, `-e`, a REPL line). Errors become uncaught exceptions. */
+  run(fn: () => unknown): void;
+  /** Deliver a signal: `SIGINT` runs listeners if any, otherwise exits 130. */
+  kill(signal?: string): void;
+  /** An error the host caught outside the loop (a worker's unhandledrejection). */
+  reportUncaught(error: unknown): void;
+  /** Keep the process alive until the returned function is called. */
+  hold(): () => void;
+}
+
+const SIGNAL_CODES: Record<string, number> = { SIGINT: 130, SIGTERM: 143, SIGKILL: 137, SIGHUP: 129 };
+
+export async function startNode(options: NodeOptions): Promise<NodeInstance> {
+  await esmReady;
+  const { system, io } = options;
+  let resolveExit!: (code: number) => void;
+  const exit = new Promise<number>((resolve) => (resolveExit = resolve));
+  let finished = false;
+  const servers = new Set<{ close(): void }>();
+
+  // Servers die with the process: wrap listen so exit can close what is left open.
+  const processSystem: System = {
+    ...system,
+    listen(port, handler) {
+      const registration = system.listen(port, handler);
+      const tracked = {
+        port: registration.port,
+        close() {
+          servers.delete(tracked);
+          registration.close();
+        },
+      };
+      servers.add(tracked);
+      return tracked;
+    },
+  };
+
+  const finish = (code: number) => {
+    if (finished) return;
+    finished = true;
+    loop.stop();
+    for (const server of [...servers]) server.close();
+    resolveExit(code);
+  };
+
+  const uncaught = (error: unknown) => {
+    if (error instanceof ProcessExit || finished) return;
+    if (proc.listenerCount('uncaughtException')) {
+      try {
+        proc.emit('uncaughtException', error, 'uncaughtException');
+        return;
+      } catch (nested) {
+        error = nested;
+      }
+    }
+    const text = error instanceof Error ? error.stack ?? `${error.name}: ${error.message}` : `Uncaught ${inspect(error)}`;
+    io.stderr(`${text}\n\nNode.js v${proc.versions.node}\n`);
+    exitQuietly(proc.exitCode && proc.exitCode !== 0 ? proc.exitCode : 1);
+  };
+
+  const exitQuietly = (code?: number) => {
+    try {
+      proc.exit(code);
+    } catch (error) {
+      if (!(error instanceof ProcessExit)) throw error;
+    }
+  };
+
+  const loop = new EventLoop({
+    onIdle() {
+      if (finished) return;
+      try {
+        proc.emit('beforeExit', Number(proc.exitCode ?? 0));
+      } catch (error) {
+        uncaught(error);
+      }
+      if (loop.alive) return; // a beforeExit listener scheduled more work
+      exitQuietly();
+    },
+    onError: uncaught,
+  });
+
+  const proc = createProcess({
+    argv: ['/usr/local/bin/node', ...options.argv],
+    env: options.env,
+    cwd: options.cwd,
+    fs: system.fs,
+    io,
+    loop,
+    onExit: finish,
+  });
+  const console = createConsole(proc);
+  const builtins = createBuiltins({ fs: system.fs, process: proc, loop, system: processSystem, io, console });
+
+  const globals: Record<string, unknown> = {
+    process: proc,
+    Buffer,
+    console,
+    setTimeout: loop.setTimeout,
+    setInterval: loop.setInterval,
+    setImmediate: loop.setImmediate,
+    clearTimeout: loop.clearTimeout,
+    clearInterval: loop.clearInterval,
+    clearImmediate: loop.clearImmediate,
+    fetch: builtins.fetch,
+  };
+  if (options.installGlobals) {
+    Object.assign(globalThis, globals, { global: globalThis });
+    globals.global = globalThis;
+  } else {
+    // A per-process view of the global object: reads fall through to the real
+    // one, Node's own names resolve to this process's.
+    globals.global = Object.assign(Object.create(globalThis), globals);
+  }
+  globals.globalThis = globals.global;
+
+  const modules = createModuleSystem({ fs: system.fs, isBuiltin: builtins.isBuiltin, builtin: builtins.get, globals });
+  (modules.Module as unknown as { builtinModules: string[] }).builtinModules = builtins.names;
+  Object.defineProperty(proc, 'mainModule', { get: () => modules.main, configurable: true });
+
+  const run = (fn: () => unknown) => {
+    if (finished) return;
+    try {
+      const result = fn();
+      if (result instanceof Promise) result.catch(uncaught).finally(() => loop.scheduleCheck());
+    } catch (error) {
+      uncaught(error);
+    }
+    loop.scheduleCheck();
+  };
+
+  return {
+    process: proc,
+    modules,
+    exit,
+    run,
+    kill(signal = 'SIGTERM') {
+      if (finished) return;
+      if (signal !== 'SIGKILL' && proc.listenerCount(signal)) {
+        loop._run(() => proc.emit(signal, signal));
+        return;
+      }
+      finish(SIGNAL_CODES[signal] ?? 1);
+    },
+    reportUncaught: uncaught,
+    hold: () => loop.hold(),
+  };
+}

package/src/node/stream/index.ts

@@ -0,0 +1,196 @@
+/**
+ * Duplex, Transform, PassThrough, the legacy `Stream` base, and the `stream`
+ * module object with `pipeline`/`finished` (callback and promise forms).
+ */
+import { EventEmitterBase } from '../events.js';
+import { callable } from '../callable.js';
+import { initReadable, Readable, tick, type ReadableOptions } from './readable.js';
+import { initWritable, Writable, type WritableOptions } from './writable.js';
+
+type Callback = (error?: Error | null) => void;
+type AnyStream = EventEmitterBase & { destroy?(error?: Error): unknown; pipe?(dest: unknown, opts?: unknown): unknown; _readableState?: { endEmitted: boolean }; _writableState?: { finished: boolean } };
+
+/** The pre-streams2 base class: an emitter with a simple `pipe`. */
+class LegacyStream extends EventEmitterBase {
+  pipe(dest: { write(chunk: unknown): boolean; end(): void }): unknown {
+    this.on('data', (chunk: unknown) => dest.write(chunk));
+    this.on('end', () => dest.end());
+    return dest;
+  }
+}
+Object.setPrototypeOf(Readable.prototype, LegacyStream.prototype);
+Object.setPrototypeOf(Writable.prototype, LegacyStream.prototype);
+
+export interface DuplexOptions extends Omit<ReadableOptions, 'destroy'>, Omit<WritableOptions, 'destroy'> {
+  allowHalfOpen?: boolean;
+  destroy?(this: Duplex, error: Error | null, callback: (error?: Error | null) => void): void;
+}
+
+function initDuplex(self: Duplex, options: DuplexOptions = {}): void {
+  initReadable(self, options as ReadableOptions);
+  initWritable(self as unknown as Writable, options as WritableOptions);
+  self.allowHalfOpen = options.allowHalfOpen !== false;
+  if (!self.allowHalfOpen) self.once('end', () => (self as unknown as Writable).end());
+}
+
+export interface Duplex extends Omit<Writable, keyof EventEmitterBase | 'destroy' | 'destroyed' | '_destroy' | '_write' | '_final'> {
+  _write(chunk: any, encoding: string, callback: Callback): void;
+  _final?(callback: Callback): void;
+}
+export class Duplex extends Readable {
+  declare allowHalfOpen: boolean;
+
+  constructor(options?: DuplexOptions) {
+    super(options);
+    initDuplex(this, options);
+  }
+
+  override destroy(error?: Error | null): this {
+    const w = this._writableState;
+    if (w) w.destroyed = true;
+    return super.destroy(error);
+  }
+}
+for (const key of Object.getOwnPropertyNames(Writable.prototype)) {
+  if (key === 'constructor' || key === 'destroy' || key === 'destroyed' || key === '_destroy' || key in Duplex.prototype && Object.getOwnPropertyDescriptor(Duplex.prototype, key)) continue;
+  Object.defineProperty(Duplex.prototype, key, Object.getOwnPropertyDescriptor(Writable.prototype, key)!);
+}
+
+export interface TransformOptions extends DuplexOptions {
+  transform?(this: Transform, chunk: any, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+  flush?(this: Transform, callback: (error?: Error | null, data?: unknown) => void): void;
+}
+
+function initTransform(self: Transform, options: TransformOptions = {}): void {
+  initDuplex(self, options);
+  if (typeof options.transform === 'function') self._transform = options.transform;
+  if (typeof options.flush === 'function') self._flush = options.flush;
+}
+
+export class Transform extends Duplex {
+  _flush?(callback: (error?: Error | null, data?: unknown) => void): void;
+
+  constructor(options?: TransformOptions) {
+    super(options);
+    initTransform(this, options);
+  }
+
+  _transform(_chunk: unknown, _encoding: string, _callback: (error?: Error | null, data?: unknown) => void): void {
+    throw new Error('The _transform() method is not implemented');
+  }
+
+  override _read(): void {
+    // data is pushed as it is written
+  }
+
+  _write(chunk: unknown, encoding: string, callback: Callback): void {
+    this._transform(chunk, encoding, (error, data) => {
+      if (error) return callback(error);
+      if (data !== undefined && data !== null) this.push(data);
+      callback();
+    });
+  }
+
+  _final(callback: Callback): void {
+    const done = (error?: Error | null, data?: unknown) => {
+      if (error) return callback(error);
+      if (data !== undefined && data !== null) this.push(data);
+      this.push(null);
+      callback();
+    };
+    if (this._flush) this._flush(done);
+    else done();
+  }
+}
+
+export class PassThrough extends Transform {
+  override _transform(chunk: unknown, _encoding: string, callback: (error?: Error | null, data?: unknown) => void): void {
+    callback(null, chunk);
+  }
+}
+
+/** Call back once when `stream` has ended, finished, errored or closed. */
+export function finished(stream: AnyStream, options: unknown, callback?: Callback): () => void {
+  const cb = (typeof options === 'function' ? options : callback) as Callback;
+  let done = false;
+  const once = (error?: Error | null) => {
+    if (done) return;
+    done = true;
+    cleanup();
+    cb(error ?? null);
+  };
+  const onError = (error: Error) => once(error);
+  const onEnd = () => once();
+  const onClose = () => {
+    const r = stream._readableState;
+    const w = stream._writableState;
+    if ((r && !r.endEmitted) || (w && !w.finished)) once(Object.assign(new Error('Premature close'), { code: 'ERR_STREAM_PREMATURE_CLOSE' }));
+    else once();
+  };
+  const isWritableOnly = !!stream._writableState && !stream._readableState;
+  stream.on('error', onError);
+  stream.on(isWritableOnly ? 'finish' : 'end', onEnd);
+  if (stream._readableState && stream._writableState) stream.on('finish', () => stream._readableState!.endEmitted && once());
+  stream.on('close', onClose);
+  const cleanup = () => {
+    stream.removeListener('error', onError);
+    stream.removeListener('end', onEnd);
+    stream.removeListener('finish', onEnd);
+    stream.removeListener('close', onClose);
+  };
+  if ((stream._readableState?.endEmitted && !stream._writableState) || (isWritableOnly && stream._writableState!.finished)) tick(() => once());
+  return cleanup;
+}
+
+export function pipeline(...args: unknown[]): unknown {
+  const callback = typeof args[args.length - 1] === 'function' ? (args.pop() as Callback) : undefined;
+  const streams = (Array.isArray(args[0]) ? args[0] : args) as AnyStream[];
+  if (streams.length < 2) throw new Error('pipeline requires at least two streams');
+  let failed = false;
+  const fail = (error: Error) => {
+    if (failed) return;
+    failed = true;
+    for (const s of streams) s.destroy?.(error);
+    callback?.(error);
+  };
+  for (let i = 0; i < streams.length - 1; i++) streams[i]!.pipe!(streams[i + 1]);
+  streams.forEach((s, i) => {
+    if (i < streams.length - 1) s.on('error', fail);
+  });
+  const last = streams[streams.length - 1]!;
+  finished(last, (error?: Error | null) => {
+    if (error) fail(error);
+    else if (!failed) callback?.(null);
+  });
+  return last;
+}
+
+export function createStreamModule(): Record<string, unknown> {
+  const Stream = callable(LegacyStream, () => undefined) as unknown as Record<string, unknown>;
+  const wrapped = {
+    Readable: callable(Readable, (self, options) => initReadable(self, options)),
+    Writable: callable(Writable, (self, options) => initWritable(self, options)),
+    Duplex: callable(Duplex, (self, options) => initDuplex(self, options)),
+    Transform: callable(Transform, (self, options) => initTransform(self, options)),
+    PassThrough: callable(PassThrough, (self, options) => initTransform(self, options)),
+  };
+  const promises = {
+    pipeline: (...streams: unknown[]) => new Promise<void>((resolve, reject) => pipeline(...streams, (error?: Error | null) => (error ? reject(error) : resolve()))),
+    finished: (stream: AnyStream) => new Promise<void>((resolve, reject) => finished(stream, (error?: Error | null) => (error ? reject(error) : resolve()))),
+  };
+  Object.assign(Stream, wrapped, {
+    Stream,
+    pipeline,
+    finished,
+    promises,
+    addAbortSignal: (_signal: AbortSignal, stream: unknown) => stream,
+    isReadable: (s: Readable) => !!s?.readable,
+    isErrored: (s: Readable) => !!s?._readableState?.errored,
+    isDisturbed: (s: Readable) => !!s?._readableState?.endEmitted || (s?._readableState?.flowing ?? null) !== null,
+    getDefaultHighWaterMark: (objectMode: boolean) => (objectMode ? 16 : 16 * 1024),
+    setDefaultHighWaterMark: () => undefined,
+  });
+  return Stream;
+}
+
+export { Readable, Writable, tick };