@volter/tabnode 0.4.1 → 0.5.1

package/src/node-lib/binding/tty_wrap.ts

@@ -9,12 +9,56 @@
  * when the running program's own `process.stdout.isTTY` says so -- which is
  * what a held run gets, and what a program reads to decide on colour.
  */
-import { LibuvStreamWrap } from './stream_wrap';
-import { guessHandleTypeOfFd } from './fds';
+import { LibuvStreamWrap, type WriteWrap } from './stream_wrap';
+import { guessHandleTypeOfFd, handleForFd, registerFd, releaseFd } from './fds';
+import { UV_EBADF, UV_EIO, UV_ENOTSUP } from './uv';
+
+export interface TerminalState {
+  columns: number;
+  rows: number;
+  onResize(listener: (columns: number, rows: number) => void): () => void;
+  resize(columns: number, rows: number): void;
+}
+
+/** One terminal endpoint, shared by independently owned descriptors. */
+class TerminalEndpoint {
+  readonly descriptors = new Set<TTY>();
+  readonly readers = new Set<TTY>();
+  readonly input: Uint8Array[] = [];
+  peer?: TerminalEndpoint;
+  eof = false;
+  scheduled = false;
+  constructor(readonly terminal: TerminalState, readonly slave: boolean) {}
+  pump(): void {
+    if (this.scheduled) return;
+    this.scheduled = true;
+    queueMicrotask(() => {
+      this.scheduled = false;
+      while (this.input.length) {
+        const reader = [...this.readers].find(handle => handle.reading && !handle.closed && !handle.descriptor.closed);
+        if (!reader) return;
+        reader.deliver(this.input.shift()!);
+      }
+      if (this.eof) for (const reader of this.readers) reader.receiveEof();
+    });
+  }
+  release(descriptor: TTY): void {
+    this.descriptors.delete(descriptor);
+    if (this.descriptors.size || !this.peer) return;
+    this.peer.eof = true;
+    this.peer.pump();
+    this.input.length = 0;
+  }
+}
+
 
 /** libuv's `uv_tty_t`, over the same stream the rest of the binding is. */
 export class TTY extends LibuvStreamWrap {
-  readonly fdNumber: number;
+  get fdNumber(): number { return this.fd; }
+  readonly descriptor: TTY;
+  private endpoint?: TerminalEndpoint;
+  get terminal(): TerminalState | undefined { return this.endpoint?.terminal; }
+  get slave(): boolean { return this.endpoint?.slave === true; }
 
   /**
    * Node's `new TTY(fd, ctx)` writes an errno onto `ctx` when the fd is not
@@ -24,8 +68,11 @@ export class TTY extends LibuvStreamWrap {
    */
   constructor(fd: number, ctx?: { code?: string } | boolean) {
     super();
-    this.fdNumber = fd;
     this.fd = fd;
+    const held = handleForFd(fd);
+    this.descriptor = held instanceof TTY ? held.descriptor : this;
+    this.endpoint = held instanceof TTY ? held.endpoint : undefined;
+    this.endpoint?.readers.add(this);
     if (ctx && typeof ctx === 'object' && !isTTY(fd)) {
       ctx.code = 'ENOTTY';
     }
@@ -33,16 +80,96 @@ export class TTY extends LibuvStreamWrap {
 
   /** A terminal the engine does not own has one size and no mode to set. */
   getWindowSize(out: number[]): number {
-    out[0] = 80;
-    out[1] = 24;
+    out[0] = this.terminal?.columns ?? 80;
+    out[1] = this.terminal?.rows ?? 24;
     return 0;
   }
 
   setRawMode(_raw: number): number {
-    return 0;
+    // ADR-0023: this host has no termios. Do not claim a mode change.
+    return this.endpoint ? UV_ENOTSUP : 0;
+  }
+
+  static allocate(endpoint: TerminalEndpoint): TTY {
+    const handle = new TTY(-1);
+    handle.endpoint = endpoint;
+    handle.fd = registerFd('TTY', handle);
+    endpoint.descriptors.add(handle);
+    endpoint.readers.add(handle);
+    return handle;
+  }
+
+  /** Inheritance duplicates the fd; neither process owns the other's ref. */
+  duplicate(): TTY {
+    if (!this.endpoint || this.closed || this.descriptor.closed) throw Object.assign(new Error('Bad terminal descriptor'), { code: 'EBADF' });
+    return TTY.allocate(this.endpoint);
+  }
+
+  readStart(): number {
+    if (this.descriptor.closed) return UV_EBADF;
+    const result = super.readStart();
+    this.endpoint?.pump();
+    return result;
+  }
+
+  /** Delivered into Node's existing stream binding, preserving backpressure. */
+  deliver(bytes: Uint8Array): void { this.receive(bytes); this.flushInbound(); }
+
+  protected dispatchWrite(req: WriteWrap, bytes: Uint8Array): number {
+    if (!this.endpoint) return super.dispatchWrite(req, bytes);
+    if (this.closed || this.descriptor.closed) return UV_EBADF;
+    if (!this.endpoint.peer?.descriptors.size) return UV_EIO;
+    // Let the base binding set Node's synchronous-write accounting, while
+    // the shared endpoint, rather than a replaceable handle, owns the bytes.
+    const status = super.dispatchWrite(req, bytes);
+    if (bytes.byteLength) this.endpoint.peer.input.push(bytes.slice());
+    this.endpoint.peer.pump();
+    return status;
+  }
+
+  protected onCloseHandle(): void {
+    this.endpoint?.readers.delete(this);
+    if (this.descriptor !== this) { this.descriptor.close(); return; }
+    releaseFd(this.fd);
+    this.endpoint?.release(this);
+    for (const reader of this.endpoint?.readers ?? []) {
+      if (reader.descriptor === this) reader.close();
+    }
   }
 }
 
+/** Host OS adapter door. The process host retains terminal behavior. */
+export function openPty(columns: number, rows: number): { master: number; slave: number; pty: string } {
+  validSize(columns, rows);
+  const listeners = new Set<(columns: number, rows: number) => void>();
+  const terminal: TerminalState = {
+    columns, rows,
+    onResize(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
+    resize(columns, rows) {
+      validSize(columns, rows);
+      this.columns = columns; this.rows = rows;
+      for (const listener of listeners) listener(columns, rows);
+    },
+  };
+  const master = new TerminalEndpoint(terminal, false);
+  const slave = new TerminalEndpoint(terminal, true);
+  master.peer = slave; slave.peer = master;
+  const masterFd = TTY.allocate(master).fd;
+  const slaveFd = TTY.allocate(slave).fd;
+  return { master: masterFd, slave: slaveFd, pty: `/dev/pts/${slaveFd}` };
+}
+
+function validSize(columns: number, rows: number): void {
+  if (![columns, rows].every(value => Number.isInteger(value) && value > 0)) throw Object.assign(new Error('Invalid terminal size'), { code: 'EINVAL' });
+}
+
+export function resizePty(fd: number, columns: number, rows: number): void {
+  const terminal = handleForFd(fd);
+  if (!(terminal instanceof TTY) || terminal.closed) throw Object.assign(new Error('Bad terminal descriptor'), { code: 'EBADF' });
+  terminal.terminal?.resize(columns, rows);
+}
+
+
 /** libuv's `uv_guess_handle(fd) === UV_TTY`, as the running program sees it. */
 export function isTTY(fd: number): boolean {
   if (fd !== 0 && fd !== 1 && fd !== 2) return guessHandleTypeOfFd(fd) === 'TTY';
@@ -53,4 +180,4 @@ export function isTTY(fd: number): boolean {
   return stream?.isTTY === true;
 }
 
-export default { TTY, isTTY };
+export default { TTY, isTTY, openPty, resizePty };

package/src/node-lib/binding/util.ts

@@ -152,21 +152,7 @@ export const utilBinding = {
    * the module the first time it is read, so a builtin that exposes another
    * builtin's class does not load it to say so.
    */
-  defineLazyProperties: (target: object, id: string, keys: string[], writable = true): void => {
-    for (const key of keys) {
-      let built: unknown;
-      let ready = false;
-      Object.defineProperty(target, key, {
-        configurable: true,
-        enumerable: true,
-        get() {
-          if (!ready) { ready = true; built = (nodeLibInternalRequire(id) as Record<string, unknown>)[key]; }
-          return built;
-        },
-        set: writable ? (value: unknown) => { built = value; ready = true; } : void 0,
-      });
-    }
-  },
+  defineLazyProperties: lazyProperties(nodeLibInternalRequire),
 
   /**
    * The stack, as `util.getCallSites()` reports it: one entry per frame with
@@ -272,3 +258,26 @@ export const utilBinding = {
 };
 
 export default utilBinding;
+
+function lazyProperties(require: (name: string) => unknown) {
+  return (target: object, id: string, keys: string[], writable = true): void => {
+    for (const key of keys) {
+      let built: unknown;
+      let ready = false;
+      Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        get() {
+          if (!ready) { ready = true; built = (require(id) as Record<string, unknown>)[key]; }
+          return built;
+        },
+        set: writable ? (value: unknown) => { built = value; ready = true; } : void 0,
+      });
+    }
+  };
+}
+
+/** Lazy builtin exports must resolve inside the requesting process. */
+export function createUtilBinding(require: (name: string) => unknown) {
+  return { ...utilBinding, defineLazyProperties: lazyProperties(require) };
+}

package/src/node-lib/binding/uv.ts

@@ -93,10 +93,14 @@ export const UV_ENOTCONN = codes.UV_ENOTCONN[0];
 export const UV_ECANCELED = codes.UV_ECANCELED[0];
 export const UV_ENOTSUP = codes.UV_ENOTSUP[0];
 export const UV_EBADF = codes.UV_EBADF[0];
+export const UV_EIO = codes.UV_EIO[0];
 export const UV_ENOSYS = codes.UV_ENOSYS[0];
 export const UV_EADDRNOTAVAIL = codes.UV_EADDRNOTAVAIL[0];
 export const UV_EACCES = codes.UV_EACCES[0];
 export const UV_ENOBUFS = codes.UV_ENOBUFS[0];
+export const UV_EMFILE = codes.UV_EMFILE[0];
+export const UV_EBUSY = codes.UV_EBUSY[0];
+export const UV_EALREADY = codes.UV_EALREADY[0];
 export const UV_ESRCH = codes.UV_ESRCH[0];
 
 export default uvBinding;

package/src/node-lib/fs-module.ts

@@ -19,25 +19,9 @@ import { loadNodeLibFor } from './load';
 export const fsModule = lazyModule<Record<string, unknown>>('fs');
 export const fsPromisesModule = lazyModule<Record<string, unknown>>('internal/fs/promises');
 
-/**
- * `require('fs')` for one guest process. The first process in the realm is
- * handed the already-built module; a later process gets a file compiled for
- * it, so a tag on the module object is that process's.
- */
-const byProcess = new WeakMap<object, unknown>();
-let firstProcess: object | null = null;
+/** Every guest, including the first, owns its builtin graph. */
 export function fsModuleFor(process: object): unknown {
-  const held = byProcess.get(process);
-  if (held !== undefined) return held;
-  let module: unknown;
-  if (firstProcess === null || firstProcess === process) {
-    firstProcess = process;
-    module = fsModule;
-  } else {
-    module = loadNodeLibFor(process, 'fs');
-  }
-  byProcess.set(process, module);
-  return module;
+  return loadNodeLibFor(process, 'fs');
 }
 
 export default fsModule;

package/src/node-lib/internal/navigator.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const {
+  ObjectDefineProperties,
+  ObjectFreeze,
+  StringPrototypeIndexOf,
+  StringPrototypeSlice,
+  StringPrototypeToUpperCase,
+  Symbol,
+} = primordials;
+
+const {
+  ERR_ILLEGAL_CONSTRUCTOR,
+} = require('internal/errors').codes;
+
+const {
+  kEnumerableProperty,
+} = require('internal/util');
+
+const {
+  getAvailableParallelism,
+} = internalBinding('os');
+
+const kInitialize = Symbol('kInitialize');
+
+const {
+  platform,
+  arch,
+  version: nodeVersion,
+} = require('internal/process/per_thread');
+
+const {
+  getDefaultLocale,
+} = internalBinding('config');
+
+/**
+ * @param {string} arch
+ * @param {string} platform
+ * @returns {string}
+ */
+function getNavigatorPlatform(arch, platform) {
+  if (platform === 'darwin') {
+    // On macOS, modern browsers return 'MacIntel' even if running on Apple Silicon.
+    return 'MacIntel';
+  } else if (platform === 'win32') {
+    // On Windows, modern browsers return 'Win32' even if running on a 64-bit version of Windows.
+    // https://developer.mozilla.org/en-US/docs/Web/API/Navigator/platform#usage_notes
+    return 'Win32';
+  } else if (platform === 'linux') {
+    if (arch === 'ia32') {
+      return 'Linux i686';
+    } else if (arch === 'x64') {
+      return 'Linux x86_64';
+    }
+    return `Linux ${arch}`;
+  } else if (platform === 'freebsd') {
+    if (arch === 'ia32') {
+      return 'FreeBSD i386';
+    } else if (arch === 'x64') {
+      return 'FreeBSD amd64';
+    }
+    return `FreeBSD ${arch}`;
+  } else if (platform === 'openbsd') {
+    if (arch === 'ia32') {
+      return 'OpenBSD i386';
+    } else if (arch === 'x64') {
+      return 'OpenBSD amd64';
+    }
+    return `OpenBSD ${arch}`;
+  } else if (platform === 'sunos') {
+    if (arch === 'ia32') {
+      return 'SunOS i86pc';
+    }
+    return `SunOS ${arch}`;
+  } else if (platform === 'aix') {
+    return 'AIX';
+  }
+  return `${StringPrototypeToUpperCase(platform[0])}${StringPrototypeSlice(platform, 1)} ${arch}`;
+}
+
+class Navigator {
+  // Private properties are used to avoid brand validations.
+  #availableParallelism;
+  #userAgent;
+  #platform;
+  #languages;
+
+  constructor() {
+    if (arguments[0] === kInitialize) {
+      return;
+    }
+    throw new ERR_ILLEGAL_CONSTRUCTOR();
+  }
+
+  /**
+   * @return {number}
+   */
+  get hardwareConcurrency() {
+    this.#availableParallelism ??= getAvailableParallelism();
+    return this.#availableParallelism;
+  }
+
+  /**
+   * @return {string}
+   */
+  get language() {
+    // The default locale might be changed dynamically, so always invoke the
+    // binding.
+    return getDefaultLocale() || 'en-US';
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  get languages() {
+    this.#languages ??= ObjectFreeze([this.language]);
+    return this.#languages;
+  }
+
+  /**
+   * @return {string}
+   */
+  get userAgent() {
+    this.#userAgent ??= `Node.js/${StringPrototypeSlice(nodeVersion, 1, StringPrototypeIndexOf(nodeVersion, '.'))}`;
+    return this.#userAgent;
+  }
+
+  /**
+   * @return {string}
+   */
+  get platform() {
+    this.#platform ??= getNavigatorPlatform(arch, platform);
+    return this.#platform;
+  }
+}
+
+ObjectDefineProperties(Navigator.prototype, {
+  hardwareConcurrency: kEnumerableProperty,
+  language: kEnumerableProperty,
+  languages: kEnumerableProperty,
+  userAgent: kEnumerableProperty,
+  platform: kEnumerableProperty,
+});
+
+module.exports = {
+  getNavigatorPlatform,
+  navigator: new Navigator(kInitialize),
+  Navigator,
+};

package/src/node-lib/internals/buffer-and-streams.ts

@@ -118,26 +118,62 @@ export const internalFile = {
  */
 type AnyStream = Record<string, (...args: never[]) => unknown> & Record<string, unknown>;
 
+/** Capture the owning graph; callbacks must not fall back to the host loader. */
+export function createWebStreamsAdapters(require: (name: string) => unknown = libRequire) {
 function streamModule(): Record<string, new (options?: unknown) => AnyStream> {
-  return libRequire('stream') as Record<string, new (options?: unknown) => AnyStream>;
+  return require('stream') as Record<string, new (options?: unknown) => AnyStream>;
 }
 
-function newReadableStreamFromStreamReadable(readable: AnyStream): ReadableStream {
+function newReadableStreamFromStreamReadable(readable: AnyStream, options?: { strategy?: QueuingStrategy }): ReadableStream {
+  // Node v22.18's webstreams/adapters owns this boundary's semantics: pause
+  // at the Web queue's high-water mark, resume on pull, and let Node's own
+  // finished()/destroy() handle premature close and cancellation. The old
+  // adapter attached a flowing data listener with no pressure, buffering an
+  // entire HTTP upload while the host was still deciding whether to admit it.
+  const streams = require('stream') as {
+    finished(stream: AnyStream, callback: (error?: Error | null) => void): () => void;
+    destroy(stream: AnyStream, error?: unknown): void;
+  };
+  if (typeof readable?._readableState !== 'object') {
+    throw Object.assign(new TypeError('streamReadable must be a stream.Readable'), { code: 'ERR_INVALID_ARG_TYPE' });
+  }
+  if (readable.destroyed || (readable as Record<string, unknown>).readable === false) return new ReadableStream({ start(controller) { controller.close(); } });
+  const objectMode = Boolean(readable.readableObjectMode);
+  const highWaterMark = Number(readable.readableHighWaterMark);
+  const strategy = options?.strategy ?? (objectMode
+    ? new CountQueuingStrategy({ highWaterMark }) : new ByteLengthQueuingStrategy({ highWaterMark }));
+  let canceled = false;
+  let complete = false;
+  let controller: ReadableStreamDefaultController;
+  const on = readable.on as (event: string, listener: (...args: any[]) => void) => void;
+  const onData = (chunk: unknown): void => {
+    if (complete || canceled) return;
+    // Detach binary chunks from Node's reusable Buffer pool; retain objects.
+    controller.enqueue(!objectMode && chunk instanceof Uint8Array ? new Uint8Array(chunk) : chunk);
+    if ((controller.desiredSize ?? 0) <= 0) (readable.pause as () => void)();
+  };
+  (readable.pause as () => void)();
   return new ReadableStream({
-    start(controller) {
-      (readable.on as (e: string, l: (v: unknown) => void) => void)('data', (chunk) => {
-        controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(Buffer_from(chunk)));
+    start(output) {
+      controller = output;
+      const cleanup = streams.finished(readable, (error) => {
+        complete = true;
+        cleanup();
+        (readable.removeListener as (event: string, listener: (...args: any[]) => void) => void)('data', onData);
+        on.call(readable, 'error', () => {});
+        if (canceled) return;
+        if (error) controller.error(error); else controller.close();
       });
-      (readable.on as (e: string, l: () => void) => void)('end', () => { try { controller.close(); } catch { /* a stream closed twice is closed */ } });
-      (readable.on as (e: string, l: (v: unknown) => void) => void)('error', (error) => { try { controller.error(error); } catch { /* likewise */ } });
+      on.call(readable, 'data', onData);
     },
-    cancel() { (readable.destroy as () => void)(); },
-  });
+    pull() { if (!complete && !canceled) (readable.resume as () => void)(); },
+    cancel(reason) { canceled = true; streams.destroy(readable, reason); },
+  }, strategy);
 }
 
 /** The bytes of a chunk that is not already one, without importing `buffer` at load. */
 function Buffer_from(chunk: unknown): Uint8Array {
-  const { Buffer } = libRequire('buffer') as { Buffer: { from(value: unknown): Uint8Array } };
+  const { Buffer } = require('buffer') as { Buffer: { from(value: unknown): Uint8Array } };
   return Buffer.from(chunk);
 }
 
@@ -214,7 +250,7 @@ function newStreamDuplexFromReadableWritablePair(pair: { readable: ReadableStrea
   return duplex;
 }
 
-export const internalWebStreamsAdapters = {
+return {
   newReadableStreamFromStreamReadable,
   newStreamReadableFromReadableStream,
   newWritableStreamFromStreamWritable,
@@ -222,3 +258,6 @@ export const internalWebStreamsAdapters = {
   newReadableWritablePairFromDuplex,
   newStreamDuplexFromReadableWritablePair,
 };
+
+}
+export const internalWebStreamsAdapters = createWebStreamsAdapters();

package/src/node-lib/internals/events-util.ts

@@ -13,6 +13,11 @@ import { readlineModule as nodeLibPublicReadline } from './readline-access';
 /** `internal/console/global`: the realm's console, which `util.debuglog` logs through. */
 export const internalConsoleGlobal = new Proxy({} as Record<string, unknown>, {
   get: (_target, key) => Reflect.get(globalThis.console as unknown as object, key),
+  ownKeys: () => Reflect.ownKeys(globalThis.console),
+  getOwnPropertyDescriptor: (_target, key) => ({
+    configurable: true, enumerable: true,
+    get: () => Reflect.get(globalThis.console as unknown as object, key),
+  }),
 });
 
 /**

package/src/node-lib/internals/index.ts

@@ -23,14 +23,24 @@ import {
 import { internalSocketAddress, internalBlockList } from './addresses';
 import { internalFsUtils, internalDgram } from './child-process';
 import {
-  internalAbortController, internalBlob, internalFile, internalWebStreamsAdapters,
+  internalAbortController, internalBlob, internalFile, internalWebStreamsAdapters, createWebStreamsAdapters,
 } from './buffer-and-streams';
 import { internalBootstrapRealm, internalUrl, internalEncoding } from './modules';
 
 /** Built on the first ask, for the reason `./binding/index.ts` gives. */
 // eslint-disable-next-line no-var, vars-on-top
 var __table: Record<string, () => unknown> | undefined;
-export function nodeLibInternal(name: string): (() => unknown) | undefined {
+export function nodeLibInternal(name: string, require?: (name: string) => any, process?: any): (() => unknown) | undefined {
+  if (require && name === 'internal/webstreams/adapters') return () => createWebStreamsAdapters(require);
+  if (process && name === 'internal/process/per_thread') return () => ({
+    platform: process.platform, arch: process.arch, version: process.version,
+  });
+  if (process && name === 'internal/process/execution') return () => ({
+    tryGetCwd() { try { return process.cwd(); } catch { return ''; } },
+  });
+  if (process && name === 'internal/process/warning') return () => ({
+    emitWarningSync: (...args: unknown[]) => process.emitWarning(...args),
+  });
   __table ??= {
   'internal/util/types': () => internalUtilTypes,
   'internal/async_hooks': () => internalAsyncHooks,