@volter/tabnode 0.3.1 → 0.4.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/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

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),