@webjsdev/server 0.8.83 → 0.8.85

package/src/dev/hot-host.js

@@ -0,0 +1,176 @@
+/**
+ * One dev server per process under `bun --hot` (#1575).
+ *
+ * `bun --hot` re-evaluates the entry module whenever a file it loaded changes,
+ * with a fresh module registry and `globalThis` preserved. For `webjs dev` the
+ * entry is the CLI, so every page, layout or component edit ran `startServer`
+ * again: a second request handler, a second set of file watchers, a second SSE
+ * hub, another `instrumentation.register()`, and both `Bun.plugin` hooks
+ * registered again. Nothing from the previous run was disposed, because nothing
+ * could reach it. Measured on the scaffold: about 25 MB more per edit, 5.8 GB
+ * after 225 edits, after which `bun --hot` stopped reloading at all and a
+ * component edit was never served again until a restart. A second instance also
+ * built its route table before its watchers existed, so a file added or renamed
+ * while it booted was invisible to the instance that ended up serving (a 404
+ * for a route that exists, an unknown action).
+ *
+ * So the first run owns the process: its listener, hub, watchers and request
+ * handler stay, and a later run only tells it the module registry was reset
+ * (`rerun`). The handler then re-derives its analysis on the next request,
+ * which re-imports the app's modules from the fresh registry. The framework's
+ * own code stays the first run's, so its caches stay warm. Mixing that code
+ * with app modules from a later registry is safe by design: core's type checks
+ * are structural (`_$webjs`) and its shared state is keyed by `Symbol.for`.
+ *
+ * The state lives on `globalThis` under a `Symbol.for` key because a re-run
+ * evaluates a NEW copy of this module, whose own module variables start empty.
+ *
+ * @module dev/hot-host
+ */
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { pathToFileURL } from 'node:url';
+
+const HOSTS = Symbol.for('webjs.dev.hotHosts');
+
+/**
+ * Sent to the `webjs dev` supervisor over IPC once the hot host is up, so it
+ * stops restarting the process for plugin-served edits this server now reloads
+ * in place. Mirrors `HOT_IN_PLACE_MESSAGE` in `@webjsdev/cli`'s `dev-reload.js`.
+ */
+export const HOT_IN_PLACE_MESSAGE = 'hot-reload-in-place';
+
+/** Tell the supervisor (when there is one) that edits reload in place. */
+export function announceHotInPlace() {
+  try {
+    if (typeof process.send === 'function' && process.connected) process.send({ webjs: HOT_IN_PLACE_MESSAGE });
+  } catch { /* no supervisor, or it is gone */ }
+}
+
+/**
+ * Whether this process re-runs its entry on a file change: Bun under `--hot`.
+ *
+ * @param {{ isBun?: boolean, execArgv?: string[] }} [env]
+ * @returns {boolean}
+ */
+export function hotRerunCapable({ isBun = !!process.versions.bun, execArgv = process.execArgv } = {}) {
+  return isBun && Array.isArray(execArgv) && execArgv.includes('--hot');
+}
+
+/**
+ * @typedef {{
+ *   version: string,
+ *   rerun: () => Promise<unknown>,
+ *   poke: () => void,
+ * }} HotHost
+ */
+
+/** @returns {Map<string, HotHost>} */
+function hosts() {
+  const g = /** @type {any} */ (globalThis);
+  if (!(g[HOSTS] instanceof Map)) g[HOSTS] = new Map();
+  return g[HOSTS];
+}
+
+/**
+ * The host key: one dev server per app directory and port.
+ * @param {string} appDir absolute
+ * @param {number} port
+ */
+export function hotHostKey(appDir, port) {
+  return `${appDir}\0${port}`;
+}
+
+/** @param {string} key @returns {HotHost | undefined} */
+export function getHotHost(key) {
+  return hosts().get(key);
+}
+
+/** @param {string} key @param {HotHost} host */
+export function setHotHost(key, host) {
+  hosts().set(key, host);
+}
+
+/** @param {string} key */
+export function deleteHotHost(key) {
+  hosts().delete(key);
+}
+
+/**
+ * The sentinel module that lets the dev server ask `bun --hot` for a re-run.
+ * `bun --hot` does not watch a module a `Bun.plugin` served (#1550), and in dev
+ * every app module is one (`*.server.*` through the seed plugin, the rest
+ * through `dev/bun-app-source.js`). A `*.server.*` edit used to restart the
+ * whole process, which dropped requests for 0.3 to 2 seconds. Writing this file
+ * instead re-runs the entry within milliseconds, which resets the registry.
+ *
+ * It lives in the OS temp dir, per process: inside the app it would match the
+ * app-source plugin's filter (and so not be watched) and the dev watcher.
+ *
+ * @param {string} appDir
+ * @returns {string} absolute path
+ */
+export function hotSentinelPath(appDir) {
+  const tag = createHash('sha1').update(appDir).digest('hex').slice(0, 12);
+  return join(tmpdir(), 'webjs-dev-hot', `${process.pid}-${tag}.mjs`);
+}
+
+/**
+ * Create (if needed) and import the sentinel so `bun --hot` watches it. A
+ * re-run's fresh registry imports (and so watches) it again.
+ *
+ * @param {string} appDir
+ * @returns {Promise<void>}
+ */
+export async function armHotSentinel(appDir) {
+  const file = hotSentinelPath(appDir);
+  try {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, 'export default 0;\n', { flag: 'wx' });
+  } catch { /* already there */ }
+  try { await import(pathToFileURL(file).href); } catch { /* best effort: without it a poke is a no-op */ }
+}
+
+/** Remove the sentinel (the server is closing). @param {string} appDir */
+export function removeHotSentinel(appDir) {
+  try { rmSync(hotSentinelPath(appDir), { force: true }); } catch { /* best effort */ }
+}
+
+/**
+ * Ask `bun --hot` for a re-run by changing the sentinel.
+ * @param {string} appDir
+ */
+export function pokeHotSentinel(appDir) {
+  try { writeFileSync(hotSentinelPath(appDir), `export default ${Date.now()};\n`); } catch { /* best effort */ }
+}
+
+const APP_MODULE = /\.m?[jt]s$/;
+/** Files no module imports at runtime: an edit to one never needs a registry reset. */
+const INERT_ASSET = /\.(?:css|md|mdx|txt|log|map|png|jpe?g|gif|webp|avif|ico|svg|woff2?|ttf|otf)$/i;
+
+/**
+ * Whether a changed path could leave a stale module in the registry, so the
+ * dev server has to ask `bun --hot` for a reset. In dev on Bun every JS/TS
+ * module of the app is served by a `Bun.plugin` (`*.server.*` through the seed
+ * plugin, the rest through `dev/bun-app-source.js` or the source-locations
+ * plugin), which `bun --hot` never watches.
+ *
+ * `isRouteOnly` answers whether a module path is one only the router loads
+ * (nothing imports it; see `needsRegistryReset` on the request handler): its
+ * dev re-import is keyed by content, so it needs no reset. Anything the
+ * dev server cannot place, such as the extensionless temp file `sed -i`
+ * renames over the real one, gets the reset, because the event may name the
+ * temp file rather than the module it replaced.
+ *
+ * @param {string} path  relative to the watched root
+ * @param {(path: string) => boolean} isRouteOnly
+ * @returns {boolean}
+ */
+export function needsHotReset(path, isRouteOnly) {
+  if (/(?:^|[\\/])node_modules[\\/]/.test(path)) return false;
+  if (INERT_ASSET.test(path)) return false;
+  if (APP_MODULE.test(path)) return !isRouteOnly(path);
+  return true;
+}

package/src/dev/serve.js

@@ -34,7 +34,7 @@ import { versionModuleImports, withAssetHash } from '../asset-hash.js';
 import { toUrlPath } from '../ssr/preloads.js';
 import { BUFFERED_MARKER } from '../conditional-get.js';
 import { MIME, TS_CACHE_MAX, exists, reloadClientJs, reloadWorkerJs } from './helpers.js';
-import { devImportSpecifier } from '../dev-import.js';
+import { devImport } from '../dev-import.js';
 import { runMetadataRoute } from '../metadata-routes.js';
 
 /**
@@ -573,7 +573,7 @@ export async function runWithSegmentMiddleware(req, files, terminal, dev) {
   const handlers = [];
   for (const f of files) {
     try {
-      const mod = await import(devImportSpecifier(f, dev));
+      const mod = await devImport(f, dev);
       if (typeof mod.default === 'function') handlers.push(mod.default);
     } catch {
       // Bad middleware file: skip; top-level error handler will catch real problems.
@@ -617,7 +617,7 @@ export async function loadMiddleware(appDir, dev, logger) {
   }
   if (!file) return null;
   try {
-    const mod = await import(devImportSpecifier(file, dev));
+    const mod = await devImport(file, dev);
     return typeof mod.default === 'function' ? mod.default : null;
   } catch (e) {
     logger.error('failed to load root middleware', { file, err: String(e) });

package/src/dev/server.js

@@ -1,7 +1,11 @@
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { strongerVerdict } from '../dev-classify.js';
 import { watchTree } from './watch-tree.js';
-import { relative } from 'node:path';
+import { relative, resolve } from 'node:path';
+import {
+  hotRerunCapable, hotHostKey, getHotHost, setHotHost, deleteHotHost,
+  armHotSentinel, pokeHotSentinel, removeHotSentinel, needsHotReset, announceHotInPlace,
+} from './hot-host.js';
 import { createServer as createHttp1Server } from 'node:http';
 import { createRequestHandler } from './handler.js';
 import { readServerTimeoutsFromApp, readDevWatchPathsFromApp } from './config.js';
@@ -15,6 +19,18 @@ import { attachWebSocket } from '../websocket.js';
 import { toWebRequest, sendWebResponse } from './helpers.js';
 import { isAddrInUse, portInUseError, reusePortRequested } from '../port-in-use.js';
 
+/** This copy of `@webjsdev/server`'s version, so a hot re-run can tell the framework itself changed. */
+const SERVER_VERSION = (() => {
+  try { return JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version || ''; } catch { return ''; }
+})();
+
+/**
+ * How long a poked re-run (#1575) may take before the dev server stops waiting
+ * for it and rebuilds anyway, so an edit is never lost to a sentinel `bun --hot`
+ * did not see.
+ */
+const POKE_FALLBACK_MS = 1500;
+
 function debounce(fn, ms) {
   let t;
   return (...args) => {
@@ -237,11 +253,29 @@ export async function startServer(opts) {
   const compress = opts.compress ?? !dev;
   const logger = opts.logger || defaultLogger({ dev });
 
+  // `bun --hot` re-runs the CLI, and so this function, on every edit to a
+  // module it loaded (#1575). The first run owns the process; a later one only
+  // tells it the module registry was reset. See dev/hot-host.js.
+  const hotKey = dev && hotRerunCapable() ? hotHostKey(resolve(opts.appDir), port) : null;
+  const host = hotKey ? getHotHost(hotKey) : undefined;
+  if (host) {
+    if (host.version !== SERVER_VERSION) {
+      // The framework itself changed under a running dev server (an upgrade).
+      // Its first-run code cannot load the new copy in place, so exit and let
+      // the `webjs dev` supervisor start a fresh process on the new version.
+      logger.warn(`[webjs] @webjsdev/server changed (${host.version || '?'} -> ${SERVER_VERSION || '?'}), restarting the dev server`);
+      if (process.env.__WEBJS_DEV_CHILD === '1') process.exit(0);
+    }
+    return /** @type {any} */ (await host.rerun());
+  }
+
   // Runtime-neutral SSE registry + fanout (shared by the node:http and Bun.serve
   // shells via listener-core.js, so live-reload + the dev error overlay behave
   // identically on both). Built before the handler so its onReload / onDevError
   // callbacks can fan out through it.
-  const hub = new SseHub();
+  // A Bun hot host, or a server outside the dev supervisor (`--no-hot`, an
+  // embedder), applies an edit in place; a supervised Node child is restarted.
+  const hub = new SseHub({ inPlace: dev && (!!hotKey || process.env.__WEBJS_DEV_CHILD !== '1') });
   // Pages render the stream's state into a meta tag (#1516), so the relay can
   // re-check a page against the server on every reconnect.
   if (dev) setDevReloadState(() => ({ boot: DEV_BOOT_ID, seq: hub.seq }));
@@ -263,6 +297,10 @@ export async function startServer(opts) {
 
   /** @type {AbortController | null} */
   let watcherAbort = null;
+  /** The strongest verdict of the edits a poked re-run has yet to apply. */
+  /** @type {import('../dev-classify.js').ReloadVerdict | null} */
+  let pokedVerdict = null;
+  /** @type {any} */ let pokeFallback = null;
   if (dev) {
     // 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,
@@ -273,18 +311,35 @@ export async function startServer(opts) {
     // (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
-    // 80ms debounce window, so hold the STRONGEST verdict of the window and
+    // 50ms debounce window (80ms before #1575), so hold the STRONGEST verdict of the window and
     // hand it to the rebuild. Same rule as the browser relay's cross-batch
     // accumulation, for the same reason: a window mixing a page edit and a
     // component edit is a component edit, and taking the last one would morph
     // fresh markup onto the old component class.
     /** @type {import('../dev-classify.js').ReloadVerdict | null} */
     let pendingVerdict = null;
+    // Under `bun --hot`, a window that changed a module a `Bun.plugin` serves
+    // pokes the re-run sentinel instead of rebuilding (#1575): the rebuild has
+    // to wait for the registry reset, or the next request would still import
+    // the stale module. The re-run (`hotRerun` below) rebuilds with the verdict.
+    let pendingPoke = false;
     const rebuild = debounce(() => {
       const v = pendingVerdict;
       pendingVerdict = null;
+      if (pendingPoke) {
+        pendingPoke = false;
+        pokedVerdict = strongerVerdict(pokedVerdict, v);
+        pokeHotSentinel(app.appDir);
+        clearTimeout(pokeFallback);
+        pokeFallback = setTimeout(() => {
+          const pv = pokedVerdict;
+          pokedVerdict = null;
+          if (pv) app.rebuild(pv);
+        }, POKE_FALLBACK_MS);
+        return;
+      }
       app.rebuild(v || undefined);
-    }, 80);
+    }, 50);
     watcherAbort = new AbortController();
     // 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
@@ -307,6 +362,7 @@ export async function startServer(opts) {
           // lives in createRequestHandler's scope, not here.
           if (app.isRegenerateOutput(filename)) return;
           pendingVerdict = strongerVerdict(pendingVerdict, app.classifyWatchPath(filename, root));
+          if (hotKey && needsHotReset(filename, (f) => !app.needsRegistryReset(f, root))) pendingPoke = true;
           rebuild();
         },
         onError: onWatchError,
@@ -341,11 +397,43 @@ export async function startServer(opts) {
   // req/s on the listening path (#511); the Bun shell is dynamically imported so
   // the `Bun.*` global is never referenced on Node.
   try {
+    /** @type {{ server: any, close: () => Promise<void> }} */
+    let handle;
     if (serverRuntime() === 'bun') {
       const { startBunListener } = await import('../listener-bun.js');
-      return startBunListener(ctx);
+      handle = startBunListener(ctx);
+    } else {
+      handle = await startNodeListener(ctx);
+    }
+    if (hotKey) {
+      // Own the process for every later `bun --hot` re-run (#1575).
+      await armHotSentinel(app.appDir);
+      const close = handle.close;
+      handle = { ...handle, close: () => { deleteHotHost(hotKey); removeHotSentinel(app.appDir); return close(); } };
+      const owned = handle;
+      setHotHost(hotKey, {
+        version: SERVER_VERSION,
+        /**
+         * The registry was reset: re-watch the sentinel from the fresh registry,
+         * then re-derive the analysis so it re-imports the app's modules (the
+         * middleware, the components it primes) from that registry. A re-run a
+         * poke asked for carries the verdict of the edits behind it and tells the
+         * browser; any other is silent, since the watcher already sent that
+         * edit's own reload frame.
+         */
+        rerun: async () => {
+          await armHotSentinel(app.appDir);
+          const pv = pokedVerdict;
+          pokedVerdict = null;
+          clearTimeout(pokeFallback);
+          await app.rebuild(pv || undefined, { notify: !!pv });
+          return owned;
+        },
+        poke: () => pokeHotSentinel(app.appDir),
+      });
+      announceHotInPlace();
     }
-    return await startNodeListener(ctx);
+    return handle;
   } catch (e) {
     // The listener never came up (a taken port, #1527): stop what was started
     // for it, so an embedding caller that catches this is not left with a

package/src/dev-import.js

@@ -2,13 +2,21 @@
  * The import specifier for a module the dev server re-imports on every request
  * (#1550): a page, layout, route handler, action module, middleware, and so on.
  *
- * In dev the specifier carries a fresh `?t=` query, so each request gets a new
- * module instance and a just-edited top-level file is served without waiting
- * for a restart. Node keys its ESM cache by the full file URL, query included.
- * Bun keys its cache by path and DROPS the query of a `file://` specifier, so
- * the same URL-plus-query is a silent no-op there: on Bun the query must ride a
- * plain absolute path, which Bun loads fresh (and hands to a `Bun.plugin`
- * `onLoad` with the query intact).
+ * In dev the specifier carries a `?t=` query naming the file's CONTENT (#1575),
+ * so a just-edited top-level file is served without waiting for a restart. Node
+ * keys its ESM cache by the full file URL, query included. Bun keys its cache by
+ * path and DROPS the query of a `file://` specifier, so the same URL-plus-query
+ * is a silent no-op there: on Bun the query must ride a plain absolute path,
+ * which Bun loads fresh (and hands to a `Bun.plugin` `onLoad` with the query
+ * intact).
+ *
+ * The query used to be random per call, which made every request a NEW module
+ * instance that neither runtime ever frees: about 60 KB per page view, so a dev
+ * server left open on a page grew without bound. Keyed by content, an unchanged
+ * file maps to the module already loaded. Content rather than mtime, because
+ * Linux stamps mtime from a coarse clock, so two quick writes of the same
+ * length can share one and the second would never be seen. A file that cannot
+ * be read gets a unique query, the old behaviour.
  *
  * A path that already contains `?` or `#` cannot carry a query unambiguously as
  * a plain path, so on Bun it falls back to the file URL (no fresh import; the
@@ -17,18 +25,67 @@
  * Outside dev the specifier is the plain file URL, exactly as before.
  */
 import { pathToFileURL } from 'node:url';
+import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 
 /**
  * @param {string} file absolute file path
  * @param {boolean} dev whether to cache-bust
- * @param {{ bun?: boolean, now?: () => number }} [opts] test seams: the runtime (default: detected) and the clock
+ * @param {{ bun?: boolean, version?: (file: string) => string }} [opts] test
+ *   seams: the runtime (default: detected) and the content version
  * @returns {string}
  */
 export function devImportSpecifier(file, dev, opts = {}) {
   const url = pathToFileURL(file).toString();
   if (!dev) return url;
   const bun = opts.bun ?? Boolean(typeof process !== 'undefined' && process.versions && process.versions.bun);
-  const bust = `?t=${(opts.now ?? Date.now)()}-${Math.random().toString(36).slice(2)}`;
+  const bust = `?t=${(opts.version ?? contentVersion)(file)}`;
   if (bun && !/[?#]/.test(file)) return file + bust;
   return url + bust;
 }
+
+/**
+ * A short hash of the file's bytes, or a unique token when it cannot be read.
+ * @param {string} file
+ * @returns {string}
+ */
+export function contentVersion(file) {
+  try {
+    return createHash('sha1').update(readFileSync(file)).digest('hex').slice(0, 16);
+  } catch {
+    return `u${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  }
+}
+
+/**
+ * Specifiers whose import rejected, mapped to the key to use instead (#1575).
+ * Under `bun --hot`, importing a module that failed to parse a SECOND time
+ * through the same specifier never settles, and a later reload can then crash
+ * the process (Bun 1.3.14). A content-keyed specifier repeats for as long as
+ * the bytes do, so a broken file would hang every request after the first. A
+ * failed key is therefore never imported again: the next attempt gets a fresh
+ * one, which sticks once it loads.
+ * @type {Map<string, string>}
+ */
+const RETRY_KEYS = new Map();
+let retrySeq = 0;
+
+/**
+ * `import()` a module the dev server re-imports on every request, through
+ * `devImportSpecifier`. Use this rather than `import(devImportSpecifier(...))`.
+ *
+ * @param {string} file absolute file path
+ * @param {boolean} dev
+ * @returns {Promise<any>}
+ */
+export async function devImport(file, dev) {
+  const base = devImportSpecifier(file, dev);
+  if (!dev) return import(base);
+  const spec = RETRY_KEYS.get(base) || base;
+  try {
+    return await import(spec);
+  } catch (e) {
+    RETRY_KEYS.set(base, `${base}-r${++retrySeq}`);
+    throw e;
+  }
+}

package/src/dev-reload-worker.js

@@ -36,6 +36,18 @@
  */
 export const RELOAD_QUIET_MS = 2000;
 
+/**
+ * The quiet window for a batch made only of in-process frames from a server
+ * that reloads IN PLACE (#1575): Bun's one long-lived dev server, or any
+ * `--no-hot` server. No restart follows such a frame, so nothing is worth
+ * waiting 2000ms for, and that wait was most of the save-to-paint time (3.8s
+ * measured in a hosted preview). 300ms still folds a save's few frames and a
+ * quick burst into one reload. A batch holding any restart signal (a changed
+ * boot id, a stale page, a frame from a restarting server) keeps the full
+ * `RELOAD_QUIET_MS`, since the restarted process is still warming.
+ */
+export const RELOAD_QUIET_IN_PLACE_MS = 300;
+
 /**
  * The longest a reload is ever held, measured from the FIRST signal of a batch
  * (#1397). A quiet window alone would freeze the page on stale content for a
@@ -116,6 +128,19 @@ export function pageIsStale(page, boot, seq) {
 }
 
 /** A reload frame's `seq` (#1507), or null when it carries none. @param {string} data */
+/**
+ * Whether a `reload` frame comes from a server that reloads in place (#1575).
+ * Absent or unreadable means it may restart, the safe (slower) reading.
+ * @param {string} data
+ * @returns {boolean}
+ */
+export function frameInPlace(data) {
+  try {
+    const o = JSON.parse(data);
+    return !!(o && o.inPlace === true);
+  } catch (_) { return false; }
+}
+
 function reloadSeq(data) {
   try {
     const o = JSON.parse(data);
@@ -190,6 +215,8 @@ export function startReloadWorker(scope, EventSourceCtor, eventsUrl, opts) {
   let batchAll = false;
   /** @type {Set<any>} tabs whose page fell behind, reloaded on their own */
   const batchPorts = new Set();
+  /** Whether the batch holds a signal from a server that restarts (#1575). */
+  let batchRestart = false;
 
   function emitReload() {
     if (quietTimer !== null) { timers.clearTimeout(quietTimer); quietTimer = null; }
@@ -200,6 +227,7 @@ export function startReloadWorker(scope, EventSourceCtor, eventsUrl, opts) {
     const targets = batchAll ? Array.from(ports.keys()) : Array.from(batchPorts).filter((p) => ports.has(p));
     batchAll = false;
     batchPorts.clear();
+    batchRestart = false;
     for (const p of targets) {
       // The tab applies this reload, so from here its page reflects the state
       // the relay knows now; a later hello compares against that.
@@ -219,11 +247,13 @@ export function startReloadWorker(scope, EventSourceCtor, eventsUrl, opts) {
    * @param {string} verdict
    * @param {any} [port]  reload only this tab (its page fell behind); omitted, every tab
    */
-  function requestReload(verdict, port) {
+  function requestReload(verdict, port, inPlace) {
     if (port === undefined) batchAll = true; else batchPorts.add(port);
     if (rank(verdict) < rank(batchVerdict)) batchVerdict = VERDICT_STRENGTH[rank(verdict)];
+    // One restart signal anywhere in the batch keeps the long window (#1575).
+    if (!inPlace) batchRestart = true;
     if (quietTimer !== null) timers.clearTimeout(quietTimer);
-    quietTimer = timers.setTimeout(emitReload, RELOAD_QUIET_MS);
+    quietTimer = timers.setTimeout(emitReload, batchRestart ? RELOAD_QUIET_MS : RELOAD_QUIET_IN_PLACE_MS);
     if (capTimer === null) capTimer = timers.setTimeout(emitReload, RELOAD_MAX_HOLD_MS);
   }
 
@@ -278,7 +308,7 @@ export function startReloadWorker(scope, EventSourceCtor, eventsUrl, opts) {
       lastError = null;
       const n = reloadSeq(e.data);
       if (n !== null) lastSeq = n;
-      requestReload(parseVerdict(e.data));
+      requestReload(parseVerdict(e.data), undefined, frameInPlace(e.data));
     });
     es.addEventListener('webjs-error', (e) => { lastError = e.data; fanout({ type: 'webjs-error', data: e.data }); });
     // The stream dropped (a restarting server, a network blip, a host that

package/src/dev-source-locations-hook.js

@@ -105,6 +105,13 @@ export function registerSourceLocationHook(appDir) {
   if (_roots.has(appDir)) return _installed;
   _roots.add(appDir);
   if (serverRuntime() === 'bun') {
+    // Once per root per PROCESS (#1575): `bun --hot` re-runs this module with
+    // an empty `_roots`, and a `Bun.plugin` cannot be unregistered.
+    const g = /** @type {any} */ (globalThis);
+    const key = Symbol.for('webjs.sourceLocations.bunRoots');
+    if (!(g[key] instanceof Set)) g[key] = new Set();
+    if (g[key].has(appDir)) { _installed = true; return _installed; }
+    g[key].add(appDir);
     // One plugin per root, each with a filter that can never match a
     // `node_modules` or `*.server.*` path (see the module comment).
     const filter = new RegExp(

package/src/env-schema.js

@@ -33,7 +33,7 @@
  */
 import { join } from 'node:path';
 import { stat } from 'node:fs/promises';
-import { devImportSpecifier } from './dev-import.js';
+import { devImport } from './dev-import.js';
 
 /** Field type names a schema may declare. */
 const KNOWN_TYPES = new Set(['string', 'number', 'boolean', 'url', 'enum']);
@@ -223,7 +223,7 @@ export async function loadEnvSchema(appDir, opts = {}) {
     }
   }
   if (!file) return null;
-  const mod = await import(devImportSpecifier(file, Boolean(opts.dev)));
+  const mod = await devImport(file, Boolean(opts.dev));
   return mod.default ?? null;
 }
 

package/src/form-action-identity.js

@@ -16,7 +16,7 @@
 
 import { actionIdentitiesOf, identityHookInstalled } from './action-seed.js';
 import { pathToFileURL } from 'node:url';
-import { devImportSpecifier } from './dev-import.js';
+import { devImport } from './dev-import.js';
 
 /**
  * Resolved identities for functions the hook never registered. Only ever
@@ -283,7 +283,7 @@ export async function lookupActionIdentity(idx, id) {
   if (!file) return { ok: false, reason: 'skew' };
   let module;
   try {
-    module = await import(devImportSpecifier(file, Boolean(idx.dev)));
+    module = await devImport(file, Boolean(idx.dev));
   } catch (error) {
     return { ok: false, reason: 'load-failed', error };
   }

package/src/instrumentation.js

@@ -18,7 +18,7 @@
 import { join } from 'node:path';
 import { stat } from 'node:fs/promises';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { devImportSpecifier } from './dev-import.js';
+import { devImport } from './dev-import.js';
 
 /**
  * Per-boot handoff channel for a `register()`-registered error sink. An
@@ -86,7 +86,7 @@ export async function runInstrumentation(appDir, opts = {}) {
   const store = { onError: null };
   await _als.run(store, async () => {
     try {
-      const mod = await import(devImportSpecifier(file, dev));
+      const mod = await devImport(file, dev);
       const register = typeof mod.default === 'function'
         ? mod.default
         : (typeof mod.register === 'function' ? mod.register : null);

package/src/listener-core.js

@@ -23,7 +23,7 @@ import {
 import { stripBasePath } from './base-path.js';
 import { randomUUID } from 'node:crypto';
 import { isWatchError } from './dev/watch-tree.js';
-import { devImportSpecifier } from './dev-import.js';
+import { devImport } from './dev-import.js';
 
 /** The dev live-reload SSE path (matched after base-path stripping). */
 export const EVENTS_PATH = '/__webjs/events';
@@ -329,7 +329,7 @@ export async function readBufferedOrStream(web, maxBytes) {
  * @param {boolean} dev
  */
 export function loadWsModule(file, dev) {
-  return import(devImportSpecifier(file, dev));
+  return devImport(file, dev);
 }
 
 /**
@@ -351,7 +351,13 @@ export function loadWsModule(file, dev) {
  * tab was hidden can tell, on reconnecting, that it missed an edit.
  */
 export class SseHub {
-  constructor() {
+  /**
+   * @param {{ inPlace?: boolean }} [opts] `inPlace`: this server applies an
+   *   edit without restarting its process (#1575), so its reload frames say so
+   *   and the browser relay need not wait for a restart to settle.
+   */
+  constructor({ inPlace = false } = {}) {
+    this.inPlace = inPlace;
     /** @type {Set<{ send: (s: string) => void, close: () => void }>} */
     this.clients = new Set();
     /** Reload frames sent by this process (#1507). */
@@ -399,7 +405,7 @@ export class SseHub {
   reload(verdict) {
     const v = verdict && typeof verdict.v === 'string' ? verdict : { v: 'reload' };
     this.seq++;
-    this._raw(`event: reload\ndata: ${JSON.stringify({ ...v, seq: this.seq })}\n\n`);
+    this._raw(`event: reload\ndata: ${JSON.stringify({ ...v, seq: this.seq, ...(this.inPlace ? { inPlace: true } : {}) })}\n\n`);
   }
 
   /** Push a dev-error overlay frame (#264) to every open tab. @param {object} frame */