@webjsdev/cli 0.10.16 → 0.10.17

package/bin/webjs.js

@@ -4,6 +4,7 @@ import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { checkNodeInline, nodeInlineMessage } from '../lib/node-preflight.js';
 import { loadAppEnv, resolvePort } from '../lib/port.js';
+import { planDevSupervisor } from '../lib/dev-supervisor.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const [cmd, ...rest] = process.argv.slice(2);
@@ -39,7 +40,8 @@ if (cmd !== 'help' && cmd !== undefined) {
 const TEMPLATES = ['full-stack', 'api', 'saas'];
 
 const USAGE = `webjs commands:
-  webjs dev   [--port 8080]                       Start dev server with live reload
+  webjs dev   [--port 8080] [--no-hot]            Start dev server with live reload
+                                                  (--no-hot: run in-process, no hot-reload supervisor)
   webjs start [--port 8080]                       Start production server (serves source directly, no build step)
   webjs test  [--server|--browser]                 Run server + browser tests
   webjs check [--json]                            Run correctness checks on the app (--json emits structured violations)
@@ -83,7 +85,8 @@ async function main() {
   }
   switch (cmd) {
     case 'dev': {
-      // If we're already inside the --watch child, start the server directly.
+      // If we're already inside the reload child (node --watch or bun --hot),
+      // start the server directly.
       if (process.env.__WEBJS_DEV_CHILD === '1') {
         const { startServer } = await import('@webjsdev/server');
         // Load `.env` BEFORE resolving the port so a `PORT` set there is in
@@ -104,36 +107,31 @@ async function main() {
       const hint = prismaDevHint(process.cwd());
       if (hint) console.error(hint);
 
-      // Otherwise, spawn ourselves as a child with node --watch.
-      // This restarts the process on file changes, guaranteeing a fresh
-      // Node ESM module cache. Without this, edits to transitively-imported
-      // modules (actions, queries, components, utils) don't take effect
-      // because Node caches ESM by URL with no public invalidation API.
-      // Build watch paths from directories that exist in the project.
+      // Decide how to run: in-process (`--no-hot`), or re-exec'd under the host
+      // runtime's hot-reload supervisor (`node --watch` on Node, `bun --hot` on
+      // Bun, #514). The branch logic lives in the pure `planDevSupervisor` so it
+      // is unit-testable without spawning a process.
       const { existsSync } = await import('node:fs');
-      const watchPaths = [];
-      for (const dir of ['app', 'components', 'modules', 'lib', 'actions']) {
-        if (existsSync(dir)) watchPaths.push('--watch-path', dir);
-      }
-      // Watch root middleware/config if present
-      for (const f of ['middleware.ts', 'middleware.js']) {
-        if (existsSync(f)) watchPaths.push('--watch-path', f);
+      const plan = planDevSupervisor({
+        isBun: !!process.versions.bun,
+        argv: process.argv.slice(1),
+        noHot: rest.includes('--no-hot'),
+        exists: (p) => existsSync(p),
+      });
+
+      if (plan.mode === 'inline') {
+        const { startServer } = await import('@webjsdev/server');
+        loadAppEnv(process.cwd());
+        const port = resolvePort(flag(rest, '--port'));
+        await startServer({ appDir: process.cwd(), port, dev: true });
+        break;
       }
 
-      const child = spawn(
-        process.execPath,
-        [
-          '--watch',
-          '--watch-preserve-output',
-          ...watchPaths,
-          ...process.argv.slice(1),
-        ],
-        {
-          stdio: 'inherit',
-          cwd: process.cwd(),
-          env: { ...process.env, __WEBJS_DEV_CHILD: '1' },
-        },
-      );
+      const child = spawn(process.execPath, plan.args, {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+        env: { ...process.env, __WEBJS_DEV_CHILD: '1' },
+      });
       child.on('exit', (code) => process.exit(code ?? 0));
       break;
     }

package/lib/dev-supervisor.js

@@ -0,0 +1,61 @@
+/**
+ * Dev-server reload supervisor planning for `webjs dev` (issue #514).
+ *
+ * `webjs dev` re-execs itself under the host runtime's hot-reload supervisor so
+ * an edit to a transitively-imported module (an action, query, component, util)
+ * takes effect without a manual restart. Both runtimes cache ES modules by
+ * resolved URL with no public invalidation API, so the dev re-import in
+ * `@webjsdev/server`'s `dev.js` relies on the runtime's own file-watching cache
+ * invalidation:
+ *
+ * - **Node** has no in-place module-cache eviction, so it re-execs under
+ *   `node --watch`, which RESTARTS the process on a file change (a fresh ESM
+ *   cache each time). The dev re-import additionally appends a `?t=` cache-bust
+ *   query that Node honours between restarts.
+ * - **Bun** keys its module cache by path and IGNORES that `?t=` query, so the
+ *   `node --watch` model does not transfer: without help a re-imported module
+ *   stays STALE on Bun (the #514 bug). Bun's `--hot` invalidates loaded modules
+ *   on a file change WITHOUT restarting the process, which is exactly what the
+ *   dev re-import needs; `Bun.serve` is reused across hot reloads, so the
+ *   listener is not duplicated. `--hot` auto-watches every loaded file, so the
+ *   node `--watch-path` flags do not apply (and are not Bun flags).
+ *
+ * This pure planner returns the spawn decision so the bin stays a thin shell and
+ * the branch logic is unit-testable without spawning a process.
+ */
+
+/**
+ * Plan how `webjs dev` runs its server.
+ *
+ * @param {object} opts
+ * @param {boolean} opts.isBun  Whether the host runtime is Bun (`process.versions.bun`).
+ * @param {string[]} opts.argv  `process.argv.slice(1)` (the script path followed by its args), forwarded to the child verbatim.
+ * @param {boolean} opts.noHot  Whether `--no-hot` was passed (opt out of the supervisor entirely).
+ * @param {(path: string) => boolean} opts.exists  Existence check for the Node `--watch-path` targets (relative to cwd). Unused on Bun.
+ * @returns {{ mode: 'inline' } | { mode: 'spawn', args: string[] }}
+ *   `inline` runs the server in this process (no reload watcher); `spawn`
+ *   re-execs `process.execPath` with `args` and `__WEBJS_DEV_CHILD=1`.
+ */
+export function planDevSupervisor({ isBun, argv, noHot, exists }) {
+  // `--no-hot` opts out of the reload supervisor on either runtime: run the dev
+  // server in THIS process with no watcher. Degraded dev (a deep-import edit
+  // needs a manual restart) but useful under an external process manager or a
+  // debugger that wants a single, un-re-exec'd process.
+  if (noHot) return { mode: 'inline' };
+
+  if (isBun) return { mode: 'spawn', args: ['--hot', ...argv] };
+
+  // Node: re-exec under `node --watch`, watching the project dirs/files that
+  // exist. `--watch-preserve-output` keeps prior logs across a restart.
+  const watchPaths = [];
+  for (const dir of ['app', 'components', 'modules', 'lib', 'actions']) {
+    if (exists(dir)) watchPaths.push('--watch-path', dir);
+  }
+  for (const f of ['middleware.ts', 'middleware.js']) {
+    if (exists(f)) watchPaths.push('--watch-path', f);
+  }
+  return {
+    mode: 'spawn',
+    args: ['--watch', '--watch-preserve-output', ...watchPaths, ...argv],
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/cli",
-  "version": "0.10.16",
+  "version": "0.10.17",
   "type": "module",
   "description": "webjs CLI - dev, start, create, db",
   "bin": {