@amritk/nish-x86_64-linux 0.18.0 → 0.21.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@amritk/nish-x86_64-linux",
-  "version": "0.18.0",
-  "description": "The @amritk/nish native compiler for Linux on x86_64",
+  "version": "0.21.0",
+  "description": "The nish native compiler for Linux on x86_64",
   "license": "MIT",
   "os": [
     "linux"
@@ -17,6 +17,7 @@
     "runtime",
     "scripts",
     "std",
+    "docs",
     "LICENSE",
     "INSTALL.md"
   ],

package/runtime/browser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `nish/runtime/browser`: importing it installs the browser host on the core
+ * in `nish/runtime` (docs/guide/using-nish/to-typescript.md).
+ */
+
+/**
+ * What the program's `exit(code)`, and every panic, throws: a page cannot end
+ * itself. Tell it apart with `instanceof`, not by its `name`.
+ */
+export class NishExit extends Error {
+  /** The 8-bit status a native exit would leave: `code & 0xff`. */
+  readonly code: number;
+  constructor(code: number);
+}

package/runtime/browser.mjs

@@ -0,0 +1,88 @@
+/**
+ * The browser host (WP33 R3): importing this installs, on the core in
+ * `runtime/core.mjs`, the answers a web page can give. It names no `node:`
+ * module and reads only web globals (`console`, `performance`,
+ * `queueMicrotask`), so it loads in a page, a worker or any engine that has
+ * those.
+ *
+ *   - Output goes to the console a line at a time: what `write` leaves without
+ *     a newline waits for the next one, for `exit`, or for the program to yield.
+ *   - `exit(code)` throws a `NishExit` carrying the code, since a page cannot
+ *     end itself; the caller that started the program catches it, and does
+ *     not call the module again (docs/security/runtime-browser.md, BROWSER-2).
+ *   - `monotonicNanos` reads `performance.now()`, `getenv` answers `null`,
+ *     `isTerminal` answers `false` and `terminalSize` `[-25, 0]`, and `argv()`
+ *     is the program alone.
+ *   - Every file-system, process and machine call panics, naming itself and
+ *     the browser.
+ */
+import { installHost, panic } from "./core/host.mjs";
+
+/**
+ * What `exit(code)` throws: `code` is the 8-bit status a native exit would
+ * leave. Exported so a caller tells it apart with `instanceof`, which a thrown
+ * object that only carries the name does not pass.
+ */
+export class NishExit extends Error {
+  constructor(code) {
+    super(`the program exited with ${code}`);
+    this.name = "NishExit";
+    this.code = code & 0xff;
+  }
+}
+
+/**
+ * One console stream, buffered to the next newline. The `"%s"` keeps a `%d`
+ * or `%o` in the program's text from being read as a format directive.
+ */
+function lineStream(print) {
+  let pending = "";
+  let scheduled = false;
+  const flush = () => {
+    scheduled = false;
+    if (pending !== "") print("%s", pending);
+    pending = "";
+  };
+  return {
+    write(s) {
+      // Only the text up to the last newline is split, so a run of writes
+      // with no newline costs their length once, not once per write.
+      const text = String(s);
+      const last = text.lastIndexOf("\n");
+      if (last < 0) {
+        pending += text;
+      } else {
+        const lines = (pending + text.slice(0, last)).split("\n");
+        pending = text.slice(last + 1);
+        for (const line of lines) print("%s", line);
+      }
+      if (pending !== "" && !scheduled) {
+        scheduled = true;
+        queueMicrotask(flush);
+      }
+    },
+    flush,
+  };
+}
+
+const out = lineStream((...a) => console.log(...a));
+const err = lineStream((...a) => console.error(...a));
+
+installHost({
+  writeOut: out.write,
+  writeErr: err.write,
+  exit(code) {
+    out.flush();
+    err.flush();
+    throw new NishExit(code);
+  },
+  argv: () => ["main"],
+  call(name) {
+    if (name === "getenv") return null;
+    if (name === "monotonicNanos") return BigInt(Math.round(performance.now() * 1e6));
+    // A page has no terminal, which `nish:term` answers as a pipe does.
+    if (name === "isTerminal") return false;
+    if (name === "terminalSize") return [-25, 0];
+    return panic(`${name} is not available in a browser`);
+  },
+});

package/runtime/core/arrays.d.ts

@@ -0,0 +1,18 @@
+/** The array half of the core: bounds-checked access, and the arena stubs. */
+import type { i32 } from "./numbers.js";
+export declare function idx<T>(a: readonly T[], i: number | bigint): T;
+export declare function pop<T>(a: T[]): T;
+export declare function setIdx<T>(a: T[], i: number | bigint, v: T): T;
+export declare function updIdx<T>(a: T[], i: number | bigint, f: (old: T) => T): T;
+export declare function uncheckedGet<T extends number>(xs: readonly T[], i: i32): T;
+export declare function uncheckedSet<T extends number>(xs: T[], i: i32, v: T): void;
+export declare function copyIn<T>(v: T): T;
+export declare function storeIdx<T>(a: T[], i: number | bigint, v: T): T;
+export declare function arraySet<T>(dst: T[], src: readonly T[], offset?: number): void;
+export declare function newArray<T>(n: number | bigint, zero: T): T[];
+export declare function arenaUsed(): number;
+export declare function arenaMark(): number;
+export declare function arenaRelease(m?: unknown): void;
+export declare function arenaReset(): void;
+/** `using a = arena()`: an object whose `Symbol.dispose` does nothing. */
+export declare function arena(): object;

package/runtime/core/arrays.mjs

@@ -0,0 +1,125 @@
+import { panicIndex, panicSlice, toIndex } from "./checks.mjs";
+
+// The native check compares the index as an unsigned 64-bit number, so a
+// negative one fails, and prints, as that number: `-1` is 18446744073709551615.
+// A NaN or infinite `number` has no such number and prints as it is.
+function outOfRange(i, len) {
+  const n = toIndex(i);
+  if (typeof i !== "bigint" && !Number.isFinite(n)) panicIndex(n, len);
+  const k = typeof i === "bigint" ? i : BigInt(n);
+  panicIndex(k < 0n ? BigInt.asUintN(64, k) : k, len);
+}
+
+/** `a[i]` read with the WP4 bounds check (negative indices fail like the unsigned compare does). */
+export function idx(a, i) {
+  const k = toIndex(i);
+  if (!(k >= 0 && k < a.length)) outOfRange(i, a.length);
+  return a[k];
+}
+
+/** `a.pop()`: the last element, or the bounds panic — Nish has no `undefined` to return. */
+export function pop(a) {
+  if (a.length === 0) panicIndex(0, 0);
+  return a.pop();
+}
+
+/** `a[i] = v`: evaluates `a`, `i`, `v`, then checks and stores; yields `v`. */
+export function setIdx(a, i, v) {
+  const k = toIndex(i);
+  if (!(k >= 0 && k < a.length)) outOfRange(i, a.length);
+  a[k] = v;
+  return v;
+}
+
+/**
+ * `a[i] op= v`: evaluates `a`, `i`, checks, loads, then `f(old)` computes the
+ * new element, and checks again before the store, as `f` can shrink `a`.
+ */
+export function updIdx(a, i, f) {
+  const k = toIndex(i);
+  if (!(k >= 0 && k < a.length)) outOfRange(i, a.length);
+  const v = f(a[k]);
+  if (!(k < a.length)) outOfRange(i, a.length);
+  a[k] = v;
+  return v;
+}
+
+/** `nish:unsafe`'s `uncheckedGet(a, i)`: the element with no bounds check, as the native load is. */
+export function uncheckedGet(a, i) {
+  return a[i];
+}
+
+/** `nish:unsafe`'s `uncheckedSet(a, i, v)`: the store with no bounds check. */
+export function uncheckedSet(a, i, v) {
+  a[i] = v;
+}
+
+// A record an array holds inline is an object literal here, and nothing else
+// is a plain object: a class instance has its class's prototype, and an array
+// has Array's.
+function isRecord(v) {
+  return v !== null && typeof v === "object" && Object.getPrototypeOf(v) === Object.prototype;
+}
+
+/** A value put into an array slot from a generic body: a copy when it is a record, as a slot holds it inline. */
+export function copyIn(v) {
+  return isRecord(v) ? { ...v } : v;
+}
+
+/**
+ * `a[i] = v` from a generic body: as `setIdx`, but a record is written field
+ * by field into the record already in the slot, as an inline element is.
+ */
+export function storeIdx(a, i, v) {
+  const k = toIndex(i);
+  if (!(k >= 0 && k < a.length)) outOfRange(i, a.length);
+  const old = a[k];
+  if (isRecord(old) && isRecord(v)) Object.assign(old, v);
+  else a[k] = v;
+  return v;
+}
+
+/**
+ * `dst.set(src, offset)` (WP34 N2): `TypedArray.prototype.set`'s copy on the
+ * plain array a `u8[]` is here. The source is copied first, so a self-copy or
+ * an overlapping one reads what was there before, as `memmove` does natively;
+ * a range past the end fails with the native panic and its words, where a
+ * typed array would throw a `RangeError` for the same offsets.
+ */
+export function arraySet(dst, src, offset) {
+  // `ToIntegerOrInfinity`: NaN is 0, as `llvm.fptosi.sat` makes it natively.
+  // `Math.trunc` rather than `toIndex`, which converts a bigint: an `i64` or
+  // `u64` offset is a bigint here, and it throws the `TypeError` the typed
+  // array and `Array.prototype.fill` throw for one, instead of being rounded
+  // to the nearest double past 2^53 (docs/RUN_UNDER_NODE.md).
+  const at = offset === undefined ? 0 : Math.trunc(offset) || 0;
+  const end = at + src.length;
+  if (!(at >= 0 && end <= dst.length)) panicSlice(at, end, dst.length);
+  // Two plain arrays overlap only when they are one array, which is the one
+  // case that must read the source before writing it.
+  const from = src === dst ? src.slice() : src;
+  for (let i = 0; i < from.length; i++) dst[at + i] = from[i];
+}
+
+/** `new Array<T>(n)`: `n` zero-filled elements (`0`, `0n`, or `false`). */
+export function newArray(n, zero) {
+  return new Array(toIndex(n)).fill(zero);
+}
+
+// Arena introspection has no JS counterpart: the stubs keep programs that only
+// compare `Arena.used()` before/after (a "stayed flat" check) in agreement, while
+// programs that print raw byte counts are listed as known differences.
+//
+// `nish --threads` makes the native arena thread-local (WP20 T0) and nothing
+// here moves with it: a rewritten program runs on the one thread Node gives it,
+// so "the arena of the calling thread" and "the arena" are the same object, and
+// these stubs answer for both. If T1 ever lands a spawn the rewrite can reach,
+// that is when this file grows a second arena to keep count of.
+export function arenaUsed() { return 0; }
+export function arenaMark() { return 0; }
+export function arenaRelease() {}
+export function arenaReset() {}
+/** `using a = arena()`: a disposable whose disposal does nothing, because there is no arena to release. */
+export function arena() {
+  return { [Symbol.dispose]() {} };
+}

package/runtime/core/checks.mjs

@@ -0,0 +1,20 @@
+/**
+ * The checks the strings and arrays share: an index as the compiler converts
+ * it, and the two bounds panics with their native words. Internal to the core:
+ * `runtime/core.mjs` does not re-export them.
+ */
+import { panic } from "./host.mjs";
+
+/** Index conversion as in the compiler: `sext` from i32, `fptosi` (truncation) from f64. */
+export function toIndex(i) {
+  return typeof i === "bigint" ? Number(i) : Math.trunc(i);
+}
+
+export function panicIndex(i, len) {
+  panic(`index out of range: ${i} >= ${len}`);
+}
+
+/** `nish_panic_slice`: the failed range check of `s.slice(start, end)`; the offsets print signed. */
+export function panicSlice(start, end, len) {
+  panic(`slice out of range: [${start}, ${end}) of length ${len}`);
+}

package/runtime/core/host.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The host the core runs on, and every builtin that asks it. Import
+ * `nish/runtime/node` or `nish/runtime/browser` to install one; until then each
+ * of these throws a `NishNoHost`.
+ */
+import type { f64, i32, i64, u8 } from "./numbers.js";
+
+/** What an adapter installs: `exit` never returns, and `call` answers the builtin `name`. */
+export interface Host {
+  writeOut(s: string): void;
+  writeErr(s: string): void;
+  exit(code: number): never;
+  argv(): string[];
+  call(name: string, args: unknown[]): unknown;
+}
+
+/** What every member of the default host throws: no adapter has been imported. */
+export declare class NishNoHost extends Error {
+  constructor(name: string);
+  readonly requested: string;
+}
+
+export declare function installHost(next: Host): void;
+export declare function log(x: unknown): void;
+export declare function error(x: unknown): void;
+export declare function write(s: string): void;
+export declare function writeError(s: string): void;
+export declare function panic(message: string): never;
+export declare function exit(code: i32): never;
+export declare function argv(): string[];
+export declare function readFileSync(path: string): string;
+export declare function readFileSyncOrNull(path: string): string | null;
+export declare function readFileBytesSync(path: string): u8[] | null;
+export declare function writeFileSync(path: string, data: string): void;
+export declare function appendFileSync(path: string, data: string): void;
+export declare function mkdirSync(path: string): boolean;
+export declare function isDirectorySync(path: string): boolean;
+export declare function readdirSync(path: string): string[] | null;
+export declare function realpathSync(path: string): string | null;
+export declare function platform(): string;
+export declare function arch(): string;
+export declare function getenv(name: string): string | null;
+export declare function spawnSync(argv: string[]): number;
+export declare function spawnSyncTo(argv: string[], stdoutPath: string, stderrPath: string): number;
+export declare function kill(pid: i32, sig: i32): i32;
+export declare function availableParallelism(): i32;
+export declare function totalMemory(): i64;
+export declare function monotonicNanos(): i64;
+export declare function statMtimeSync(path: string): f64;
+export declare function lstatOwnerModeSync(path: string): i64;
+export declare function geteuid(): i64;
+export declare function isExecutableSync(path: string): boolean;
+export declare function isTerminal(fd: i32): boolean;
+export declare function terminalSize(): i32[];
+/** `crypto.getRandomValues(bytes)` for a `u8[]`; a typed array goes straight through. */
+export declare function getRandomValues<T extends u8[] | Uint8Array>(bytes: T): T;
+/** These four have no synchronous reading: each throws, naming itself, and is typed as `runtime/nish.d.ts` types it. */
+export declare function spawn(argv: string[]): i32;
+export declare function waitPid(pid: i32, flags: i32): i32[];
+export declare function signalFd(): i32;
+export declare function readSignal(fd: i32): i32;
+/** What each `nish:net` function is under the core: a throw naming `name`. */
+export declare function noNetReading(name: string): never;
+/** What `readStdin`, `waitStdin`, `setRawMode` and `setTerminalRestore` are under the core: a throw naming `name`. */
+export declare function noTermReading(name: string): never;
+/** `nish:term`'s four that have no reading under Node: each throws, naming itself. */
+export declare function readStdin(buf: u8[], off: i32, len: i32): i32;
+export declare function waitStdin(timeoutMs: i32): boolean;
+export declare function setRawMode(on: boolean): i32;
+export declare function setTerminalRestore(bytes: string): i32;

package/runtime/core/host.mjs

@@ -0,0 +1,311 @@
+/**
+ * The host the core runs on (WP33 R3). Everything a program asks of the world
+ * outside it — its output, its exit, its arguments, its files, its environment,
+ * its children and its clocks — goes through one installed host object:
+ *
+ *   {
+ *     writeOut(s), writeErr(s): write `s` to stdout or stderr, synchronously;
+ *     exit(code): end the process with `code` and never return;
+ *     argv(): the program then its arguments, as `process.argv` is under Nish;
+ *     call(name, args): the host-bound builtin `name`, applied to `args`;
+ *   }
+ *
+ * `runtime/node.mjs` installs Node's on import. Until a host is installed every
+ * member throws a `NishNoHost` naming what was asked for, so a core loaded on
+ * its own fails loudly rather than writing nowhere.
+ *
+ * The functions that have no synchronous reading under Node (`spawn`,
+ * `waitPid`, `signalFd`, `readSignal`, the `nish:net` set) throw here without
+ * asking any host.
+ */
+
+/** What every member of the default host throws: no adapter has been imported. */
+export class NishNoHost extends Error {
+  constructor(name) {
+    super(`\`${name}\` needs a host, and none is installed: import runtime/node.mjs (or another adapter) first`);
+    this.name = "NishNoHost";
+    this.requested = name;
+  }
+}
+
+const NO_HOST = {
+  writeOut() {
+    throw new NishNoHost("writeOut");
+  },
+  writeErr() {
+    throw new NishNoHost("writeErr");
+  },
+  exit() {
+    throw new NishNoHost("exit");
+  },
+  argv() {
+    throw new NishNoHost("argv");
+  },
+  call(name) {
+    throw new NishNoHost(name);
+  },
+};
+
+let host = NO_HOST;
+
+/** Make `next` the host every later call goes through. */
+export function installHost(next) {
+  host = next;
+}
+
+/** `console.log(x)`: `String(x)` (no `n` suffix for i64) plus a newline, written synchronously. */
+export function log(x) {
+  host.writeOut(`${String(x)}\n`);
+}
+
+/** `console.error(x)`: the same, on stderr. */
+export function error(x) {
+  host.writeErr(`${String(x)}\n`);
+}
+
+/** `write(s)` / `writeError(s)`: the bytes as they are, no trailing newline. */
+export function write(s) {
+  host.writeOut(s);
+}
+
+export function writeError(s) {
+  host.writeErr(s);
+}
+
+/** `panic(message)`: the message on stderr, then exit 1. */
+export function panic(message) {
+  host.writeErr(`${message}\n`);
+  host.exit(1);
+}
+
+/**
+ * `process.exit(code)`: libc `exit` truncates to 8 bits exactly like Node does.
+ * The code is converted as an index is (`sext` from i32, truncation from f64).
+ */
+export function exit(code) {
+  host.exit(typeof code === "bigint" ? Number(code) : Math.trunc(code));
+}
+
+/** `process.argv`: index 0 is the program (the script here, the executable natively), then the arguments. */
+export function argv() {
+  return host.argv();
+}
+
+// ---- The host-bound builtins ----------------------------------------------------
+//
+// Each is the installed host's answer, under the same name and with the same
+// arguments; what each answers is written beside its Node body in
+// `runtime/node.mjs`.
+
+export function readFileSync(path) {
+  return host.call("readFileSync", [path]);
+}
+
+export function readFileSyncOrNull(path) {
+  return host.call("readFileSyncOrNull", [path]);
+}
+
+export function readFileBytesSync(path) {
+  return host.call("readFileBytesSync", [path]);
+}
+
+export function writeFileSync(path, data) {
+  return host.call("writeFileSync", [path, data]);
+}
+
+export function appendFileSync(path, data) {
+  return host.call("appendFileSync", [path, data]);
+}
+
+export function mkdirSync(path) {
+  return host.call("mkdirSync", [path]);
+}
+
+export function isDirectorySync(path) {
+  return host.call("isDirectorySync", [path]);
+}
+
+export function readdirSync(path) {
+  return host.call("readdirSync", [path]);
+}
+
+export function realpathSync(path) {
+  return host.call("realpathSync", [path]);
+}
+
+export function platform() {
+  return host.call("platform", []);
+}
+
+export function arch() {
+  return host.call("arch", []);
+}
+
+export function getenv(name) {
+  return host.call("getenv", [name]);
+}
+
+export function spawnSync(argv) {
+  return host.call("spawnSync", [argv]);
+}
+
+export function spawnSyncTo(argv, out, err) {
+  return host.call("spawnSyncTo", [argv, out, err]);
+}
+
+export function kill(pid, sig) {
+  return host.call("kill", [pid, sig]);
+}
+
+export function availableParallelism() {
+  return host.call("availableParallelism", []);
+}
+
+export function totalMemory() {
+  return host.call("totalMemory", []);
+}
+
+export function monotonicNanos() {
+  return host.call("monotonicNanos", []);
+}
+
+export function statMtimeSync(path) {
+  return host.call("statMtimeSync", [path]);
+}
+
+export function lstatOwnerModeSync(path) {
+  return host.call("lstatOwnerModeSync", [path]);
+}
+
+export function geteuid() {
+  return host.call("geteuid", []);
+}
+
+export function isExecutableSync(path) {
+  return host.call("isExecutableSync", [path]);
+}
+
+export function isTerminal(fd) {
+  return host.call("isTerminal", [fd]);
+}
+
+export function terminalSize() {
+  return host.call("terminalSize", []);
+}
+
+// ---- Randomness ----------------------------------------------------------------
+
+/**
+ * The host's own fill, taken from the web `crypto` global before
+ * `runtime/nish.mjs` puts the one below in its place on the same object.
+ */
+const webRandom = globalThis.crypto.getRandomValues.bind(globalThis.crypto);
+
+/**
+ * `crypto.getRandomValues(bytes)` for the plain array a `u8[]` is here. The
+ * web's own takes only a typed array, so the bytes are drawn into one and copied
+ * across. More than 65,536 fails with the native panic and its words, where
+ * the web's would throw a `QuotaExceededError`: the exit status is 1 either
+ * way. A typed array goes straight through.
+ */
+export function getRandomValues(bytes) {
+  if (!Array.isArray(bytes)) {
+    return webRandom(bytes);
+  }
+  if (bytes.length > 65536) {
+    panic(`crypto.getRandomValues: ${bytes.length} bytes asked for, and one call fills at most 65536`);
+  }
+  const drawn = webRandom(new Uint8Array(bytes.length));
+  for (let i = 0; i < drawn.length; i++) {
+    bytes[i] = drawn[i];
+  }
+  return bytes;
+}
+
+// ---- No synchronous reading ------------------------------------------------------
+
+/**
+ * `spawn(argv)` and `waitPid(pid, flags)` (WP34 N12) have no faithful reading
+ * under Node, for `signalFd`'s reason: Node reaps its children itself, on the
+ * event loop, and hands their status to an `exit` listener, so no synchronous
+ * function here can wait for one, and a child Node started is never there for
+ * a wait-less poll to find. Each throws, naming itself.
+ */
+function noProcessReading(name) {
+  throw new Error(
+    `\`${name}\` has no synchronous reading under Node: a child is reaped by the event loop, which a synchronous wait never returns to (docs/wp33-round-trip.md)`
+  );
+}
+
+export function spawn() {
+  return noProcessReading("spawn");
+}
+
+export function waitPid() {
+  return noProcessReading("waitPid");
+}
+
+/**
+ * `signalFd()` and `readSignal(fd)` have no faithful reading under Node, and
+ * these say so rather than answer something else. Node delivers a signal to
+ * its event loop (`process.on("SIGTERM")`), and a blocking read keeps the loop
+ * from ever running, so no synchronous function here can learn that one
+ * arrived. docs/wp33-round-trip.md §3.5 has the row and the translation.
+ */
+export function signalFd() {
+  throw new Error(
+    "signalFd has no synchronous reading under Node: a signal reaches the event loop, which a blocking readSignal never returns to (docs/wp33-round-trip.md)"
+  );
+}
+
+export function readSignal() {
+  return signalFd();
+}
+
+/**
+ * The `nish:net` functions (WP34 N5) have no faithful reading under Node
+ * either, for `signalFd`'s reason: Node's sockets are asynchronous only, and a
+ * socket becomes readable, writable or connected only to the event loop, which
+ * a program that owns its loop and spins or blocks in it never returns to. So
+ * each throws, naming itself, rather than answer -11 forever; `nish.mjs`
+ * installs one per name.
+ * docs/wp33-round-trip.md is the note that asks for one stated answer.
+ */
+export function noNetReading(name) {
+  throw new Error(
+    `\`${name}\` has no synchronous reading under Node: a socket is ready only to the event loop, which a program that owns its loop never returns to (docs/wp33-round-trip.md)`
+  );
+}
+
+/**
+ * `readStdin`, `waitStdin` and `setRawMode` (`nish:term`) throw too, naming
+ * themselves, for `noNetReading`'s reason: Node reads stdin only to its event
+ * loop, and its own raw mode turns Ctrl-C into a byte, which is not the native
+ * answer. `setTerminalRestore` throws as well: its bytes go out from the
+ * native runtime's exit and signal paths, which Node does not run. The core
+ * exports one per name, for `--emit-ts` output to import, and
+ * `nish.mjs` installs one per name as a global.
+ */
+export function noTermReading(name) {
+  throw new Error(
+    `\`${name}\` has no synchronous reading under Node: stdin is read only by the event loop, which a program that owns its loop never returns to (docs/RUN_UNDER_NODE.md)`
+  );
+}
+
+export function readStdin() {
+  return noTermReading("readStdin");
+}
+
+export function waitStdin() {
+  return noTermReading("waitStdin");
+}
+
+export function setRawMode() {
+  return noTermReading("setRawMode");
+}
+
+export function setTerminalRestore() {
+  throw new Error(
+    "`setTerminalRestore` has no reading under Node: its bytes go out from the native runtime's exit, panic and signal paths, which Node does not run (docs/RUN_UNDER_NODE.md)"
+  );
+}