visaljs 0.0.6 → 0.0.8

package/node/prelude/stream_consumers.js

@@ -0,0 +1,34 @@
+// node:stream/consumers: a stream read to its end as text, JSON, bytes or a Blob, as Node's: any
+// async iterable of chunks (a Readable, a web ReadableStream, an async generator).
+
+/** The chunks as a Blob. */
+export async function blob(stream) {
+  const chunks = [];
+  for await (const chunk of stream) chunks.push(chunk);
+  return new globalThis.Blob(chunks);
+}
+
+export async function arrayBuffer(stream) {
+  return (await blob(stream)).arrayBuffer();
+}
+
+export async function buffer(stream) {
+  return Buffer.from(await arrayBuffer(stream));
+}
+
+/** The chunks as UTF-8 text: strings as they are, bytes decoded across chunk boundaries. */
+export async function text(stream) {
+  const decoder = new TextDecoder();
+  let string = "";
+  for await (const chunk of stream) {
+    if (typeof chunk === "string") string += chunk;
+    else string += decoder.decode(chunk, { stream: true });
+  }
+  return string + decoder.decode(undefined, { stream: false });
+}
+
+export async function json(stream) {
+  return JSON.parse(await text(stream));
+}
+
+export default { arrayBuffer, blob, buffer, json, text };

package/node/prelude/stream_promises.js

@@ -1,4 +1,4 @@
-// node:stream/promises (ADR 0012, layer 3): pipeline and finished, as promises.
+// node:stream/promises: pipeline and finished as promises (lib/stream/promises.js).
 import { promises } from "./stream.js";
 
 export const pipeline = promises.pipeline;

package/node/prelude/stream_web.js

@@ -1,6 +1,19 @@
-// node:stream/web (ADR 0012, layer 3): the web streams the runtime provides as globals.
+// node:stream/web: the web streams the runtime provides as globals, and the compression streams
+// (internal/compression_streams.js, linked into programs that name them).
+import { lazyClass } from "./internal/features.js";
+
 export const ReadableStream = globalThis.ReadableStream;
 export const ReadableStreamDefaultReader = globalThis.ReadableStreamDefaultReader;
 export const ReadableStreamDefaultController = globalThis.ReadableStreamDefaultController;
+export const WritableStream = globalThis.WritableStream;
+export const WritableStreamDefaultWriter = globalThis.WritableStreamDefaultWriter;
+export const WritableStreamDefaultController = globalThis.WritableStreamDefaultController;
+export const TransformStream = globalThis.TransformStream;
+export const TransformStreamDefaultController = globalThis.TransformStreamDefaultController;
+export const CompressionStream = lazyClass("CompressionStream");
+export const DecompressionStream = lazyClass("DecompressionStream");
 
-export default { ReadableStream, ReadableStreamDefaultReader, ReadableStreamDefaultController };
+export default {
+  ReadableStream, ReadableStreamDefaultReader, ReadableStreamDefaultController, WritableStream, WritableStreamDefaultWriter,
+  WritableStreamDefaultController, TransformStream, TransformStreamDefaultController, CompressionStream, DecompressionStream,
+};

package/node/prelude/string_decoder.js

@@ -1,4 +1,4 @@
-// node:string_decoder (ADR 0012, layer 3): StringDecoder, which decodes Buffers to strings without
+// node:string_decoder: StringDecoder, which decodes Buffers to strings without
 // splitting a character (UTF-8, UTF-16LE) or a base64 group across writes. Node's algorithm (its
 // JavaScript one, before it moved to C++); the other encodings decode chunk by chunk.
 import { codeError } from "./internal/errors.js";

package/node/prelude/sys.js

@@ -0,0 +1,7 @@
+// node:sys: node:util under its old name, deprecated (DEP0025): the same object.
+import util from "./util.js";
+
+process.emitWarning("sys is deprecated. Use util instead.", "DeprecationWarning", "DEP0025");
+
+export * from "./util.js";
+export default util;

package/node/prelude/test.js

@@ -0,0 +1,56 @@
+// node:test: Node's test runner in a compiled program (lib/test.js; the runner
+// is internal/test_runner/). test / it, describe / suite, the hooks, test contexts (subtests,
+// plan, skip, todo, diagnostic, t.mock, t.assert, waitFor), mocks, and the tap and spec
+// reporters. Not here: run() (a process per test file), snapshots, mock.timers and mock.module.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { notSupported } from "./internal/errors.js";
+import { MockTracker } from "./internal/test_runner/mock.js";
+import { hook, registerAssertion, run, runInParentContext, Suite, Test } from "./internal/test_runner/test.js";
+
+const test = runInParentContext(Test);
+const suite = runInParentContext(Suite);
+const before = hook("before");
+const after = hook("after");
+const beforeEach = hook("beforeEach");
+const afterEach = hook("afterEach");
+
+let lazyMock;
+const testAssert = { __proto__: null, register: registerAssertion };
+
+Object.assign(test, {
+  after,
+  afterEach,
+  before,
+  beforeEach,
+  describe: suite,
+  it: test,
+  run,
+  suite,
+  test,
+});
+
+Object.defineProperty(test, "mock", {
+  configurable: true,
+  enumerable: true,
+  get() {
+    lazyMock ??= new MockTracker();
+    return lazyMock;
+  },
+});
+
+const snapshot = {
+  __proto__: null,
+  setDefaultSnapshotSerializers() {
+    throw notSupported("node:test's snapshots");
+  },
+  setResolveSnapshotPath() {
+    throw notSupported("node:test's snapshots");
+  },
+};
+Object.defineProperty(test, "snapshot", { configurable: true, enumerable: true, value: snapshot });
+
+Object.defineProperty(test, "assert", { configurable: true, enumerable: true, value: testAssert });
+
+export default test;
+export { after, afterEach, before, beforeEach, suite as describe, test as it, run, snapshot, suite, test, testAssert as assert };
+export const mock = test.mock;

package/node/prelude/test_reporters.js

@@ -0,0 +1,269 @@
+// node:test/reporters (Node's lib/test/reporters.js and lib/internal/test_runner/reporter/; MIT;
+// Node v24.21.0): the reporters a program composes with a stream of test events. tap, dot and junit
+// are async generators over the events; spec and lcov are Transforms from events to text. tap and
+// spec are the runner's own (internal/test_runner/reporters.js); lcov writes the coverage events,
+// which a compiled program doesn't produce.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { hostname } from "./os.js";
+import { relative } from "./path.js";
+import Transform from "./internal/streams/transform.js";
+import { SpecReporter, TapReporter, colorsFor, inspectWithNoCustomRetry } from "./internal/test_runner/reporters.js";
+
+/* ---- tap, spec ----------------------------------------------------------------------------------- */
+
+export async function* tap(source) {
+  const reporter = new TapReporter();
+  yield reporter.start();
+  for await (const event of source) {
+    const text = reporter.handle(event);
+    if (text) yield text;
+  }
+  const tail = reporter.flush();
+  if (tail) yield tail;
+}
+Object.defineProperty(tap, "name", { value: "tapReporter" });
+
+class SpecTransform extends Transform {
+  #reporter = new SpecReporter();
+
+  constructor() {
+    super({ writableObjectMode: true });
+  }
+
+  _transform({ type, data }, _encoding, callback) {
+    callback(null, this.#reporter.handle({ type, data }) || undefined);
+  }
+
+  _flush(callback) {
+    callback(null, this.#reporter.flush());
+  }
+}
+
+/** Node's: a function that makes a spec Transform, with or without new. */
+export const spec = function spec() {
+  return new SpecTransform();
+};
+
+/* ---- dot (reporter/dot.js) ----------------------------------------------------------------------- */
+
+export async function* dot(source) {
+  const colors = colorsFor(process.stderr);
+  const lineLength = () => Math.max(process.stdout.columns ?? 20, 20);
+  let count = 0;
+  let columns = lineLength();
+  const failedTests = [];
+  for await (const { type, data } of source) {
+    if (type === "test:pass") {
+      yield `${colors.green}.${colors.reset}`;
+    }
+    if (type === "test:fail") {
+      yield `${colors.red}X${colors.reset}`;
+      failedTests.push(data);
+    }
+    if ((type === "test:fail" || type === "test:pass") && ++count === columns) {
+      yield "\n";
+      columns = lineLength();  /* again, in case the terminal was resized */
+      count = 0;
+    }
+  }
+  yield "\n";
+  if (failedTests.length > 0) {
+    yield `\n${colors.red}Failed tests:${colors.white}\n\n`;
+    const format = new SpecReporter();
+    for (const test of failedTests) {
+      yield format.formatTestReport("test:fail", test);
+    }
+  }
+}
+
+/* ---- junit (reporter/junit.js) ------------------------------------------------------------------- */
+
+const junitInspectOptions = { __proto__: null, colors: false, breakLength: Infinity };
+
+/* Node 24's: a newline as 
, and an & that begins a numeric character reference kept */
+function escapeAttribute(s = "") {
+  return escapeContent(s.replaceAll("\n", "
").replaceAll('"', """));
+}
+
+function escapeContent(s = "") {
+  return s.replace(/(&)(?!#\d{1,7};)/g, "&amp;").replaceAll("<", "&lt;");
+}
+
+function escapeComment(s = "") {
+  return s.replaceAll("--", "&#45;&#45;");
+}
+
+function treeToXML(tree) {
+  if (typeof tree === "string") {
+    return `${escapeContent(tree)}\n`;
+  }
+  const { tag, attrs, nesting, children, comment } = tree;
+  const indent = "\t".repeat(nesting + 1);
+  if (comment != null) {
+    return `${indent}<!-- ${escapeComment(comment)} -->\n`;
+  }
+  const attrsString = Object.entries(attrs).map(([key, value]) => `${key}="${escapeAttribute(String(value))}"`).join(" ");
+  if (!children?.length) {
+    return `${indent}<${tag} ${attrsString}/>\n`;
+  }
+  const childrenString = (children ?? []).map(treeToXML).join("");
+  return `${indent}<${tag} ${attrsString}>\n${childrenString}${indent}</${tag}>\n`;
+}
+
+function isFailure(node) {
+  return (node?.children && node.children.some((c) => c.tag === "failure")) || node?.attrs?.failures;
+}
+
+function isSkipped(node) {
+  return (node?.children && node.children.some((c) => c.tag === "skipped")) || node?.attrs?.skipped;
+}
+
+export async function* junit(source) {
+  const HOSTNAME = hostname();
+  yield '<?xml version="1.0" encoding="utf-8"?>\n';
+  yield "<testsuites>\n";
+  let currentSuite = null;
+  const roots = [];
+
+  function startTest(event) {
+    const originalSuite = currentSuite;
+    currentSuite = { __proto__: null, attrs: { __proto__: null, name: event.data.name }, nesting: event.data.nesting, parent: currentSuite, children: [] };
+    if (originalSuite?.children) {
+      originalSuite.children.push(currentSuite);
+    }
+    if (!currentSuite.parent) {
+      roots.push(currentSuite);
+    }
+  }
+
+  for await (const event of source) {
+    switch (event.type) {
+      case "test:start": {
+        startTest(event);
+        break;
+      }
+      case "test:pass":
+      case "test:fail": {
+        if (!currentSuite) {
+          startTest({ __proto__: null, data: { __proto__: null, name: "root", nesting: 0 } });
+        }
+        if (currentSuite.attrs.name !== event.data.name || currentSuite.nesting !== event.data.nesting) {
+          startTest(event);
+        }
+        const currentTest = currentSuite;
+        if (currentSuite?.nesting === event.data.nesting) {
+          currentSuite = currentSuite.parent;
+        }
+        currentTest.attrs.time = (event.data.details.duration_ms / 1000).toFixed(6);
+        const nonCommentChildren = currentTest.children.filter((c) => c.comment == null);
+        if (nonCommentChildren.length > 0) {
+          currentTest.tag = "testsuite";
+          currentTest.attrs.disabled = 0;
+          currentTest.attrs.errors = 0;
+          currentTest.attrs.tests = nonCommentChildren.length;
+          currentTest.attrs.failures = currentTest.children.filter(isFailure).length;
+          currentTest.attrs.skipped = currentTest.children.filter(isSkipped).length;
+          /* when it started: its end less its duration (its test:start comes late, with its first test) */
+          currentTest.attrs.timestamp = new Date(Date.now() - event.data.details.duration_ms).toISOString();
+          currentTest.attrs.hostname = HOSTNAME;
+        } else {
+          currentTest.tag = "testcase";
+          currentTest.attrs.classname = event.data.classname ?? "test";
+          if (event.data.file) {
+            currentTest.attrs.file = event.data.file;
+          }
+          if (event.data.skip) {
+            currentTest.children.push({
+              __proto__: null, nesting: event.data.nesting + 1, tag: "skipped", attrs: { __proto__: null, type: "skipped", message: event.data.skip },
+            });
+          }
+          if (event.data.todo) {
+            currentTest.children.push({
+              __proto__: null, nesting: event.data.nesting + 1, tag: "skipped", attrs: { __proto__: null, type: "todo", message: event.data.todo },
+            });
+          }
+          if (event.type === "test:fail") {
+            const error = event.data.details?.error;
+            currentTest.children.push({
+              __proto__: null,
+              nesting: event.data.nesting + 1,
+              tag: "failure",
+              attrs: { __proto__: null, type: error?.failureType || error?.code, message: error?.message.trim() ?? "" },
+              children: [inspectWithNoCustomRetry(error, junitInspectOptions)],
+            });
+            currentTest.failures = 1;
+            currentTest.attrs.failure = error?.message ?? "";
+          }
+        }
+        break;
+      }
+      case "test:diagnostic":
+      case "test:log": {
+        const parent = currentSuite?.children ?? roots;
+        parent.push({ __proto__: null, nesting: event.data.nesting, comment: event.data.message });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  for (const suite of roots) {
+    yield treeToXML(suite);
+  }
+  yield "</testsuites>\n";
+}
+Object.defineProperty(junit, "name", { value: "junitReporter" });
+
+/* ---- lcov (reporter/lcov.js) --------------------------------------------------------------------- */
+
+/** The coverage events as an LCOV tracefile. */
+class LcovReporter extends Transform {
+  constructor(options) {
+    super({ ...options, writableObjectMode: true, __proto__: null });
+  }
+
+  _transform(event, _encoding, callback) {
+    if (event.type !== "test:coverage") {
+      return callback(null);
+    }
+    let lcov = "TN:\n";
+    const { workingDirectory } = event.data.summary;
+    try {
+      for (const file of event.data.summary.files) {
+        lcov += `SF:${relative(workingDirectory, file.path)}\n`;
+        let fnda = "";
+        for (let j = 0; j < file.functions.length; j++) {
+          const func = file.functions[j];
+          const name = func.name || `anonymous_${j}`;
+          lcov += `FN:${func.line},${name}\n`;
+          fnda += `FNDA:${func.count},${name}\n`;
+        }
+        lcov += fnda;
+        lcov += `FNF:${file.totalFunctionCount}\n`;
+        lcov += `FNH:${file.coveredFunctionCount}\n`;
+        for (let j = 0; j < file.branches.length; j++) {
+          lcov += `BRDA:${file.branches[j].line},${j},0,${file.branches[j].count}\n`;
+        }
+        lcov += `BRF:${file.totalBranchCount}\n`;
+        lcov += `BRH:${file.coveredBranchCount}\n`;
+        for (const line of file.lines.toSorted((a, b) => a.line - b.line)) {
+          lcov += `DA:${line.line},${line.count}\n`;
+        }
+        lcov += `LH:${file.coveredLineCount}\n`;
+        lcov += `LF:${file.totalLineCount}\n`;
+        lcov += "end_of_record\n";
+      }
+    } catch (error) {
+      return callback(error);
+    }
+    return callback(null, lcov);
+  }
+}
+
+/** A new reporter on each call, with new or without, as spec. */
+export function lcov(options) {
+  return new LcovReporter(options);
+}
+
+const reporters = { dot, junit, spec, tap, lcov };
+export default reporters;

package/node/prelude/timers.js

@@ -1,14 +1,9 @@
-// node:timers (ADR 0012, layer 3): setTimeout, setInterval and setImmediate as Node has them,
-// returning Timeout and Immediate objects (ref, unref, hasRef, refresh, close, a primitive id)
-// that call back with the object as `this` (internal/timers.js); and the legacy enroll,
-// unenroll, active and _unrefActive, on an object of the caller's with an _onTimeout.
-import { invalidArgType, outOfRange } from "./internal/errors.js";
-import {
-  TIMEOUT_MAX, armed, arm, clearImmediate, clearInterval, clearTimeout, duration, kFire, kId, kPending, kRefed,
-  setImmediate, setInterval, setTimeout, unenrollTimeout,
-} from "./internal/timers.js";
-import { deprecate } from "./util.js";
-import * as promises from "./timers_promises.js";
+// node:timers: setTimeout, setInterval and setImmediate as Node has them, returning Timeout and
+// Immediate objects (ref, unref, hasRef, refresh, close, a primitive id) that call back with the
+// object as `this` (internal/timers.js).
+import { clearImmediate, clearInterval, clearTimeout, setImmediate, setInterval, setTimeout } from "./internal/timers.js";
+/* timers.promises is require("timers/promises") itself: the module's exports object */
+import promises from "./timers_promises.js";
 
 export { clearImmediate, clearInterval, clearTimeout, promises, setImmediate, setInterval, setTimeout };
 
@@ -17,76 +12,4 @@ const promisifyCustom = Symbol.for("nodejs.util.promisify.custom");
 Object.defineProperty(setTimeout, promisifyCustom, { value: promises.setTimeout, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(setImmediate, promisifyCustom, { value: promises.setImmediate, enumerable: false, writable: true, configurable: true });
 
-/* ---- The legacy API ------------------------------------------------------------------ */
-
-function getTimerDuration(msecs, name) {
-  if (typeof msecs !== "number") throw invalidArgType(name, "of type number", msecs);
-  if (msecs < 0 || !Number.isFinite(msecs)) throw outOfRange(name, "a non-negative finite number", msecs);
-  if (msecs > TIMEOUT_MAX) {
-    if (typeof process.emitWarning === "function") {
-      process.emitWarning(`${msecs} does not fit into a 32-bit signed integer.\nTimer duration was truncated to ${TIMEOUT_MAX}.`, "TimeoutOverflowWarning");
-    }
-    return TIMEOUT_MAX;
-  }
-  return msecs;
-}
-
-function enrollItem(item, msecs) {
-  if (item._idleNext) unenrollItem(item);
-  item._idleNext = item;
-  item._idlePrev = item;
-  item._idleTimeout = getTimerDuration(msecs, "msecs");
-}
-
-function unenrollItem(item) {
-  if (item[kFire] === undefined) {  /* never activated */
-    item._idleTimeout = -1;
-    item._destroyed = true;
-    return;
-  }
-  unenrollTimeout(item);
-}
-
-/* arms the item: its _onTimeout() after its _idleTimeout ms */
-function activeItem(item, refed) {
-  const msecs = item._idleTimeout;
-  if (msecs < 0 || msecs === undefined) return;
-  if (item[kFire] === undefined) item[kFire] = () => fireItem(item);
-  item._destroyed = false;
-  item[kRefed] = refed;
-  const saved = item._idleTimeout;
-  item._idleTimeout = duration(msecs);
-  arm(item, refed);
-  item._idleTimeout = saved;
-}
-
-function fireItem(item) {
-  item[kPending] = false;
-  armed.delete(item[kId]);
-  try {
-    if (typeof item._onTimeout === "function") item._onTimeout();
-  } finally {
-    if (!item[kPending]) item._destroyed = true;
-  }
-}
-
-export const enroll = deprecate(function enroll(item, msecs) {
-  enrollItem(item, msecs);
-}, "timers.enroll() is deprecated. Please use setTimeout instead.", "DEP0095");
-
-export const unenroll = deprecate(function unenroll(item) {
-  unenrollItem(item);
-}, "timers.unenroll() is deprecated. Please use clearTimeout instead.", "DEP0096");
-
-export const active = deprecate(function active(item) {
-  activeItem(item, true);
-}, "timers.active() is deprecated. Please use timeout.refresh() instead.", "DEP0126");
-
-export const _unrefActive = deprecate(function _unrefActive(item) {
-  activeItem(item, false);
-}, "timers._unrefActive() is deprecated. Please use timeout.refresh() instead.", "DEP0127");
-
-export default {
-  setTimeout, clearTimeout, setImmediate, clearImmediate, setInterval, clearInterval,
-  _unrefActive, active, unenroll, enroll, promises,
-};
+export default { setTimeout, clearTimeout, setImmediate, clearImmediate, setInterval, clearInterval, promises };

package/node/prelude/timers_promises.js

@@ -1,4 +1,4 @@
-// node:timers/promises (ADR 0012, layer 3): setTimeout and setImmediate as promises,
+// node:timers/promises: setTimeout and setImmediate as promises,
 // setInterval as an async iterator, and scheduler.wait and scheduler.yield; each takes an
 // AbortSignal, and ref: false for a timer that doesn't keep the program alive.
 import { codeError, invalidArgType } from "./internal/errors.js";

package/node/prelude/tls.js

@@ -1,7 +1,8 @@
-// node:tls (ADR 0019): TLS 1.0–1.3 clients and servers on BoringSSL, following Node's lib/tls.js.
+// node:tls: TLS 1.0–1.3 clients and servers on BoringSSL, following Node's lib/tls.js.
 // TLSSocket, Server and connect are in internal/tls/wrap.js; SecureContext, the cipher suites and
 // the errors in internal/tls/common.js; certificates in internal/tls/x509.js. The root
 // certificates are the ones Node bundles (Mozilla's), built into the runtime.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { fsReadFile, tlsRootCertificates } from "visaljs:host";
 import { EventEmitter } from "./events.js";
 import { invalidArgType, invalidArgValue, validateString } from "./internal/errors.js";

package/node/prelude/trace_events.js

@@ -0,0 +1,52 @@
+// node:trace_events: Tracing objects that enable and disable their categories, as Node's; a compiled
+// program has no trace writer, so nothing is written (Node writes node_trace.*.log).
+import { invalidArgType } from "./internal/errors.js";
+
+/* the enabled categories, each counted by the Tracings that enable it */
+const enabledCounts = new Map();
+
+class Tracing {
+  #categories;
+  #enabled = false;
+
+  constructor(categories) {
+    this.#categories = categories;
+  }
+
+  get categories() {
+    return this.#categories.join(",");
+  }
+
+  get enabled() {
+    return this.#enabled;
+  }
+
+  enable() {
+    if (this.#enabled) return;
+    this.#enabled = true;
+    for (const c of this.#categories) enabledCounts.set(c, (enabledCounts.get(c) ?? 0) + 1);
+  }
+
+  disable() {
+    if (!this.#enabled) return;
+    this.#enabled = false;
+    for (const c of this.#categories) {
+      const n = enabledCounts.get(c) - 1;
+      if (n === 0) enabledCounts.delete(c);
+      else enabledCounts.set(c, n);
+    }
+  }
+}
+
+export function createTracing(options) {
+  if (options === null || typeof options !== "object") throw invalidArgType("options", "of type object", options);
+  if (!Array.isArray(options.categories)) throw invalidArgType("options.categories", "an instance of Array", options.categories);
+  return new Tracing(options.categories.map(String));
+}
+
+/** The enabled categories, comma-separated, or undefined. */
+export function getEnabledCategories() {
+  return enabledCounts.size ? [...enabledCounts.keys()].join(",") : undefined;
+}
+
+export default { createTracing, getEnabledCategories };

package/node/prelude/tty.js

@@ -1,14 +1,20 @@
-// node:tty (ADR 0012, layer 3): isatty. The terminal streams (ReadStream, WriteStream) aren't
-// provided yet: process.stdout and process.stderr have isTTY.
+// node:tty: isatty, and ReadStream: a terminal read as node:net's Socket, which
+// process.stdin is when it's a terminal. ReadStream links node:net and libuv: its class is
+// internal/tty_read_stream.js, in programs whose code names it (a name only computed at run time
+// throws ERR_VISALJS_UNSUPPORTED). WriteStream isn't provided yet: process.stdout and
+// process.stderr have isTTY.
 import { ttyIsatty } from "visaljs:host";
 import { notSupported } from "./internal/errors.js";
+import { streams } from "./internal/tty_streams.js";
 
 export function isatty(fd) {
   return Number.isInteger(fd) && fd >= 0 && fd <= 2147483647 && ttyIsatty(fd);
 }
 
-export function ReadStream() {
-  throw notSupported("tty.ReadStream");
+/** ReadStream(fd, options): a terminal, read. */
+export function ReadStream(fd, options) {
+  if (streams.ReadStream === undefined) throw notSupported("tty.ReadStream (named only at run time)");
+  return Reflect.construct(streams.ReadStream, [fd, options], new.target ?? ReadStream);
 }
 
 export function WriteStream() {