@volter/tabnode 0.3.0 → 0.4.0

package/dist/node-lib/binding/fs.d.ts

@@ -45,7 +45,7 @@ export declare class FSEvent {
     #private;
     onchange: ((status: number, event: string, filename: string) => void) | null;
     initialized: boolean;
-    start(path: unknown, _persistent?: boolean, recursive?: boolean, _encoding?: string): number;
+    start(path: unknown, persistent?: boolean, recursive?: boolean, _encoding?: string): number;
     close(): void;
     ref(): void;
     unref(): void;
@@ -95,11 +95,11 @@ export declare const fsBinding: {
     read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number, req?: FSReq): number | undefined;
     readBuffers(fd: number, buffers: Uint8Array[], position: number, req?: FSReq): number | undefined;
     /** Node's fast path for `readFile` with an encoding it can decode itself. */
-    readFileUtf8(path: unknown, _flags: number): string;
+    readFileUtf8(path: unknown, flags: number): string;
     writeBuffer(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, req?: FSReq): number | undefined;
     writeBuffers(fd: number, buffers: Uint8Array[], position: number | null, req?: FSReq): number | undefined;
     writeString(fd: number, value: string, position: number | null, encoding: string | undefined, req?: FSReq): number | undefined;
-    writeFileUtf8(path: unknown, data: string, flags: number, _mode: number): undefined;
+    writeFileUtf8(path: unknown, data: string, flags: number, mode: number): undefined;
     stat(path: unknown, bigint: boolean, req?: FSReq, throwIfNoEntry?: boolean): Float64Array | BigInt64Array | undefined;
     lstat(path: unknown, bigint: boolean, req?: FSReq, throwIfNoEntry?: boolean): Float64Array | BigInt64Array | undefined;
     fstat(fd: number, bigint: boolean, req?: FSReq): Float64Array | BigInt64Array | undefined;
@@ -109,7 +109,7 @@ export declare const fsBinding: {
      * a disk: a block size, and a count no program can exhaust.
      */
     statfs(_path: unknown, bigint: boolean, req?: FSReq): Float64Array | BigInt64Array | undefined;
-    access(path: unknown, _mode: number, req?: FSReq): undefined;
+    access(path: unknown, mode: number, req?: FSReq): undefined;
     existsSync(path: unknown): boolean;
     /**
      * Node's `cpSync` asks this before it copies: a directory is not a file,
@@ -143,12 +143,12 @@ export declare const fsBinding: {
     mkdtemp(prefix: unknown, encoding: string, req?: FSReq): string | Uint8Array | undefined;
     chmod(path: unknown, mode: number, req?: FSReq): undefined;
     fchmod(fd: number, mode: number, req?: FSReq): undefined;
-    chown(path: unknown, _uid: number, _gid: number, req?: FSReq): undefined;
+    chown(_path: unknown, _uid: number, _gid: number, req?: FSReq): undefined;
     fchown(_fd: number, _uid: number, _gid: number, req?: FSReq): undefined;
     lchown(_path: unknown, _uid: number, _gid: number, req?: FSReq): undefined;
-    utimes(_path: unknown, _atime: number, _mtime: number, req?: FSReq): undefined;
-    futimes(_fd: number, _atime: number, _mtime: number, req?: FSReq): undefined;
-    lutimes(_path: unknown, _atime: number, _mtime: number, req?: FSReq): undefined;
+    utimes(path: unknown, atime: number, mtime: number, req?: FSReq): undefined;
+    futimes(fd: number, atime: number, mtime: number, req?: FSReq): undefined;
+    lutimes(path: unknown, atime: number, mtime: number, req?: FSReq): undefined;
     fsync(_fd: number, req?: FSReq): undefined;
     fdatasync(_fd: number, req?: FSReq): undefined;
     ftruncate(fd: number, length: number, req?: FSReq): undefined;

package/dist/server-bridge.d.ts

@@ -65,6 +65,7 @@ export declare class ServerBridge extends EventEmitter {
      * news comes from the net binding, because that is where a port is taken;
      * the engine's `http` is Node's own file and knows nothing of a page.
      */
+    private readonly guestServers;
     private watchGuestPorts;
     close(): void;
     /**

package/dist/shims/child_process.d.ts

@@ -32,6 +32,12 @@ type RunStdin = {
  * output went down the child's channel.
  */
 export interface RunStreams {
+    stdinStream?: AsyncIterable<Uint8Array>;
+    terminal?: {
+        columns: number;
+        rows: number;
+        onResize?: (listener: (columns: number, rows: number) => void) => () => void;
+    };
     onStdout?: (data: string) => void;
     onStderr?: (data: string) => void;
     signal?: AbortSignal;

package/dist/virtual-fs.d.ts

@@ -28,6 +28,7 @@ export interface FSNode {
     target?: string;
     children?: Map<string, FSNode>;
     mtime: number;
+    mode?: number;
     /**
      * When the file was last read. Node reports it apart from the write time
      * and `utimes` sets the two separately; this filesystem reported the write
@@ -154,6 +155,8 @@ export declare class VirtualFS {
     /**
      * Get stats for path
      */
+    chmodSync(path: string, mode: number): void;
+    utimesSync(path: string, atime: number | Date, mtime: number | Date): void;
     statSync(path: string): Stats;
     /**
      * lstatSync - same as statSync for our virtual FS (no symlinks)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -68,6 +68,8 @@ export interface RunOptions {
   env?: Record<string, string>;
   /** What the shell reads on stdin, so a builtin reads what was piped to it. */
   stdin?: string;
+  stdinStream?: AsyncIterable<Uint8Array>;
+  terminal?: { columns: number; rows: number; onResize?: (listener: (columns: number, rows: number) => void) => () => void };
   /** Callback for streaming stdout chunks as they arrive (for long-running commands like vitest watch) */
   onStdout?: (data: string) => void;
   /** Callback for streaming stderr chunks as they arrive */
@@ -168,6 +170,9 @@ export function createContainer(options?: ContainerOptions): {
         onStderr: runOptions?.onStderr,
         signal: runOptions?.signal,
         held: runOptions?.held === true,
+        stdinStream: runOptions?.stdinStream,
+        stdinOpen: runOptions?.stdinStream !== undefined,
+        terminal: runOptions?.terminal,
       });
 
       return new Promise((resolve) => {
@@ -180,7 +185,7 @@ export function createContainer(options?: ContainerOptions): {
           resolve({
             stdout: String(stdout),
             stderr: String(stderr),
-            exitCode: error ? (error.code ?? 1) : 0,
+            exitCode: runOptions?.signal?.aborted ? 143 : error ? (error.code ?? 1) : 0,
           });
         });
       });

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

@@ -28,6 +28,8 @@
  * own tree.
  */
 import { createNodeError as vfsError } from '../../virtual-fs';
+import { registerHandle, releaseHandle, refHandle, unrefHandle, handleHasRef, currentOwner } from './handles';
+import { enterRun } from '../../process-tokens';
 
 /**
  * An errno error, as the filesystem makes one. The tree's own maker knows the
@@ -51,8 +53,10 @@ function refuseLinks(syscall: string, path: string): never {
   );
 }
 
-/** Modes `chmod` has set, keyed by the path Node handed the binding. */
-const pathModes = new Map<string, number>();
+function unsupportedMetadata(syscall: string): never {
+  throw Object.assign(new Error(`ENOTSUP: filesystem does not support ${syscall}`), { code: 'ENOTSUP', syscall });
+}
+
 
 function treeHoldsLinks(): boolean {
   return (vfs() as VirtualFS & { holdsLinks?: boolean }).holdsLinks === true;
@@ -173,11 +177,10 @@ function statArray(stats: VfsStats, bigint: boolean, path?: string): Float64Arra
   // The tree keeps permissions but not the type bits; `Stats.isFile()` is
   // `mode & S_IFMT`, so the type the tree does know is put where Node looks.
   // `chmod` stores what it set; a path it has not touched keeps the tree's.
-  const stored = path !== undefined ? pathModes.get(path) : undefined;
-  const permissions = (stored !== undefined ? stored : Number(stats.mode ?? 0)) & 0o7777;
+  const permissions = Number(stats.mode ?? (stats.isDirectory?.() ? 0o755 : 0o644)) & 0o7777;
   const type = stats.isDirectory?.() ? S_IFDIR : stats.isSymbolicLink?.() ? S_IFLNK : S_IFREG;
   const values = [
-    Number(stats.dev ?? 0), type | (permissions || (type === S_IFDIR ? 0o755 : 0o644)), Number(stats.nlink ?? 1),
+    Number(stats.dev ?? 0), type | permissions, Number(stats.nlink ?? 1),
     Number(stats.uid ?? 0), Number(stats.gid ?? 0), Number(stats.rdev ?? 0),
     Number(stats.blksize ?? 4096), Number(stats.ino ?? 0), Number(stats.size ?? 0),
     Number(stats.blocks ?? Math.ceil(Number(stats.size ?? 0) / 512)),
@@ -366,16 +369,23 @@ export class FSEvent {
   #watcher: { close(): void } | null = null;
   initialized = false;
 
-  start(path: unknown, _persistent?: boolean, recursive?: boolean, _encoding?: string): number {
+  start(path: unknown, persistent?: boolean, recursive?: boolean, _encoding?: string): number {
     const name = asPath(path);
     const tree = vfs();
+    const cwd = callingCwd();
+    const owner = currentOwner();
     try {
       this.#watcher = tree.watch(name, { recursive: Boolean(recursive) }, ((event: string, filename: string | null) => {
         // libuv names a change `change` and a create or a remove `rename`,
         // which is what Node's `FSWatcher` turns into its own two events.
-        this.onchange?.(0, event === 'rename' ? 'rename' : 'change', filename ?? '');
+        const notify = () => withFilesystem(tree, () => withCwd(cwd, () =>
+          this.onchange?.(0, event === 'rename' ? 'rename' : 'change', filename ?? '')));
+        if (owner === null) notify();
+        else enterRun(owner, notify);
       }) as never) as unknown as { close(): void };
       this.initialized = true;
+      registerHandle(this);
+      if (persistent === false) unrefHandle(this);
       return 0;
     } catch (error) {
       const code = (error as { code?: string }).code;
@@ -384,15 +394,16 @@ export class FSEvent {
   }
 
   close(): void {
+    releaseHandle(this);
     this.initialized = false;
     try { this.#watcher?.close(); } catch { /* a watcher already closed is closed */ }
     this.#watcher = null;
   }
 
-  ref(): void {}
-  unref(): void {}
+  ref(): void { if (this.initialized) refHandle(this); }
+  unref(): void { unrefHandle(this); }
   getAsyncId(): number { return 0; }
-  hasRef(): boolean { return this.initialized; }
+  hasRef(): boolean { return this.initialized && handleHasRef(this); }
 }
 
 /**
@@ -466,9 +477,15 @@ export const fsBinding = {
       const tree = vfs();
       const bits = flagBits();
       const exists = tree.existsSync(name);
+      if (exists && ((flags & 3) !== 0 || (flags & (bits.create | bits.truncate | bits.append)) !== 0)) {
+        tree.accessSync(name, 2);
+      }
       if ((flags & bits.excl) !== 0 && (flags & bits.create) !== 0 && exists) throw createNodeError('EEXIST', 'open', name);
       if (!exists) {
         if ((flags & bits.create) === 0) throw createNodeError('ENOENT', 'open', name);
+        // VirtualFS writes create parents for image loading; open(2) does not.
+        const parent = name.slice(0, name.lastIndexOf('/')) || '/';
+        if (!tree.statSync(parent).isDirectory()) throw createNodeError('ENOTDIR', 'open', name);
         tree.writeFileSync(name, '');
       } else if ((flags & bits.truncate) !== 0) {
         tree.writeFileSync(name, '');
@@ -481,13 +498,14 @@ export const fsBinding = {
   },
 
   close(fd: number, req?: FSReq): undefined {
-    return answer(req, () => { openFiles.delete(fd); return undefined; });
+    return answer(req, () => { fileFor(fd); openFiles.delete(fd); return undefined; });
   },
 
   // ---- reading ------------------------------------------------------------
   read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number, req?: FSReq): number | undefined {
     return answer(req, () => {
       const file = fileFor(fd);
+      if ((file.flags & 3) === 1) throw createNodeError('EBADF', 'read', file.path);
       if (file.cached === undefined) file.cached = file.tree.readFileSync(file.path) as Uint8Array;
       const bytes = file.cached;
       const from = position === null || position === undefined || position < 0 ? file.position : position;
@@ -512,18 +530,27 @@ export const fsBinding = {
   },
 
   /** Node's fast path for `readFile` with an encoding it can decode itself. */
-  readFileUtf8(path: unknown, _flags: number): string {
-    return vfs().readFileSync(asPath(path), 'utf8') as string;
+  readFileUtf8(path: unknown, flags: number): string {
+    const owned = typeof path !== 'number';
+    const fd = owned ? fsBinding.open(path, flags, 0o666) as number : path as number;
+    try {
+      const file = fileFor(fd);
+      const bytes = new Uint8Array(file.tree.statSync(file.path).size);
+      const length = fsBinding.read(fd, bytes, 0, bytes.length, -1) as number;
+      return new TextDecoder().decode(bytes.subarray(0, length));
+    } finally { if (owned) fsBinding.close(fd); }
   },
 
   // ---- writing ------------------------------------------------------------
   writeBuffer(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, req?: FSReq): number | undefined {
     return answer(req, () => {
       const file = fileFor(fd);
+      if ((file.flags & 3) === 0) throw createNodeError('EBADF', 'write', file.path);
       const tree = file.tree;
       const slice = buffer.subarray(offset, offset + length);
       const existing = file.cached ?? (tree.existsSync(file.path) ? tree.readFileSync(file.path) as Uint8Array : new Uint8Array(0));
-      const at = position === null || position === undefined || position < 0 ? file.position : position;
+      const at = (file.flags & flagBits().append) !== 0 ? existing.length
+        : position === null || position === undefined || position < 0 ? file.position : position;
       const size = Math.max(existing.length, at + slice.length);
       const next = new Uint8Array(size);
       next.set(existing, 0);
@@ -553,15 +580,13 @@ export const fsBinding = {
     return fsBinding.writeBuffer(fd, bytes, 0, bytes.length, position ?? null, req);
   },
 
-  writeFileUtf8(path: unknown, data: string, flags: number, _mode: number): undefined {
-    const tree = vfs();
-    const name = asPath(path);
-    if ((flags & flagBits().append) !== 0 && tree.existsSync(name)) {
-      const existing = tree.readFileSync(name, 'utf8') as string;
-      tree.writeFileSync(name, existing + data);
-      return undefined;
-    }
-    tree.writeFileSync(name, data);
+  writeFileUtf8(path: unknown, data: string, flags: number, mode: number): undefined {
+    // Node's UTF-8 fast path accepts a path OR an already-open descriptor.
+    // Reuse open/write so flags, offsets and errors match the buffer path.
+    const owned = typeof path !== 'number';
+    const fd = owned ? fsBinding.open(path, flags, mode) as number : path as number;
+    try { fsBinding.writeString(fd, data, null, 'utf8'); }
+    finally { if (owned) fsBinding.close(fd); }
     return undefined;
   },
 
@@ -612,10 +637,10 @@ export const fsBinding = {
     });
   },
 
-  access(path: unknown, _mode: number, req?: FSReq): undefined {
+  access(path: unknown, mode: number, req?: FSReq): undefined {
     return answer(req, () => {
       const name = asPath(path);
-      if (!vfs().existsSync(name)) throw createNodeError('ENOENT', 'access', name);
+      vfs().accessSync(name, mode);
       return undefined;
     });
   },
@@ -726,13 +751,10 @@ export const fsBinding = {
       if (tree.existsSync(name)) {
         const stats = tree.statSync(name);
         if (!recursive || !stats.isDirectory()) throw createNodeError('EEXIST', 'mkdir', name);
-        const stored = pathModes.get(name);
-        if (stored !== undefined && (stored & 0o777) !== wanted) throw createNodeError('EEXIST', 'mkdir', name);
-        pathModes.set(name, wanted);
         return undefined;
       }
       tree.mkdirSync(name, { recursive });
-      pathModes.set(name, wanted);
+      tree.chmodSync(name, wanted);
       return undefined;
     });
   },
@@ -806,43 +828,39 @@ export const fsBinding = {
     });
   },
 
-  // ---- the calls a page's filesystem has nothing to do -------------------
-  // Ownership and times are a kernel's bookkeeping. Permissions `chmod` sets
-  // are kept here, because a program that sets a mode and stats it back must
-  // see what it set, and a missing path is ENOENT as Node's is.
+  // Metadata belongs to the filesystem, including a host's permission view.
+  // Never keep a realm-global mode table or bypass that view for descriptors.
   chmod(path: unknown, mode: number, req?: FSReq): undefined {
     return answer(req, () => {
       const name = asPath(path);
-      if (!vfs().existsSync(name)) throw createNodeError('ENOENT', 'chmod', name);
-      pathModes.set(name, mode & 0o7777);
+      vfs().chmodSync(name, mode);
       return undefined;
     });
   },
   fchmod(fd: number, mode: number, req?: FSReq): undefined {
     return answer(req, () => {
       const file = fileFor(fd);
-      pathModes.set(file.path, mode & 0o7777);
-      return undefined;
-    });
-  },
-  chown(path: unknown, _uid: number, _gid: number, req?: FSReq): undefined {
-    return answer(req, () => {
-      const name = asPath(path);
-      if (!vfs().existsSync(name)) throw createNodeError('ENOENT', 'chown', name);
+      file.tree.chmodSync(file.path, mode);
       return undefined;
     });
   },
-  fchown(_fd: number, _uid: number, _gid: number, req?: FSReq): undefined { return answer(req, () => undefined); },
-  lchown(_path: unknown, _uid: number, _gid: number, req?: FSReq): undefined { return answer(req, () => undefined); },
-  utimes(_path: unknown, _atime: number, _mtime: number, req?: FSReq): undefined { return answer(req, () => undefined); },
-  futimes(_fd: number, _atime: number, _mtime: number, req?: FSReq): undefined { return answer(req, () => undefined); },
-  lutimes(_path: unknown, _atime: number, _mtime: number, req?: FSReq): undefined { return answer(req, () => undefined); },
+  chown(_path: unknown, _uid: number, _gid: number, req?: FSReq): undefined { return answer(req, () => unsupportedMetadata('chown')); },
+  fchown(_fd: number, _uid: number, _gid: number, req?: FSReq): undefined { return answer(req, () => unsupportedMetadata('fchown')); },
+  lchown(_path: unknown, _uid: number, _gid: number, req?: FSReq): undefined { return answer(req, () => unsupportedMetadata('lchown')); },
+  utimes(path: unknown, atime: number, mtime: number, req?: FSReq): undefined { return answer(req, () => { vfs().utimesSync(asPath(path), new Date(atime * 1000), new Date(mtime * 1000)); return undefined; }); },
+  futimes(fd: number, atime: number, mtime: number, req?: FSReq): undefined { return answer(req, () => { const file = fileFor(fd); file.tree.utimesSync(file.path, new Date(atime * 1000), new Date(mtime * 1000)); return undefined; }); },
+  lutimes(path: unknown, atime: number, mtime: number, req?: FSReq): undefined { return answer(req, () => {
+    if (treeHoldsLinks()) return unsupportedMetadata('lutimes');
+    vfs().utimesSync(asPath(path), new Date(atime * 1000), new Date(mtime * 1000));
+    return undefined;
+  }); },
   fsync(_fd: number, req?: FSReq): undefined { return answer(req, () => undefined); },
   fdatasync(_fd: number, req?: FSReq): undefined { return answer(req, () => undefined); },
 
   ftruncate(fd: number, length: number, req?: FSReq): undefined {
     return answer(req, () => {
       const file = fileFor(fd);
+      if ((file.flags & 3) === 0) throw createNodeError('EBADF', 'ftruncate', file.path);
       const tree = file.tree;
       const bytes = file.cached ?? (tree.readFileSync(file.path) as Uint8Array);
       const next = new Uint8Array(length);

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

@@ -23,6 +23,8 @@ export interface OwnedHandle {
 }
 
 const owners = new Map<ProcessToken, Set<OwnedHandle>>();
+// Unref affects liveness, not ownership: exit must close unreferenced handles too.
+const allOwned = new Map<ProcessToken, Set<OwnedHandle>>();
 const heldBy = new WeakMap<OwnedHandle, ProcessToken | null>();
 const refHeld = new WeakSet<OwnedHandle>();
 /**
@@ -68,6 +70,12 @@ export function ownerOf(handle: OwnedHandle): ProcessToken | null {
 /** A new handle is the current run's, ref'd and active, as libuv's start. */
 export function registerHandle(handle: OwnedHandle): void {
   heldBy.set(handle, currentOwner());
+  const token = heldBy.get(handle);
+  if (token != null) {
+    let owned = allOwned.get(token);
+    if (!owned) { owned = new Set(); allOwned.set(token, owned); }
+    owned.add(handle);
+  }
   refHeld.add(handle);
   activeHandles.add(handle);
   hold(handle);
@@ -103,6 +111,12 @@ export function handleHasRef(handle: OwnedHandle): boolean {
 /** A closed handle holds nothing. */
 export function releaseHandle(handle: OwnedHandle): void {
   drop(handle);
+  const token = heldBy.get(handle);
+  if (token != null) {
+    const owned = allOwned.get(token);
+    owned?.delete(handle);
+    if (owned?.size === 0) allOwned.delete(token);
+  }
   heldBy.delete(handle);
   refHeld.delete(handle);
   activeHandles.delete(handle);
@@ -161,8 +175,9 @@ export function __releaseOwnedServers(token: ProcessToken, stopTimers = true, st
  * Called where the run's servers and timers are released.
  */
 export function __releaseOwnedHandles(token: ProcessToken): void {
-  const held = owners.get(token);
+  const held = allOwned.get(token);
   if (!held) return;
+  allOwned.delete(token);
   owners.delete(token);
   for (const handle of [...held]) {
     try { handle.close(); } catch { /* a handle already closed is already released */ }
@@ -182,6 +197,17 @@ export function __releaseOwnedHandles(token: ProcessToken): void {
 export function __adoptHandle(handle: OwnedHandle | null | undefined, token: ProcessToken | null): void {
   if (!handle) return;
   drop(handle);
+  const previous = heldBy.get(handle);
+  if (previous != null) {
+    const owned = allOwned.get(previous);
+    owned?.delete(handle);
+    if (owned?.size === 0) allOwned.delete(previous);
+  }
   heldBy.set(handle, token);
+  if (token !== null) {
+    let owned = allOwned.get(token);
+    if (!owned) { owned = new Set(); allOwned.set(token, owned); }
+    owned.add(handle);
+  }
   hold(handle);
 }

package/src/server-bridge.ts

@@ -417,16 +417,26 @@ export class ServerBridge extends EventEmitter {
    * news comes from the net binding, because that is where a port is taken;
    * the engine's `http` is Node's own file and knows nothing of a page.
    */
+  private readonly guestServers = new WeakSet<IVirtualServer>();
+
   private watchGuestPorts(): void {
     setPortWatchers(
       (port, address) => {
         if (this.servers.has(port)) return;
         const hostname = address || '0.0.0.0';
-        this.registerServer(guestListeningServer(port, hostname), port, hostname);
+        const server = guestListeningServer(port, hostname);
+        this.guestServers.add(server);
+        this.registerServer(server, port, hostname);
       },
       (port) => {
         const entry = this.servers.get(port);
-        if (entry && entry.server === null) this.unregisterServer(port);
+        // Closing a guest's listener releases its bridge port too. Guest
+        // registrations carry a request adapter now, not the old null sentinel;
+        // a host replacement on that port must still be left alone.
+        if (entry && (entry.server === null || this.guestServers.has(entry.server))) {
+          if (entry.server) entry.server.listening = false;
+          this.unregisterServer(port);
+        }
       },
     );
   }

package/src/shims/child_process.ts

@@ -127,6 +127,8 @@ type RunStdin = { emit: (event: string, ...args: unknown[]) => void; push: (chun
  * output went down the child's channel.
  */
 export interface RunStreams {
+  stdinStream?: AsyncIterable<Uint8Array>;
+  terminal?: { columns: number; rows: number; onResize?: (listener: (columns: number, rows: number) => void) => () => void };
   onStdout?: (data: string) => void;
   onStderr?: (data: string) => void;
   signal?: AbortSignal;
@@ -470,7 +472,7 @@ export function initChildProcess(vfs: VirtualFS): void {
       // open, as a pipe whose writer has not closed.
       stdin: typeof ctx.stdin === 'string' ? ctx.stdin : '',
       ...(streams?.held || streams?.stdinOpen ? { stdinHeld: true } : {}),
-      ...(streams?.held ? { tty: true } : {}),
+      ...(streams?.held || streams?.terminal ? { tty: true } : {}),
       // The numbers this run was started with, so the guest's `process.pid`
       // is the one its parent's handle carries.
       ...(runPid(runToken) ? { pid: runPid(runToken)!.pid, ppid: runPid(runToken)!.ppid } : {}),
@@ -541,12 +543,26 @@ export function initChildProcess(vfs: VirtualFS): void {
     // For long-running commands (watch mode), report as TTY so tools like
     // vitest set up interactive features (file watching, stdin commands). A
     // spawned child's stdio is a pipe, as Node's is, and gets none of this.
-    if (streams?.held) {
+    if (streams?.held || streams?.terminal) {
       proc.stdout.isTTY = true;
       proc.stderr.isTTY = true;
       proc.stdin.isTTY = true;
       proc.stdin.setRawMode = () => proc.stdin;
     }
+    const terminal = streams?.terminal;
+    const resize = (columns: number, rows: number): void => {
+      for (const stream of [proc.stdout, proc.stderr]) {
+        stream.columns = columns;
+        stream.rows = rows;
+        stream.emit('resize');
+      }
+    };
+    let stopResize: (() => void) | undefined;
+    let inputActive = true;
+    let inputIterator: AsyncIterator<Uint8Array> | undefined;
+    const readableInput = proc.stdin as unknown as { listenerCount(event: string): number; readableLength: number; readableHighWaterMark: number; readableFlowing: boolean | null; _readableState?: { reading?: boolean; needReadable?: boolean } };
+    const inputReading = () => readableInput.readableFlowing === true || readableInput._readableState?.reading === true
+      || readableInput._readableState?.needReadable === true || readableInput.listenerCount('data') > 0 || readableInput.listenerCount('readable') > 0;
 
     // A child started with a channel wires its own end of it before its
     // module runs, which is what `lib/internal/process/pre_execution.js` does
@@ -606,6 +622,41 @@ export function initChildProcess(vfs: VirtualFS): void {
     };
     const detachUncaught = __onUncaughtException(proc, onUncaughtException);
     try {
+    // The host's pipe delivers bytes after the entry has attached its reader.
+    // EOF closes that same run's stream, never the most recently started run.
+    if (streams?.stdinStream) {
+      inputIterator = streams.stdinStream[Symbol.asyncIterator]();
+      const input = inputIterator;
+      void (async () => {
+        const push = (chunk: Uint8Array | null) => {
+          if (runToken === null) proc.stdin.push(chunk);
+          else enterRun(runToken, () => proc.stdin.push(chunk));
+        };
+        try {
+          while (inputActive && !streams.signal?.aborted) {
+            // A pipe is read on demand. Bound queued bytes by the Readable's
+            // high-water mark and do not pull a producer nobody consumes.
+            while (inputActive && !streams.signal?.aborted && (!inputReading()
+              || readableInput.readableLength >= readableInput.readableHighWaterMark)) {
+              await new Promise(resolve => (globalThis.__browserRuntimeNativeSetTimeout ?? setTimeout).call(globalThis, resolve, 10));
+            }
+            if (!inputActive || streams.signal?.aborted) break;
+            const next = await input.next();
+            if (next.done) break;
+            if (!inputActive || streams.signal?.aborted) break;
+            push(next.value);
+          }
+          if (inputActive && !streams.signal?.aborted) push(null);
+        } catch (error) {
+          if (inputActive) onUncaughtException(error);
+        } finally { streams.stdinOpen = false; }
+      })();
+    }
+    if (terminal) resize(terminal.columns, terminal.rows);
+    stopResize = terminal?.onResize?.((columns, rows) => {
+      if (runToken === null) resize(columns, rows);
+      else enterRun(runToken, () => resize(columns, rows));
+    });
 
     let entrySettling: Promise<unknown> | undefined;
     try {
@@ -676,7 +727,7 @@ export function initChildProcess(vfs: VirtualFS): void {
     // handle is one socket back to the server that forked it and which sets no
     // timer — as idle, with exit 0, three times over.
     const __ownsHandles = () => runToken !== null && (__ownedServerPorts(runToken).length > 0 || __ownedHandleCount(runToken) > 0);
-    const __printedThenWorking = () => pendingGuestTimers(proc) > 0 || heldWork().count > 0 || __ownsHandles();
+    const __printedThenWorking = () => (streams?.stdinOpen === true && inputReading()) || pendingGuestTimers(proc) > 0 || heldWork().count > 0 || __ownsHandles();
     if ((stdout.length > 0 || stderr.length > 0) && !__printedThenWorking()) {
       // Settling the command is host work. Killing guest timers must not
       // cancel this continuation and leave the command's promise unresolved.
@@ -725,7 +776,7 @@ export function initChildProcess(vfs: VirtualFS): void {
       let idleMs = 0;
       // A timer the guest still holds is work in Node's loop, whether or not
       // the program has printed; so is a handle it has open.
-      const stillWorking = (): boolean => pendingGuestTimers(proc) > 0 || __ownsHandles();
+      const stillWorking = (): boolean => (streams?.stdinOpen === true && inputReading()) || pendingGuestTimers(proc) > 0 || __ownsHandles();
 
       // When an abort signal is present (e.g. watch mode), don't apply idle timeout —
       // only exit when aborted or process.exit is called.
@@ -787,6 +838,9 @@ export function initChildProcess(vfs: VirtualFS): void {
     } finally {
       detachRejections();
       detachUncaught();
+      inputActive = false;
+      try { void Promise.resolve(inputIterator?.return?.()).catch(() => {}); } catch { /* producer cleanup cannot prevent process cleanup */ }
+      try { stopResize?.(); } catch { /* host cleanup cannot prevent handle release */ }
       // A process that ends releases its listening sockets, whatever ended it:
       // a return from the entry, a throw, an exit. Only `process.exit` released
       // them here, so `vite --host` — which opened 5173 and then died at startup