@seanhogg/builderforce-webcontainers-core 2026.10.2 → 2026.10.3

package/src/node/process.ts

@@ -0,0 +1,324 @@
+/**
+ * The `process` object of one runtime: argv/env/cwd, `exit` (unwinds via
+ * {@link ProcessExit}), `nextTick`, stdio streams wired to the program's IO
+ * port, and the identity a Linux Node 20 reports — packages branch on
+ * `process.platform`, `process.versions.node` and `process.stdout.isTTY`.
+ */
+import { EventEmitterBase } from './events.js';
+import { Readable } from './stream/readable.js';
+import { Writable } from './stream/writable.js';
+import type { EventLoop } from './loop.js';
+import type { ProgramIO } from '../system/types.js';
+import type { VirtualFileSystem } from '../vfs.js';
+import { join, normalizePath } from '../paths.js';
+import { fsError } from './fs/stats.js';
+import { format } from './inspect.js';
+
+export const NODE_VERSION = '20.18.0';
+
+/** Thrown by `process.exit()` to unwind user code; the runtime catches it. */
+export class ProcessExit {
+  constructor(readonly code: number) {}
+}
+
+let nextPid = 100;
+
+export interface ProcessOptions {
+  argv: string[];
+  env: Record<string, string>;
+  cwd: string;
+  fs: VirtualFileSystem;
+  io: ProgramIO;
+  loop: EventLoop;
+  /** Called once with the exit code; the runtime tears down. */
+  onExit(code: number): void;
+}
+
+class TtyWriteStream extends Writable {
+  isTTY: boolean;
+  fd: number;
+  columns?: number;
+  rows?: number;
+
+  constructor(fd: number, private readonly sink: (chunk: string | Uint8Array) => void, terminal: ProgramIO['terminal']) {
+    super({ decodeStrings: false });
+    this.fd = fd;
+    this.isTTY = !!terminal;
+    if (terminal) {
+      this.columns = terminal.cols;
+      this.rows = terminal.rows;
+      terminal.onResize((cols, rows) => {
+        this.columns = cols;
+        this.rows = rows;
+        this.emit('resize');
+      });
+    }
+  }
+
+  override _write(chunk: string | Uint8Array, _encoding: string, callback: () => void): void {
+    this.sink(chunk);
+    callback();
+  }
+
+  /** Synchronous, like Node's stdout to a TTY or file: output order matches call order. */
+  override write(chunk: unknown, encoding?: any, callback?: any): boolean {
+    if (typeof encoding === 'function') callback = encoding;
+    this.sink(typeof chunk === 'string' || chunk instanceof Uint8Array ? chunk : String(chunk));
+    if (typeof callback === 'function') queueMicrotask(callback);
+    return true;
+  }
+
+  getColorDepth(): number {
+    return this.isTTY ? 8 : 1;
+  }
+  hasColors(count = 16): boolean {
+    return this.isTTY && count <= 256;
+  }
+  getWindowSize(): [number, number] {
+    return [this.columns ?? 80, this.rows ?? 24];
+  }
+  cursorTo(x: number, y?: number | (() => void), cb?: () => void): boolean {
+    this.write(typeof y === 'number' ? `\x1b[${y + 1};${x + 1}H` : `\x1b[${x + 1}G`);
+    (typeof y === 'function' ? y : cb)?.();
+    return true;
+  }
+  moveCursor(dx: number, dy: number, cb?: () => void): boolean {
+    this.write((dx < 0 ? `\x1b[${-dx}D` : dx > 0 ? `\x1b[${dx}C` : '') + (dy < 0 ? `\x1b[${-dy}A` : dy > 0 ? `\x1b[${dy}B` : ''));
+    cb?.();
+    return true;
+  }
+  clearLine(dir = 0, cb?: () => void): boolean {
+    this.write(dir < 0 ? '\x1b[1K' : dir > 0 ? '\x1b[0K' : '\x1b[2K');
+    cb?.();
+    return true;
+  }
+  clearScreenDown(cb?: () => void): boolean {
+    this.write('\x1b[0J');
+    cb?.();
+    return true;
+  }
+}
+
+class StdinStream extends Readable {
+  isTTY: boolean;
+  isRaw = false;
+  fd = 0;
+  private subscription?: () => void;
+  private release?: () => void;
+
+  constructor(private readonly io: ProgramIO, private readonly loop: EventLoop) {
+    super({ encoding: 'utf8' });
+    this.isTTY = !!io.terminal;
+  }
+
+  override _read(): void {
+    this.listen();
+  }
+
+  override resume(): this {
+    this.listen();
+    return super.resume();
+  }
+
+  override pause(): this {
+    this.stopListening();
+    return super.pause();
+  }
+
+  setRawMode(raw: boolean): this {
+    this.isRaw = raw;
+    this.io.terminal?.setRawMode(raw);
+    return this;
+  }
+
+  ref(): this {
+    if (this.subscription && !this.release) this.release = this.loop.hold();
+    return this;
+  }
+
+  unref(): this {
+    this.release?.();
+    this.release = undefined;
+    return this;
+  }
+
+  private listen(): void {
+    if (this.subscription) return;
+    this.release = this.loop.hold();
+    this.subscription = this.io.onStdin((chunk) => {
+      if (chunk === null) {
+        this.stopListening();
+        this.push(null);
+      } else this.push(chunk);
+    });
+  }
+
+  private stopListening(): void {
+    this.subscription?.();
+    this.subscription = undefined;
+    this.release?.();
+    this.release = undefined;
+  }
+}
+
+export type NodeProcess = EventEmitterBase & Record<string, any>;
+
+export function createProcess(options: ProcessOptions): NodeProcess {
+  const { io, loop, fs } = options;
+  let cwd = normalizePath(options.cwd);
+  let exited = false;
+  const started = performance.now();
+  const proc = new EventEmitterBase() as NodeProcess;
+  const pid = nextPid++;
+
+  const exit = (code?: number) => {
+    if (code !== undefined) proc.exitCode = code;
+    if (!exited) {
+      exited = true;
+      const final = Number(proc.exitCode ?? 0) || 0;
+      try {
+        proc.emit('exit', final);
+      } catch {
+        // an 'exit' listener that throws must not stop the exit
+      }
+      options.onExit(Number(proc.exitCode ?? final) || 0);
+    }
+    throw new ProcessExit(Number(proc.exitCode ?? 0) || 0);
+  };
+
+  const hrtime = (previous?: [number, number]): [number, number] => {
+    const now = performance.now();
+    let seconds = Math.floor(now / 1000);
+    let nanos = Math.floor((now % 1000) * 1e6);
+    if (previous) {
+      seconds -= previous[0];
+      nanos -= previous[1];
+      if (nanos < 0) {
+        seconds--;
+        nanos += 1e9;
+      }
+    }
+    return [seconds, nanos];
+  };
+  hrtime.bigint = () => BigInt(Math.floor(performance.now() * 1e6));
+
+  const memoryUsage = () => ({ rss: 50e6, heapTotal: 30e6, heapUsed: 20e6, external: 1e6, arrayBuffers: 1e5 });
+  memoryUsage.rss = () => 50e6;
+
+  Object.assign(proc, {
+    title: 'node',
+    version: `v${NODE_VERSION}`,
+    versions: { node: NODE_VERSION, v8: '11.3.244.8-node.23', uv: '1.48.0', zlib: '1.3.0.1', modules: '115', napi: '9', unicode: '15.1' },
+    release: { name: 'node', lts: 'Iron' },
+    platform: 'linux',
+    arch: 'x64',
+    pid,
+    ppid: pid - 1,
+    argv: options.argv,
+    argv0: 'node',
+    execPath: '/usr/local/bin/node',
+    execArgv: [],
+    env: options.env,
+    exitCode: undefined as number | undefined,
+    config: { variables: {} },
+    features: { inspector: false, ipv6: true, tls: true, typescript: false },
+    allowedNodeEnvironmentFlags: new Set<string>(),
+    stdout: new TtyWriteStream(1, io.stdout, io.terminal),
+    stderr: new TtyWriteStream(2, io.stderr, io.terminal),
+    stdin: new StdinStream(io, loop),
+    cwd: () => cwd,
+    chdir(dir: string) {
+      const target = dir.startsWith('/') ? normalizePath(dir) : join(cwd, dir);
+      if (!fs.isDirectory(target)) throw fsError(fs.isFile(target) ? 'ENOTDIR' : 'ENOENT', 'chdir', target);
+      cwd = target;
+    },
+    exit,
+    reallyExit: exit,
+    abort: () => exit(134),
+    kill(target: number, signal: string | number = 'SIGTERM') {
+      if (target !== pid) throw Object.assign(new Error('kill ESRCH'), { code: 'ESRCH' });
+      if (proc.listenerCount(String(signal))) proc.emit(String(signal), String(signal));
+      else exit(143);
+      return true;
+    },
+    nextTick(fn: (...args: unknown[]) => void, ...args: unknown[]) {
+      queueMicrotask(() => loop._run(() => fn(...args)));
+    },
+    hrtime,
+    memoryUsage,
+    cpuUsage: () => ({ user: Math.floor((performance.now() - started) * 1000), system: 0 }),
+    resourceUsage: () => ({ userCPUTime: 0, systemCPUTime: 0, maxRSS: 50000 }),
+    uptime: () => (performance.now() - started) / 1000,
+    umask: () => 0o22,
+    getuid: () => 1000,
+    geteuid: () => 1000,
+    getgid: () => 1000,
+    getegid: () => 1000,
+    getgroups: () => [1000],
+    emitWarning(warning: string | Error, type?: string | { type?: string }) {
+      const name = typeof type === 'string' ? type : type?.type ?? (warning instanceof Error ? warning.name : 'Warning');
+      const message = warning instanceof Error ? warning.message : warning;
+      proc.emit('warning', Object.assign(new Error(message), { name }));
+      io.stderr(`(node:${pid}) ${name}: ${message}\n`);
+    },
+    binding(name: string) {
+      throw new Error(`No such module: ${name}`);
+    },
+    getActiveResourcesInfo: () => [],
+    setUncaughtExceptionCaptureCallback: () => undefined,
+    hasUncaughtExceptionCaptureCallback: () => false,
+    setSourceMapsEnabled: () => undefined,
+    report: { getReport: () => ({ header: { glibcVersionRuntime: '2.36' } }) },
+    connected: false,
+  });
+  return proc;
+}
+
+/** console bound to a process's stdio (`console.log` in user code prints to the terminal). */
+export function createConsole(proc: NodeProcess): Console {
+  const out = (stream: 'stdout' | 'stderr') => (...args: unknown[]) => proc[stream].write(format(...args) + '\n');
+  const counts = new Map<string, number>();
+  const timers = new Map<string, number>();
+  let indent = '';
+  const withIndent = (fn: (...args: unknown[]) => void) => (...args: unknown[]) => (indent ? fn(indent + format(...args).replace(/\n/g, '\n' + indent)) : fn(...args));
+  const log = withIndent(out('stdout'));
+  const error = withIndent(out('stderr'));
+  return {
+    log,
+    info: log,
+    debug: log,
+    warn: error,
+    error,
+    trace: (...args: unknown[]) => error(`Trace: ${format(...args)}\n${new Error().stack?.split('\n').slice(2).join('\n') ?? ''}`),
+    dir: (value: unknown) => log(value),
+    dirxml: log,
+    table: (value: unknown) => log(value),
+    assert: (condition: unknown, ...args: unknown[]) => {
+      if (!condition) error('Assertion failed' + (args.length ? `: ${format(...args)}` : ''));
+    },
+    count: (label = 'default') => {
+      counts.set(label, (counts.get(label) ?? 0) + 1);
+      log(`${label}: ${counts.get(label)}`);
+    },
+    countReset: (label = 'default') => void counts.delete(label),
+    group: (...args: unknown[]) => {
+      if (args.length) log(...args);
+      indent += '  ';
+    },
+    groupCollapsed: (...args: unknown[]) => {
+      if (args.length) log(...args);
+      indent += '  ';
+    },
+    groupEnd: () => void (indent = indent.slice(2)),
+    time: (label = 'default') => void timers.set(label, performance.now()),
+    timeLog: (label = 'default', ...args: unknown[]) => log(`${label}: ${(performance.now() - (timers.get(label) ?? 0)).toFixed(3)}ms`, ...args),
+    timeEnd: (label = 'default') => {
+      log(`${label}: ${(performance.now() - (timers.get(label) ?? 0)).toFixed(3)}ms`);
+      timers.delete(label);
+    },
+    clear: () => undefined,
+    profile: () => undefined,
+    profileEnd: () => undefined,
+    timeStamp: () => undefined,
+  } as unknown as Console;
+}

package/src/node/program.ts

@@ -0,0 +1,170 @@
+/**
+ * The `node` command: CLI flags, the entry script (or `-e`/`-p`, or stdin), and
+ * a small REPL when attached to a terminal with nothing to run.
+ */
+import type { Program, ProgramContext } from '../system/types.js';
+import { join } from '../paths.js';
+import { readBinLink } from '../installer/bins.js';
+import { startNode, type NodeInstance } from './runtime.js';
+import { NODE_VERSION } from './process.js';
+import { inspect } from './inspect.js';
+import { parseDotenv } from '../projectConfig.js';
+
+interface NodeCli {
+  entry?: string;
+  args: string[];
+  evaluate?: string;
+  print?: boolean;
+  preload: string[];
+  envFiles: string[];
+  version?: boolean;
+  help?: boolean;
+}
+
+/** Flags that take the next argument as their value. */
+const WITH_VALUE = new Set(['-r', '--require', '--import', '--loader', '--experimental-loader', '-C', '--conditions', '--input-type', '--title', '--env-file', '--stack-size']);
+
+export function parseNodeArgs(argv: string[]): NodeCli {
+  const cli: NodeCli = { args: [], preload: [], envFiles: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (arg === '--') {
+      [cli.entry, ...cli.args] = argv.slice(i + 1);
+      break;
+    }
+    if (!arg.startsWith('-') || arg === '-') {
+      cli.entry = arg;
+      cli.args = argv.slice(i + 1);
+      break;
+    }
+    const [flag, inline] = arg.includes('=') ? [arg.slice(0, arg.indexOf('=')), arg.slice(arg.indexOf('=') + 1)] : [arg, undefined];
+    const value = () => inline ?? argv[++i] ?? '';
+    if (flag === '-v' || flag === '--version') cli.version = true;
+    else if (flag === '-h' || flag === '--help') cli.help = true;
+    else if (flag === '-e' || flag === '--eval') cli.evaluate = value();
+    else if (flag === '-p' || flag === '--print') {
+      cli.evaluate = value();
+      cli.print = true;
+    } else if (flag === '-r' || flag === '--require' || flag === '--import') cli.preload.push(value());
+    else if (flag === '--env-file') cli.envFiles.push(value());
+    else if (WITH_VALUE.has(flag) && inline === undefined) i++;
+    // everything else (--inspect, --no-warnings, --max-old-space-size=…) is accepted and ignored
+  }
+  if (cli.evaluate !== undefined && cli.entry !== undefined) {
+    cli.args = [cli.entry, ...cli.args];
+    cli.entry = undefined;
+  }
+  return cli;
+}
+
+const HELP = `Usage: node [options] [ script.js ] [arguments]
+       node -e "script"    evaluate script
+       node -p "expr"      evaluate and print
+Options: -v, -r <module>, --env-file=<file>. Running in BuilderForce WebContainers.
+`;
+
+async function readAllStdin(ctx: ProgramContext): Promise<string> {
+  let text = '';
+  await new Promise<void>((resolve) => {
+    const stop = ctx.io.onStdin((chunk) => {
+      if (chunk === null) {
+        stop();
+        resolve();
+      } else text += chunk;
+    });
+  });
+  return text;
+}
+
+/** Evaluate REPL lines in one persistent sloppy-mode scope (`const`/`let` become `var` so they survive the line). */
+function startRepl(instance: NodeInstance, ctx: ProgramContext): void {
+  const { io } = ctx;
+  const scope = evalInProcess(instance, ctx.cwd, '[repl]', `(function* () { let __r; while (true) { const __line = yield __r; try { __r = { value: eval(__line) }; } catch (e) { __r = { error: e }; } } })()`) as Generator<{ value?: unknown; error?: unknown } | undefined, never, string>;
+  scope.next();
+  const release = instance.hold();
+  io.stdout(`Welcome to Node.js v${NODE_VERSION}.\nType ".exit" to leave.\n> `);
+  const leave = () => {
+    stop();
+    release();
+    instance.run(() => instance.process.exit(0));
+  };
+  const stop = io.onStdin((chunk) => {
+    if (chunk === null) return leave();
+    for (const raw of chunk.split(/\r?\n/)) {
+      const line = raw.trim();
+      if (!line) continue;
+      if (line === '.exit') return leave();
+      const result = scope.next(line.replace(/^(const|let)\s/, 'var ')).value!;
+      if ('error' in result) io.stdout(`Uncaught ${result.error instanceof Error ? result.error.stack ?? result.error.message : inspect(result.error)}\n`);
+      else io.stdout(inspect(result.value, { colors: false }) + '\n');
+    }
+    io.stdout('> ');
+  });
+}
+
+/** Evaluate `expression` inside the CommonJS wrapper, so it sees require, process, timers… of this process. */
+function evalInProcess(instance: NodeInstance, cwd: string, name: string, expression: string): unknown {
+  const filename = join(cwd, name);
+  const module = new instance.modules.Module(filename);
+  return module._compile(`return eval(${JSON.stringify(expression)});`, filename);
+}
+
+export const nodeProgram: Program = async (ctx) => {
+  const cli = parseNodeArgs(ctx.args);
+  if (cli.version) {
+    ctx.io.stdout(`v${NODE_VERSION}\n`);
+    return 0;
+  }
+  if (cli.help) {
+    ctx.io.stdout(HELP);
+    return 0;
+  }
+  const env = { ...ctx.env };
+  for (const file of cli.envFiles) {
+    const text = ctx.system.fs.readText(join(ctx.cwd, file));
+    if (text === undefined) {
+      ctx.io.stderr(`node: ${file}: not found\n`);
+      return 9;
+    }
+    Object.assign(env, parseDotenv(text));
+  }
+
+  let entry: string | undefined;
+  if (cli.entry !== undefined && cli.entry !== '-') {
+    entry = cli.entry.startsWith('/') ? cli.entry : join(ctx.cwd, cli.entry);
+    entry = readBinLink(ctx.system.fs, entry) ?? entry;
+  }
+  const source = cli.evaluate ?? (cli.entry === '-' || (!entry && !ctx.io.terminal) ? await readAllStdin(ctx) : undefined);
+  const scriptPath = entry ?? (source !== undefined ? '[eval]' : undefined);
+  const instance = await startNode({ system: ctx.system, io: ctx.io, cwd: ctx.cwd, env, installGlobals: ctx.system.ownsRealm, argv: scriptPath && scriptPath !== '[eval]' ? [scriptPath, ...cli.args] : cli.args });
+  const onAbort = () => instance.kill(typeof ctx.signal.reason === 'string' ? ctx.signal.reason : 'SIGTERM');
+  if (ctx.signal.aborted) onAbort();
+  ctx.signal.addEventListener('abort', onAbort);
+  const untrap = ctx.system.trapUncaught?.((error) => instance.reportUncaught(error));
+
+  instance.run(() => {
+    const require = instance.modules.createRequire(join(ctx.cwd, '[eval]'));
+    for (const id of cli.preload) require(id.startsWith('.') ? join(ctx.cwd, id) : id);
+    if (entry) {
+      let resolved: string;
+      try {
+        resolved = instance.modules.Module._resolveFilename(entry, undefined);
+      } catch (error) {
+        if ((error as { code?: string }).code === 'MODULE_NOT_FOUND') throw Object.assign(new Error(`Cannot find module '${entry}'`), { code: 'MODULE_NOT_FOUND', requireStack: [] });
+        throw error;
+      }
+      return instance.modules.runMain(resolved).__tla;
+    }
+    if (source !== undefined) {
+      const result = evalInProcess(instance, ctx.cwd, '[eval]', source);
+      if (cli.print) instance.process.stdout.write(inspect(result) + '\n');
+      return undefined;
+    }
+    startRepl(instance, ctx);
+    return undefined;
+  });
+  const code = await instance.exit;
+  ctx.signal.removeEventListener('abort', onAbort);
+  untrap?.();
+  return code;
+};

package/src/node/readline.ts

@@ -0,0 +1,157 @@
+/**
+ * `readline` and `readline/promises`: line splitting over any input stream,
+ * `question`, prompts and async iteration — what interactive CLIs (create-*,
+ * inquirer's simple paths, REPL-ish scripts) use. Input arrives already
+ * line-edited by the terminal's line discipline, so no keypress decoding is
+ * needed beyond `emitKeypressEvents` delivering characters.
+ */
+import { EventEmitterBase } from './events.js';
+
+interface Input extends EventEmitterBase {
+  resume?(): unknown;
+  pause?(): unknown;
+  setEncoding?(e: string): unknown;
+}
+interface Output {
+  write(chunk: string): unknown;
+}
+
+class Interface extends EventEmitterBase {
+  line = '';
+  cursor = 0;
+  terminal: boolean;
+  closed = false;
+  private buffer = '';
+  private promptText = '> ';
+  private pendingQuestion?: (answer: string) => void;
+  private readonly onData = (chunk: unknown) => this.feed(String(chunk));
+  private readonly onEnd = () => {
+    if (this.buffer) this.emitLine(this.buffer);
+    this.buffer = '';
+    this.close();
+  };
+
+  constructor(readonly input: Input, readonly output?: Output, options: { prompt?: string; terminal?: boolean } = {}) {
+    super();
+    this.terminal = options.terminal ?? !!(output as { isTTY?: boolean } | undefined)?.isTTY;
+    if (options.prompt !== undefined) this.promptText = options.prompt;
+    input.setEncoding?.('utf8');
+    input.on('data', this.onData);
+    input.on('end', this.onEnd);
+    input.resume?.();
+  }
+
+  setPrompt(prompt: string): void {
+    this.promptText = prompt;
+  }
+  getPrompt(): string {
+    return this.promptText;
+  }
+  prompt(): void {
+    this.output?.write(this.promptText);
+  }
+  question(query: string, options: unknown, callback?: (answer: string) => void): void {
+    const cb = (typeof options === 'function' ? options : callback) as (answer: string) => void;
+    this.output?.write(query);
+    this.pendingQuestion = cb;
+  }
+  write(data: string): void {
+    this.feed(data);
+  }
+  pause(): this {
+    this.input.pause?.();
+    this.emit('pause');
+    return this;
+  }
+  resume(): this {
+    this.input.resume?.();
+    this.emit('resume');
+    return this;
+  }
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    this.input.removeListener('data', this.onData);
+    this.input.removeListener('end', this.onEnd);
+    this.input.pause?.();
+    this.emit('close');
+  }
+  getCursorPos(): { rows: number; cols: number } {
+    return { rows: 0, cols: this.cursor };
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<string> {
+    const queue: string[] = [];
+    let wake: (() => void) | undefined;
+    this.on('line', (line: string) => {
+      queue.push(line);
+      wake?.();
+    });
+    this.on('close', () => wake?.());
+    while (true) {
+      if (queue.length) yield queue.shift()!;
+      else if (this.closed) return;
+      else await new Promise<void>((resolve) => (wake = resolve));
+    }
+  }
+
+  private feed(text: string): void {
+    this.buffer += text;
+    for (;;) {
+      const nl = this.buffer.search(/\r\n|\n|\r/);
+      if (nl < 0) break;
+      const line = this.buffer.slice(0, nl);
+      this.buffer = this.buffer.slice(this.buffer[nl] === '\r' && this.buffer[nl + 1] === '\n' ? nl + 2 : nl + 1);
+      this.emitLine(line);
+    }
+    this.line = this.buffer;
+    this.cursor = this.buffer.length;
+  }
+
+  private emitLine(line: string): void {
+    const question = this.pendingQuestion;
+    if (question) {
+      this.pendingQuestion = undefined;
+      question(line);
+    } else this.emit('line', line);
+  }
+}
+
+const ansi = (stream: Output | undefined, sequence: string, cb?: () => void) => {
+  stream?.write(sequence);
+  cb?.();
+  return true;
+};
+
+export function createReadlineModule(promises = false): Record<string, unknown> {
+  const createInterface = (input: Input | { input: Input; output?: Output; prompt?: string; terminal?: boolean }, output?: Output) => {
+    const opts = 'input' in input && (input as { input?: unknown }).input ? (input as { input: Input; output?: Output; prompt?: string; terminal?: boolean }) : { input: input as Input, output };
+    const rl = new Interface(opts.input, opts.output, opts);
+    if (promises) {
+      const ask = rl.question.bind(rl);
+      (rl as unknown as { question: (q: string) => Promise<string> }).question = (query: string) => new Promise((resolve) => ask(query, undefined, resolve));
+    }
+    return rl;
+  };
+  const mod: Record<string, unknown> = {
+    createInterface,
+    Interface,
+    clearLine: (stream: Output, dir: number, cb?: () => void) => ansi(stream, dir < 0 ? '\x1b[1K' : dir > 0 ? '\x1b[0K' : '\x1b[2K', cb),
+    clearScreenDown: (stream: Output, cb?: () => void) => ansi(stream, '\x1b[0J', cb),
+    cursorTo: (stream: Output, x: number, y?: number | (() => void), cb?: () => void) => ansi(stream, typeof y === 'number' ? `\x1b[${y + 1};${x + 1}H` : `\x1b[${x + 1}G`, typeof y === 'function' ? y : cb),
+    moveCursor: (stream: Output, dx: number, dy: number, cb?: () => void) =>
+      ansi(stream, (dx < 0 ? `\x1b[${-dx}D` : dx > 0 ? `\x1b[${dx}C` : '') + (dy < 0 ? `\x1b[${-dy}A` : dy > 0 ? `\x1b[${dy}B` : ''), cb),
+    emitKeypressEvents(stream: EventEmitterBase) {
+      if ((stream as { __keypress?: boolean }).__keypress) return;
+      (stream as { __keypress?: boolean }).__keypress = true;
+      stream.on('data', (chunk: unknown) => {
+        for (const ch of String(chunk)) {
+          const name = ch === '\r' || ch === '\n' ? 'return' : ch === '\x7f' ? 'backspace' : ch === '\x03' ? 'c' : /[a-z]/i.test(ch) ? ch.toLowerCase() : undefined;
+          stream.emit('keypress', ch, { sequence: ch, name, ctrl: ch === '\x03', meta: false, shift: /[A-Z]/.test(ch) });
+        }
+      });
+    },
+  };
+  if (!promises) mod.promises = createReadlineModule(true);
+  return mod;
+}