@volter/tabnode 0.3.1 → 0.4.1

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.1",
+  "version": "0.4.1",
   "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,6 +477,9 @@ 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);
@@ -623,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;
     });
   },
@@ -737,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;
     });
   },
@@ -817,37 +828,32 @@ 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);
+      file.tree.chmodSync(file.path, mode);
       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);
-      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); },
 

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/node-lib/binding/process_wrap.ts

@@ -25,9 +25,9 @@ import { Pipe, constants as pipeConstants } from './pipe_wrap';
 import { UV_ENOENT, UV_ESRCH } from './uv';
 import {
   registerHandle, refHandle, unrefHandle, handleHasRef, releaseHandle, __adoptHandle,
-  type OwnedHandle,
+  ownerOf, type OwnedHandle,
 } from './handles';
-import type { ProcessToken } from '../../process-tokens';
+import { __runFor, type ProcessToken } from '../../process-tokens';
 
 /** One entry of Node's `options.stdio`, as `getValidStdio` builds it. */
 export interface StdioEntry {
@@ -154,18 +154,31 @@ function signalNameOf(signal: number | string): string {
  * `/work` means `/work/child.js`, and resolved against the engine's shell's
  * own root it meant `/child.js` and a child that exited 1.
  */
-function spawningDirectory(): string | undefined {
-  const realm = (globalThis as unknown as { process?: { cwd?: () => string } }).process;
+// A shared realm's process global is whichever guest ran last. The spawning
+// handle belongs to the parent: inherited stdio and cwd must come from that
+// parent's process, even while a sibling starts or exits. A failed fork was
+// replaying stderr into its own closed IPC-backed stream (write EBADF).
+function parentProcess(token: ProcessToken | null) {
+  return token !== null ? __runFor(token)?.process
+    : (globalThis as unknown as { process?: { cwd?: () => string; stdout?: { write(text: string): unknown }; stderr?: { write(text: string): unknown } } }).process;
+}
+
+function spawningDirectory(token: ProcessToken | null): string | undefined {
+  const realm = parentProcess(token);
   if (typeof realm?.cwd !== 'function') return undefined;
   try { return realm.cwd(); } catch { return undefined; }
 }
 
 /** Where an `inherit` entry's bytes go: the spawning program's own stream. */
-function inheritedWriter(fd: number): ((text: string) => void) | null {
+function inheritedWriter(fd: number, token: ProcessToken | null): ((text: string) => void) | null {
   if (fd !== 1 && fd !== 2) return null;
-  const realm = (globalThis as unknown as {
-    process?: { stdout?: { write(text: string): unknown }; stderr?: { write(text: string): unknown } };
-  }).process;
+  // Inherit the descriptor's original sink, not a guest replacement of
+  // process.stderr.write (a child commonly redirects its console over IPC).
+  if (token !== null) {
+    const parent = __runFor(token);
+    return (fd === 1 ? parent?.stdout : parent?.stderr) ?? null;
+  }
+  const realm = parentProcess(token);
   const stream = fd === 1 ? realm?.stdout : realm?.stderr;
   if (!stream || typeof stream.write !== 'function') return null;
   return (text: string) => {
@@ -230,7 +243,7 @@ export class Process implements OwnedHandle {
     const request: RunRequest = {
       file: options.file,
       args: options.args ?? [options.file],
-      cwd: options.cwd ?? spawningDirectory(),
+      cwd: options.cwd ?? spawningDirectory(ownerOf(this)),
       env,
       detached: options.detached === true,
       stdout: null,
@@ -270,7 +283,7 @@ export class Process implements OwnedHandle {
           request.stderrIsPipe = true;
         }
       } else if (entry.type === 'inherit' || entry.type === 'fd') {
-        const inherited = inheritedWriter(entry.fd ?? index);
+        const inherited = inheritedWriter(entry.fd ?? index, ownerOf(this));
         if (index === 1) request.stdout = inherited;
         else request.stderr = inherited;
       }

package/src/process-tokens.ts

@@ -15,6 +15,7 @@
  * command gives its process has it removed.
  */
 
+import type { Process } from './shims/process';
 import { AsyncLocalStorage } from './shims/async_hooks';
 
 /** Whatever the embedding runtime uses to name one guest process. */
@@ -25,6 +26,10 @@ export const PROCESS_TOKEN_ENV = '__TABNODE_PROCESS_TOKEN';
 
 /** What the engine can answer about one named run. */
 export interface OwnedRun {
+  /** The guest whose cwd and inherited streams belong to this run. */
+  process: Process;
+  stdout(text: string): void;
+  stderr(text: string): void;
   /** The timers the run's guest still holds, as Node's loop counts them. */
   pendingTimers(): number;
   /** Clear those timers, as ending the process clears them. */

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 } : {}),
@@ -483,6 +485,9 @@ export function initChildProcess(vfs: VirtualFS): void {
     // whether a pid is a live process.
     if (runToken !== null) setRunPid(runToken, proc.pid, proc.ppid);
     const releaseRun = runToken === null ? null : __recordRun(runToken, {
+      process: proc,
+      stdout: appendStdout,
+      stderr: appendStderr,
       pendingTimers: () => pendingGuestTimers(proc),
       stopTimers: () => stopGuestTimers(proc),
       reportUncaught: (error: unknown) => __reportUncaughtException(proc, error),
@@ -541,12 +546,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 +625,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 +730,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 +779,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 +841,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

package/src/virtual-fs.ts

@@ -35,6 +35,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
@@ -470,6 +471,19 @@ export class VirtualFS {
   /**
    * Get stats for path
    */
+  chmodSync(path: string, mode: number): void {
+    const node = this.getNode(path);
+    if (!node) throw createNodeError('ENOENT', 'chmod', path);
+    node.mode = mode & 0o7777;
+  }
+
+  utimesSync(path: string, atime: number | Date, mtime: number | Date): void {
+    const node = this.getNode(path);
+    if (!node) throw createNodeError('ENOENT', 'utimes', path);
+    node.atime = atime instanceof Date ? atime.getTime() : atime * 1000;
+    node.mtime = mtime instanceof Date ? mtime.getTime() : mtime * 1000;
+  }
+
   statSync(path: string): Stats {
     const node = this.getNode(path);
     if (!node) {
@@ -489,7 +503,7 @@ export class VirtualFS {
       isFIFO: () => false,
       isSocket: () => false,
       size,
-      mode: node.type === 'directory' ? 0o755 : 0o644,
+      mode: node.mode ?? (node.type === 'directory' ? 0o755 : 0o644),
       mtime: new Date(mtime),
       atime: new Date(atime),
       ctime: new Date(mtime),