@tlockney/cdp-kernel 0.0.0-stage → 0.1.1

package/dist/wire.d.ts

@@ -0,0 +1,35 @@
+export declare const DELIMITER: Uint8Array<ArrayBuffer>;
+export declare const PROTOCOL_VERSION = "5.3";
+export type JsonObject = {
+    [key: string]: unknown;
+};
+export interface Header extends JsonObject {
+    msg_id: string;
+    session: string;
+    date: string;
+    username: string;
+    msg_type: string;
+    version: string;
+}
+export interface Message {
+    identities: Uint8Array[];
+    sig: string;
+    /** Raw bytes of header, parent_header, metadata, content as received. */
+    signedParts: Uint8Array[];
+    header: Header;
+    parentHeader: JsonObject;
+    metadata: JsonObject;
+    content: JsonObject;
+    buffers: Uint8Array[];
+}
+export declare function sign(key: string, parts: Uint8Array[]): string;
+export declare function verify(key: string, parts: Uint8Array[], sig: string): boolean;
+export declare function makeHeader(session: string, msgType: string): Header;
+export interface EncodeOptions {
+    identities?: Uint8Array[];
+    parentHeader?: JsonObject;
+    metadata?: JsonObject;
+    buffers?: Uint8Array[];
+}
+export declare function encodeMessage(session: string, key: string, msgType: string, content: JsonObject, options?: EncodeOptions): Uint8Array[];
+export declare function decodeMessage(frames: Uint8Array[]): Message;

package/dist/wire.js

@@ -0,0 +1,94 @@
+// Jupyter wire protocol: message framing and HMAC signing.
+//
+// Ported from Deno's cli/js/jupyter_kernel.js (v2.9.6), which is
+// Copyright 2018-2026 the Deno authors, MIT license. The structure is kept;
+// WebCrypto's async HMAC is replaced with node:crypto's synchronous one.
+import { Buffer } from "node:buffer";
+import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+const ENC = new TextEncoder();
+const DEC = new TextDecoder();
+export const DELIMITER = ENC.encode("<IDS|MSG>");
+export const PROTOCOL_VERSION = "5.3";
+export function sign(key, parts) {
+    if (key.length === 0)
+        return "";
+    const hmac = createHmac("sha256", key);
+    for (const part of parts)
+        hmac.update(part);
+    return hmac.digest("hex");
+}
+// Messages that fail this check must be dropped: the kernel runs user code,
+// so an unsigned execute_request from any local process would be code
+// execution. Matches Deno's hmacVerify.
+export function verify(key, parts, sig) {
+    if (key.length === 0)
+        return true;
+    if (!/^[0-9a-f]+$/i.test(sig) || sig.length % 2 !== 0)
+        return false;
+    const expected = Buffer.from(sign(key, parts), "hex");
+    const actual = Buffer.from(sig, "hex");
+    return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+export function makeHeader(session, msgType) {
+    return {
+        msg_id: randomUUID(),
+        session,
+        date: new Date().toISOString(),
+        username: "kernel",
+        msg_type: msgType,
+        version: PROTOCOL_VERSION,
+    };
+}
+export function encodeMessage(session, key, msgType, content, options = {}) {
+    const parts = [
+        makeHeader(session, msgType),
+        options.parentHeader ?? {},
+        options.metadata ?? {},
+        content,
+    ].map((part) => ENC.encode(JSON.stringify(part)));
+    return [
+        ...(options.identities ?? []),
+        DELIMITER,
+        ENC.encode(sign(key, parts)),
+        ...parts,
+        ...(options.buffers ?? []),
+    ];
+}
+function isDelimiter(frame) {
+    if (frame.length !== DELIMITER.length)
+        return false;
+    for (let i = 0; i < frame.length; i++) {
+        if (frame[i] !== DELIMITER[i])
+            return false;
+    }
+    return true;
+}
+function parseObject(frame) {
+    const value = JSON.parse(DEC.decode(frame));
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("expected a JSON object frame");
+    }
+    return value;
+}
+function isHeader(value) {
+    return typeof value.msg_id === "string" && typeof value.msg_type === "string";
+}
+export function decodeMessage(frames) {
+    const delimIdx = frames.findIndex(isDelimiter);
+    if (delimIdx === -1 || frames.length < delimIdx + 6) {
+        throw new Error("malformed message: no <IDS|MSG> delimiter");
+    }
+    const header = parseObject(frames[delimIdx + 2]);
+    if (!isHeader(header))
+        throw new Error("malformed message header");
+    return {
+        identities: frames.slice(0, delimIdx),
+        sig: DEC.decode(frames[delimIdx + 1]),
+        signedParts: frames.slice(delimIdx + 2, delimIdx + 6),
+        header,
+        parentHeader: parseObject(frames[delimIdx + 3]),
+        metadata: parseObject(frames[delimIdx + 4]),
+        content: parseObject(frames[delimIdx + 5]),
+        buffers: frames.slice(delimIdx + 6),
+    };
+}

package/dist/zmtp.d.ts

@@ -0,0 +1,49 @@
+import { Buffer } from "node:buffer";
+import { type Server, type Socket } from "node:net";
+/** Pull-style reader over a socket's 'data' events. */
+export declare class SocketReader {
+    #private;
+    constructor(socket: Socket);
+    readExact(n: number): Promise<Uint8Array>;
+}
+export interface Frame {
+    data: Uint8Array;
+    hasMore: boolean;
+    isCommand: boolean;
+}
+export declare function readFrame(reader: SocketReader): Promise<Frame>;
+export declare function encodeFrame(data: Uint8Array, more: boolean, isCommand?: boolean): Uint8Array;
+export declare function encodeMultipart(frames: Uint8Array[]): Buffer;
+export declare function makeGreeting(): Uint8Array;
+export declare function makeReadyCommand(socketType: string): Uint8Array;
+export declare function recvMultipart(reader: SocketReader): Promise<Uint8Array[]>;
+/** Async FIFO with blocking pop. */
+export declare class Queue<T> {
+    #private;
+    push(item: T): void;
+    pop(): Promise<T>;
+}
+/** REP socket for the heartbeat channel: echo everything. */
+export declare function startHeartbeat(port: number, host: string): Server;
+export interface RoutedMessage {
+    peer: string;
+    frames: Uint8Array[];
+}
+/** ROUTER socket: each TCP connection is one peer with a generated identity. */
+export declare class RouterSocket {
+    #private;
+    readonly incoming: Queue<RoutedMessage>;
+    readonly peers: Map<string, Socket>;
+    readonly server: Server;
+    constructor(port: number, host: string);
+    recv(): Promise<RoutedMessage>;
+    send(peer: string, frames: Uint8Array[]): void;
+    sendAll(frames: Uint8Array[]): void;
+}
+/** PUB socket for iopub: fan out to every subscriber, no topic filtering. */
+export declare class PubSocket {
+    readonly subscribers: Set<Socket>;
+    readonly server: Server;
+    constructor(port: number, host: string);
+    send(frames: Uint8Array[]): void;
+}

package/dist/zmtp.js

@@ -0,0 +1,241 @@
+// Minimal ZMTP 3.0 server sockets (NULL mechanism) over node:net.
+//
+// Ported from Deno's cli/js/jupyter_kernel.js (v2.9.6), which is
+// Copyright 2018-2026 the Deno authors, MIT license. Deno's kernel dropped
+// libzmq in denoland/deno#34083 and speaks just enough ZMTP for Jupyter
+// frontends; this keeps the same greeting, READY command and framing, and
+// swaps Deno.listen for node:net plus a small buffered reader.
+import { Buffer } from "node:buffer";
+import { createServer } from "node:net";
+import { randomBytes } from "node:crypto";
+const ENC = new TextEncoder();
+/** Pull-style reader over a socket's 'data' events. */
+export class SocketReader {
+    #chunks = [];
+    #buffered = 0;
+    #waiter = null;
+    #closed = false;
+    #error = null;
+    constructor(socket) {
+        socket.on("data", (chunk) => {
+            this.#chunks.push(chunk);
+            this.#buffered += chunk.length;
+            this.#wake();
+        });
+        socket.on("close", () => {
+            this.#closed = true;
+            this.#wake();
+        });
+        socket.on("error", (err) => {
+            this.#error = err;
+            this.#wake();
+        });
+    }
+    #wake() {
+        const waiter = this.#waiter;
+        this.#waiter = null;
+        waiter?.();
+    }
+    async readExact(n) {
+        while (this.#buffered < n) {
+            if (this.#error)
+                throw this.#error;
+            if (this.#closed)
+                throw new Error("connection closed");
+            await new Promise((resolve) => (this.#waiter = resolve));
+        }
+        const all = this.#chunks.length === 1 ? this.#chunks[0] : Buffer.concat(this.#chunks);
+        const out = all.subarray(0, n);
+        const rest = all.subarray(n);
+        this.#chunks = rest.length > 0 ? [rest] : [];
+        this.#buffered = rest.length;
+        return new Uint8Array(out);
+    }
+}
+export async function readFrame(reader) {
+    const [flag] = await reader.readExact(1);
+    const isLong = (flag & 0x02) !== 0;
+    let size;
+    if (isLong) {
+        const b = await reader.readExact(8);
+        size = Number(new DataView(b.buffer, b.byteOffset, 8).getBigUint64(0));
+    }
+    else {
+        [size] = await reader.readExact(1);
+    }
+    return {
+        data: await reader.readExact(size),
+        hasMore: (flag & 0x01) !== 0,
+        isCommand: (flag & 0x04) !== 0,
+    };
+}
+export function encodeFrame(data, more, isCommand = false) {
+    const long = data.length > 255;
+    const flag = (more ? 0x01 : 0) | (long ? 0x02 : 0) | (isCommand ? 0x04 : 0);
+    const headerLen = long ? 9 : 2;
+    const buf = new Uint8Array(headerLen + data.length);
+    buf[0] = flag;
+    if (long) {
+        new DataView(buf.buffer).setBigUint64(1, BigInt(data.length));
+    }
+    else {
+        buf[1] = data.length;
+    }
+    buf.set(data, headerLen);
+    return buf;
+}
+// One write per multipart message. Deno found that many small writes
+// interact badly with Nagle/delayed-ACK against libzmq peers.
+export function encodeMultipart(frames) {
+    return Buffer.concat(frames.map((f, i) => encodeFrame(f, i < frames.length - 1)));
+}
+export function makeGreeting() {
+    // Signature 0xff..0x7f, version 3.0, mechanism "NULL", as-server = 0.
+    // Deno learned (regression from #34083) that libzmq peers stall if a
+    // binding NULL peer sets as-server=1, so mirror libzmq's own greeting.
+    const buf = new Uint8Array(64);
+    buf[0] = 0xff;
+    buf[9] = 0x7f;
+    buf[10] = 3;
+    buf[11] = 0;
+    buf.set(ENC.encode("NULL"), 12);
+    buf[32] = 0;
+    return buf;
+}
+export function makeReadyCommand(socketType) {
+    const name = ENC.encode("READY");
+    const propName = ENC.encode("Socket-Type");
+    const value = ENC.encode(socketType);
+    const body = new Uint8Array(1 + name.length + 1 + propName.length + 4 + value.length);
+    let o = 0;
+    body[o++] = name.length;
+    body.set(name, o);
+    o += name.length;
+    body[o++] = propName.length;
+    body.set(propName, o);
+    o += propName.length;
+    new DataView(body.buffer).setUint32(o, value.length);
+    o += 4;
+    body.set(value, o);
+    return encodeFrame(body, false, true);
+}
+async function handshake(socket, reader, socketType) {
+    socket.write(makeGreeting());
+    await reader.readExact(64);
+    socket.write(makeReadyCommand(socketType));
+    await readFrame(reader); // peer READY
+}
+export async function recvMultipart(reader) {
+    const frames = [];
+    for (;;) {
+        const frame = await readFrame(reader);
+        if (frame.isCommand)
+            continue; // e.g. SUBSCRIBE/PING commands
+        frames.push(frame.data);
+        if (!frame.hasMore)
+            return frames;
+    }
+}
+function listen(port, host, onConn) {
+    const server = createServer((socket) => {
+        socket.setNoDelay(true);
+        onConn(socket);
+    });
+    server.listen(port, host);
+    return server;
+}
+/** Async FIFO with blocking pop. */
+export class Queue {
+    #items = [];
+    #waiters = [];
+    push(item) {
+        const waiter = this.#waiters.shift();
+        if (waiter)
+            waiter(item);
+        else
+            this.#items.push(item);
+    }
+    pop() {
+        const item = this.#items.shift();
+        if (item !== undefined)
+            return Promise.resolve(item);
+        return new Promise((resolve) => this.#waiters.push(resolve));
+    }
+}
+/** REP socket for the heartbeat channel: echo everything. */
+export function startHeartbeat(port, host) {
+    return listen(port, host, (socket) => {
+        const reader = new SocketReader(socket);
+        (async () => {
+            await handshake(socket, reader, "REP");
+            for (;;)
+                socket.write(encodeMultipart(await recvMultipart(reader)));
+        })().catch(() => socket.destroy());
+    });
+}
+/** ROUTER socket: each TCP connection is one peer with a generated identity. */
+export class RouterSocket {
+    incoming = new Queue();
+    peers = new Map();
+    server;
+    constructor(port, host) {
+        this.server = listen(port, host, (socket) => this.#handlePeer(socket));
+    }
+    #handlePeer(socket) {
+        const peer = randomBytes(5).toString("hex");
+        const reader = new SocketReader(socket);
+        (async () => {
+            // Register only after the handshake so a proactive send (stdin's
+            // input_request) can't land inside the greeting exchange.
+            await handshake(socket, reader, "ROUTER");
+            this.peers.set(peer, socket);
+            for (;;)
+                this.incoming.push({ peer, frames: await recvMultipart(reader) });
+        })()
+            .catch(() => { })
+            .finally(() => {
+            this.peers.delete(peer);
+            socket.destroy();
+        });
+    }
+    recv() {
+        return this.incoming.pop();
+    }
+    send(peer, frames) {
+        this.peers.get(peer)?.write(encodeMultipart(frames));
+    }
+    sendAll(frames) {
+        const buf = encodeMultipart(frames);
+        for (const socket of this.peers.values())
+            socket.write(buf);
+    }
+}
+/** PUB socket for iopub: fan out to every subscriber, no topic filtering. */
+export class PubSocket {
+    subscribers = new Set();
+    server;
+    constructor(port, host) {
+        this.server = listen(port, host, (socket) => {
+            const reader = new SocketReader(socket);
+            (async () => {
+                await handshake(socket, reader, "PUB");
+                // SUB sends a SUBSCRIBE (a command frame in ZMTP 3.1, a 0x01-prefixed
+                // message in 3.0). Readiness doesn't depend on it, so register now and
+                // drain whatever arrives.
+                this.subscribers.add(socket);
+                for (;;)
+                    await readFrame(reader);
+            })()
+                .catch(() => { })
+                .finally(() => {
+                this.subscribers.delete(socket);
+                socket.destroy();
+            });
+        });
+    }
+    send(frames) {
+        const buf = encodeMultipart(frames);
+        for (const socket of this.subscribers)
+            socket.write(buf);
+    }
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@tlockney/cdp-kernel",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Deno's Jupyter kernel, extracted to run notebooks on any V8 runtime over the Chrome DevTools Protocol",
+  "license": "MIT",
+  "author": "Thomas Lockney <thomas@lockney.net>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tlockney/cdp-kernel.git"
+  },
+  "keywords": ["jupyter", "kernel", "typescript", "notebook", "deno", "node", "cdp", "devtools-protocol"],
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "cdp-kernel": "dist/main.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "runtime/*.mjs",
+    "runtime/*.d.mts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "check": "tsc -p tsconfig.json",
+    "install:node": "node src/main.ts install --runtime node",
+    "install:deno": "node src/main.ts install --runtime deno",
+    "install:node-deno": "node src/main.ts install --runtime node --deno-compat",
+    "prepack": "npm run build",
+    "test": "node --test test/*.test.ts",
+    "e2e": "uv run --with nbclient --with nbformat --with jupyter_client python test/e2e.py"
+  },
+  "dependencies": {
+    "acorn": "^8.15.0",
+    "acorn-walk": "^8.3.4",
+    "esbuild": "^0.25.10"
+  },
+  "devDependencies": {
+    "@types/node": "^24.19.2",
+    "typescript": "^5.9.3"
+  }
+}

package/runtime/bootstrap.mjs

@@ -0,0 +1,190 @@
+// Entry module for the target runtime. The kernel host launches
+//   node --inspect=127.0.0.1:0 runtime/bootstrap.mjs
+//   deno run -A --inspect=127.0.0.1:0 runtime/bootstrap.mjs
+// then drives it over CDP. Everything the host needs from inside the
+// runtime lives on globalThis.__cdpk; output to the host goes through the
+// `__cdpk_send` CDP binding (Runtime.addBinding) plus plain stdout/stderr.
+//
+// Plain JavaScript on purpose: the same file must load unmodified in Node
+// and in Deno.
+
+import { createJupyter } from "./display.mjs";
+
+const isDeno = typeof globalThis.Deno?.version?.deno === "string";
+const ENC = new TextEncoder();
+
+const cwd = isDeno ? Deno.cwd() : process.cwd();
+const cwdUrl = new URL(`file://${cwd.endsWith("/") ? cwd : cwd + "/"}`);
+// Stand-in referrer for cell code, like Deno's ./$deno$jupyter_repl.mts.
+const replUrl = new URL("$cdpk$repl.mjs", cwdUrl);
+
+const { inspect, readFile, writeOut, writeErr, readStdinLine } = await platform();
+
+function base64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 0x8000) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+  }
+  return btoa(binary);
+}
+
+// --- Output ordering ----------------------------------------------------
+// stdout/stderr reach the host over pipes; display messages over the
+// WebSocket. To keep them in order, every binding message is preceded by a
+// numbered marker written to both pipes. The host holds the message until
+// both pipes have delivered that marker, and a gated marker ("m") holds
+// later pipe output until the message has gone out.
+let barrierSeq = 0;
+function barrier(gated = false) {
+  const n = ++barrierSeq;
+  const marker = `\x1b[cdpk:${n}${gated ? "m" : ""}]\x1b`;
+  writeOut(marker);
+  writeErr(marker);
+  return n;
+}
+
+function send(payload) {
+  const binding = globalThis.__cdpk_send;
+  if (typeof binding !== "function") return; // host not attached yet
+  binding(JSON.stringify({ ...payload, barrier: barrier(true) }));
+}
+
+const jupyter = createJupyter({
+  inspect: (value) => inspect(value),
+  base64,
+  readFile,
+  send(msgType, content, metadata, buffers) {
+    send({ kind: "iopub", msg_type: msgType, content, metadata, buffers: buffers.map(base64) });
+  },
+  // Synchronous like Deno's op_jupyter_input: ask the host, then block on
+  // stdin for its JSON-line reply.
+  input(prompt, password) {
+    send({ kind: "input_request", prompt, password });
+    const line = readStdinLine();
+    if (line === null) return null;
+    const reply = JSON.parse(line);
+    return typeof reply.value === "string" ? reply.value : null;
+  },
+});
+
+// --- Module loading -------------------------------------------------------
+function resolveRelative(specifier) {
+  return /^\.{0,2}\//.test(specifier) ? new URL(specifier, replUrl).href : specifier;
+}
+
+if (!isDeno) {
+  // Deno resolves npm:/jsr: natively; Node gets a resolve hook that adds
+  // them and re-parents cell imports to the notebook's directory.
+  const { installNodeResolveHooks } = await import("./node-hooks.mjs");
+  installNodeResolveHooks({ shimUrl: import.meta.url, replUrl: replUrl.href });
+}
+
+globalThis.__cdpk = {
+  // Cell code awaits this first; see PRELUDE in src/transform.ts.
+  tick: () => new Promise((resolve) => setTimeout(resolve, 0)),
+  // Node: the resolve hook re-parents these imports. Deno would resolve
+  // relative paths against this file, so do it here.
+  import: (specifier, options) => import(isDeno ? resolveRelative(specifier) : specifier, options),
+  meta: {
+    url: replUrl.href,
+    dirname: cwd,
+    filename: replUrl.pathname,
+    resolve: (specifier) => new URL(specifier, replUrl).href,
+  },
+  barrier,
+  broadcastResult: jupyter.broadcastResult,
+  describeError(value) {
+    if (value instanceof Error) {
+      return JSON.stringify({ name: value.name, message: value.message, stack: value.stack ?? "" });
+    }
+    return JSON.stringify({ name: "Error", message: inspect(value), stack: "" });
+  },
+};
+Object.defineProperty(globalThis, "__cdpk", { enumerable: false });
+
+globalThis.jupyter = jupyter.namespace;
+globalThis.prompt = jupyter.prompt;
+globalThis.confirm = jupyter.confirm;
+if (isDeno) {
+  // Existing Deno notebooks use Deno.jupyter, but outside `deno jupyter`
+  // that is a non-configurable getter that throws. The global binding
+  // itself is configurable, so swap in a proxy that answers `jupyter` and
+  // forwards everything else to the real namespace.
+  const real = globalThis.Deno;
+  const descriptor = Object.getOwnPropertyDescriptor(globalThis, "Deno");
+  const proxy = new Proxy(real, {
+    get: (target, key) => (key === "jupyter" ? jupyter.namespace : Reflect.get(target, key, target)),
+  });
+  Object.defineProperty(globalThis, "Deno", { ...descriptor, value: proxy });
+} else if (process.env.CDPK_DENO_COMPAT === "1" && globalThis.Deno === undefined) {
+  // Opt-in (install --deno-compat): a Deno namespace for notebooks written
+  // against `deno jupyter`. See runtime/deno-compat.mjs for the trade-off.
+  // Absolute URL: the resolve hook re-parents this module's relative
+  // imports to the notebook directory.
+  const { createDenoShim } = await import(new URL("./deno-compat.mjs", import.meta.url).href);
+  globalThis.Deno = createDenoShim({ jupyter: jupyter.namespace });
+}
+
+// An error thrown later by a cell's timer or promise must not kill the kernel.
+function reportUncaught(kind, err) {
+  writeErr(`${kind}: ${err instanceof Error ? (err.stack ?? err.message) : inspect(err)}\n`);
+}
+if (isDeno) {
+  globalThis.addEventListener("unhandledrejection", (e) => {
+    e.preventDefault();
+    reportUncaught("Uncaught (in promise)", e.reason);
+  });
+  globalThis.addEventListener("error", (e) => {
+    e.preventDefault();
+    reportUncaught("Uncaught", e.error);
+  });
+} else {
+  process.on("unhandledRejection", (err) => reportUncaught("Uncaught (in promise)", err));
+  process.on("uncaughtException", (err) => reportUncaught("Uncaught", err));
+}
+
+// Keep the event loop alive between cells.
+setInterval(() => {}, 1 << 30);
+
+async function platform() {
+  if (isDeno) {
+    const stdinBuf = new Uint8Array(1);
+    return {
+      inspect: (v) => Deno.inspect(v, { colors: true, depth: 4 }),
+      readFile: (p) => Deno.readFileSync(p),
+      writeOut: (s) => Deno.stdout.writeSync(ENC.encode(s)),
+      writeErr: (s) => Deno.stderr.writeSync(ENC.encode(s)),
+      readStdinLine: () => readLine(() => (Deno.stdin.readSync(stdinBuf) ? stdinBuf[0] : null)),
+    };
+  }
+  const util = await import("node:util");
+  const fs = await import("node:fs");
+  const buf = Buffer.alloc(1);
+  return {
+    inspect: (v) => util.inspect(v, { colors: true, depth: 4 }),
+    readFile: (p) => fs.readFileSync(p),
+    writeOut: (s) => process.stdout.write(s),
+    writeErr: (s) => process.stderr.write(s),
+    readStdinLine: () =>
+      readLine(() => {
+        for (;;) {
+          try {
+            return fs.readSync(0, buf, 0, 1, null) === 1 ? buf[0] : null;
+          } catch (err) {
+            if (err.code !== "EAGAIN") throw err;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+          }
+        }
+      }),
+  };
+}
+
+function readLine(nextByte) {
+  const bytes = [];
+  for (;;) {
+    const byte = nextByte();
+    if (byte === null) return bytes.length ? new TextDecoder().decode(new Uint8Array(bytes)) : null;
+    if (byte === 0x0a) return new TextDecoder().decode(new Uint8Array(bytes));
+    bytes.push(byte);
+  }
+}