@webjsdev/server 0.8.71 → 0.8.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/server",
-  "version": "0.8.71",
+  "version": "0.8.72",
   "type": "module",
   "description": "The server for WebJs, a full-stack JavaScript framework built on web components with server-side rendering and no build step. Provides the file-based router, SSR, server actions, route handlers, middleware, and live reload on Node 24+ or Bun.",
   "main": "index.js",

package/src/dev/server.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { strongerVerdict } from '../dev-classify.js';
-import { watch as fsWatch } from 'node:fs/promises';
+import { watchTree } from './watch-tree.js';
 import { relative } from 'node:path';
 import { createServer as createHttp1Server } from 'node:http';
 import { createRequestHandler } from './handler.js';
@@ -190,7 +190,7 @@ function startNodeListener(ctx) {
   // Catch-all process handlers: log, but don't tear the process down on a
   // single mishandled promise. Uncaught exceptions are different: state may be
   // corrupted, so log + start an orderly shutdown rather than continuing.
-  installProcessHandlers(logger, () => shutdown('uncaughtException', { fatal: true }));
+  installProcessHandlers(logger, () => shutdown('uncaughtException', { fatal: true }), { dev });
 
   return {
     server,
@@ -252,11 +252,12 @@ export async function startServer(opts) {
   /** @type {AbortController | null} */
   let watcherAbort = null;
   if (dev) {
-    // Watch the app root recursively via Node's built-in
-    // `fs.promises.watch`. Stable on macOS, Windows, and Linux as of
-    // Node 24. No external dep needed.
+    // Watch the app tree with Node's built-in `fs.watch` (no external dep):
+    // `watchTree` (#1521) watches the root plus each non-ignored top-level dir,
+    // so `node_modules` is never walked, and handles a per-path watch error
+    // (EACCES, ENOENT) with a warning instead of an uncaughtException.
     //
-    // fs.watch returns relative paths in event.filename. `shouldIgnoreWatchPath`
+    // Paths are reported relative to the watched root. `shouldIgnoreWatchPath`
     // (module-level, exported for tests) skips node_modules, .git, .webjs/, and
     // the SQLite dev DB (db/dev.db) + db/migrations so a file the dev server itself writes never loops.
     // Live-reload classification (#1398). Several files can change inside one
@@ -273,26 +274,32 @@ export async function startServer(opts) {
       app.rebuild(v || undefined);
     }, 80);
     watcherAbort = new AbortController();
-    const watchRoot = async (root) => {
-      try {
-        const events = fsWatch(root, { recursive: true, signal: watcherAbort.signal });
-        for await (const event of events) {
-          const filename = event.filename || '';
-          if (shouldIgnoreWatchPath(filename)) continue;
+    // One warning per unwatchable path (#1521): an EACCES / ENOENT on a single
+    // file must never stop the dev server, and a burst of the same temp file
+    // must not flood the log either.
+    const warned = new Set();
+    const onWatchError = (err) => {
+      const key = `${err && err.code}:${err && err.path}`;
+      if (warned.has(key) || warned.size > 200) return;
+      warned.add(key);
+      logger.warn(`file watcher skipped ${err && err.path ? err.path : 'a path'} (${err && err.code ? err.code : String(err)})`);
+    };
+    const watchRoot = (root) => {
+      const close = watchTree(root, {
+        ignore: shouldIgnoreWatchPath,
+        onEvent: (filename) => {
           // A regenerate output (#967) is a build product the server itself
           // writes on request; ignoring it stops a spurious rebuild + reload
           // (and a reload -> refetch -> recompile -> reload cycle), same as the
           // db/dev.db carve-out above. `app` exposes the check because `state`
           // lives in createRequestHandler's scope, not here.
-          if (app.isRegenerateOutput(filename)) continue;
+          if (app.isRegenerateOutput(filename)) return;
           pendingVerdict = strongerVerdict(pendingVerdict, app.classifyWatchPath(filename, root));
           rebuild();
-        }
-      } catch (err) {
-        if (err && /** @type any */(err).name !== 'AbortError') {
-          logger.warn({ err }, `file watcher exited (${root})`);
-        }
-      }
+        },
+        onError: onWatchError,
+      });
+      watcherAbort.signal.addEventListener('abort', close, { once: true });
     };
     watchRoot(app.appDir);
     // Extra roots the app reads from OUTSIDE its appDir (#894): repo-root content

package/src/dev/watch-tree.js

@@ -0,0 +1,104 @@
+import { watch, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * The dev live-reload watcher over one root (#1521).
+ *
+ * Two problems with the plain `fs.promises.watch(root, { recursive: true })`
+ * this replaces, both on Node 24's JS-implemented recursive watcher on Linux
+ * (`internal/fs/recursive_watch`), which opens one `fs.watch` per FILE:
+ *
+ * 1. A per-file failure (EACCES on a `sed -i` temp file another user created
+ *    with mode 0600, ENOENT on a file that vanished between the directory event
+ *    and the watch call) is emitted as `'error'` on an internal watcher the
+ *    promise API never listens to, so it surfaces as an uncaughtException and
+ *    the dev server shuts down. The callback form takes an `'error'` listener,
+ *    and the watcher keeps delivering events for every other file after it.
+ * 2. Watching the app ROOT walks `node_modules` too: about 10k per-file watches
+ *    and roughly 275ms of synchronous work on every boot of a scaffolded app,
+ *    all for events the ignore filter then drops. So the root is watched
+ *    non-recursively and each top-level directory that is not ignored gets its
+ *    own recursive watcher.
+ *
+ * A top-level directory created or removed after start is picked up from the
+ * root watcher's events, so `mkdir lib` mid-session is watched like it was
+ * there at boot.
+ *
+ * @param {string} root  absolute directory to watch
+ * @param {{
+ *   ignore: (relPath: string) => boolean,
+ *   onEvent: (relPath: string) => void,
+ *   onError: (err: NodeJS.ErrnoException) => void,
+ * }} opts  `relPath` is relative to `root`, with OS separators.
+ * @returns {() => void} closes every watcher
+ */
+export function watchTree(root, { ignore, onEvent, onError }) {
+  /** @type {Map<string, import('node:fs').FSWatcher>} */
+  const dirs = new Map();
+  let closed = false;
+
+  const guard = (/** @type {import('node:fs').FSWatcher} */ w) => {
+    w.on('error', (err) => onError(/** @type {NodeJS.ErrnoException} */ (err)));
+    return w;
+  };
+
+  const isDir = (name) => {
+    try { return statSync(join(root, name)).isDirectory(); } catch { return false; }
+  };
+
+  const watchDir = (name) => {
+    if (closed || dirs.has(name) || ignore(name)) return;
+    try {
+      const w = guard(watch(join(root, name), { recursive: true }, (_type, filename) => {
+        const rel = filename ? join(name, String(filename)) : name;
+        if (!ignore(rel)) onEvent(rel);
+      }));
+      dirs.set(name, w);
+    } catch (err) {
+      onError(/** @type {NodeJS.ErrnoException} */ (err));
+    }
+  };
+
+  /** @type {import('node:fs').FSWatcher | null} */
+  let top = null;
+  try {
+    top = guard(watch(root, (_type, filename) => {
+      if (!filename) return;
+      const name = String(filename);
+      if (ignore(name)) return;
+      // A top-level entry changed: start or stop following it as a directory.
+      if (isDir(name)) watchDir(name);
+      else if (dirs.has(name)) { try { dirs.get(name)?.close(); } catch {} dirs.delete(name); }
+      onEvent(name);
+    }));
+  } catch (err) {
+    onError(/** @type {NodeJS.ErrnoException} */ (err));
+  }
+
+  let entries = [];
+  try { entries = readdirSync(root, { withFileTypes: true }); } catch {}
+  for (const e of entries) {
+    if (e.isDirectory() || (e.isSymbolicLink() && isDir(e.name))) watchDir(e.name);
+  }
+
+  return () => {
+    closed = true;
+    try { top?.close(); } catch {}
+    for (const w of dirs.values()) { try { w.close(); } catch {} }
+    dirs.clear();
+  };
+}
+
+/**
+ * Whether an error came from a file watcher (#1521). Node marks every
+ * `fs.watch` failure with `syscall: 'watch'` (EACCES, EPERM, ENOENT, ELOOP, and
+ * ENOSPC when the inotify limit is reached). One unwatchable path is never a
+ * reason to stop a dev server, so the dev process handlers log these and keep
+ * serving.
+ *
+ * @param {unknown} err
+ * @returns {boolean}
+ */
+export function isWatchError(err) {
+  return !!err && typeof err === 'object' && /** @type {any} */ (err).syscall === 'watch';
+}

package/src/listener-bun.js

@@ -157,7 +157,7 @@ export function startBunListener(ctx) {
   const shutdown = makeShutdown({ closeServer, hub, logger });
   process.once('SIGINT', () => shutdown('SIGINT'));
   process.once('SIGTERM', () => shutdown('SIGTERM'));
-  installProcessHandlers(logger, () => shutdown('uncaughtException', { fatal: true }));
+  installProcessHandlers(logger, () => shutdown('uncaughtException', { fatal: true }), { dev });
 
   return {
     server,

package/src/listener-core.js

@@ -23,6 +23,7 @@ import {
 } from 'node:zlib';
 import { stripBasePath } from './base-path.js';
 import { randomUUID } from 'node:crypto';
+import { isWatchError } from './dev/watch-tree.js';
 
 /** The dev live-reload SSE path (matched after base-path stripping). */
 export const EVENTS_PATH = '/__webjs/events';
@@ -416,10 +417,18 @@ export class SseHub {
 /**
  * Install once-only process error handlers. Idempotent across multiple
  * `startServer` calls in the same process. Runtime-neutral (plain `process.on`).
+ *
+ * In dev, an uncaught file-watcher error (`syscall: 'watch'`, #1521) is logged
+ * as a warning and NOT fatal: one unreadable or vanished file in a watched dir
+ * says nothing about the server's state, and shutting down over it is how a
+ * `sed -i` from another user took a whole dev preview down. Prod keeps the
+ * strict contract, every uncaught exception is fatal.
+ *
  * @param {import('./logger.js').Logger} logger
  * @param {() => void} onFatal Starts the FATAL shutdown, which exits non-zero.
+ * @param {{ dev?: boolean }} [opts]
  */
-export function installProcessHandlers(logger, onFatal) {
+export function installProcessHandlers(logger, onFatal, { dev = false } = {}) {
   if (/** @type any */ (globalThis).__webjsProcHandlers) return;
   /** @type any */ (globalThis).__webjsProcHandlers = true;
   process.on('unhandledRejection', (reason) => {
@@ -428,6 +437,10 @@ export function installProcessHandlers(logger, onFatal) {
     });
   });
   process.on('uncaughtException', (err) => {
+    if (dev && isWatchError(err)) {
+      logger.warn(`file watcher skipped ${/** @type any */ (err).path || 'a path'} (${/** @type any */ (err).code || err.message})`);
+      return;
+    }
     logger.error('uncaughtException', { err: err.stack || err.message });
     // Begin orderly shutdown; process state may be corrupt.
     try { onFatal(); } catch {}