@modern-js/server 3.5.0 → 3.7.0

package/dist/esm-node/dev-tools/reloadManager.mjs

@@ -0,0 +1,186 @@
+import "node:module";
+import { logger } from "@modern-js/utils";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+const DEFAULT_DEBOUNCE_MS = 300;
+const notReadyHandle = ()=>new Response('Dev server is starting…', {
+        status: 503,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8'
+        }
+    });
+var _current = /*#__PURE__*/ new WeakMap(), _build = /*#__PURE__*/ new WeakMap(), _debounceMs = /*#__PURE__*/ new WeakMap(), _onReload = /*#__PURE__*/ new WeakMap(), _onError = /*#__PURE__*/ new WeakMap(), _onReloadError = /*#__PURE__*/ new WeakMap(), _debounceTimer = /*#__PURE__*/ new WeakMap(), _running = /*#__PURE__*/ new WeakMap(), _pending = /*#__PURE__*/ new WeakMap(), _runningPromise = /*#__PURE__*/ new WeakMap(), _closed = /*#__PURE__*/ new WeakMap(), _runLoop = /*#__PURE__*/ new WeakSet(), _reportBuildError = /*#__PURE__*/ new WeakSet(), _reportReloadCallbackError = /*#__PURE__*/ new WeakSet();
+class ReloadManager {
+    setHandle(handle) {
+        _class_private_field_set(this, _current, handle);
+    }
+    get handle() {
+        return (request, ...args)=>_class_private_field_get(this, _current).call(this, request, ...args);
+    }
+    get currentHandle() {
+        return _class_private_field_get(this, _current);
+    }
+    get isReloading() {
+        return _class_private_field_get(this, _running);
+    }
+    schedule() {
+        if (_class_private_field_get(this, _closed)) return;
+        if (_class_private_field_get(this, _debounceTimer)) clearTimeout(_class_private_field_get(this, _debounceTimer));
+        _class_private_field_set(this, _debounceTimer, setTimeout(()=>{
+            _class_private_field_set(this, _debounceTimer, null);
+            this.reloadNow();
+        }, _class_private_field_get(this, _debounceMs)));
+    }
+    async reloadNow() {
+        if (_class_private_field_get(this, _closed)) return;
+        if (_class_private_field_get(this, _running)) {
+            _class_private_field_set(this, _pending, true);
+            return _class_private_field_get(this, _runningPromise) ?? Promise.resolve();
+        }
+        _class_private_field_set(this, _running, true);
+        _class_private_field_set(this, _runningPromise, _class_private_method_get(this, _runLoop, runLoop).call(this));
+        try {
+            await _class_private_field_get(this, _runningPromise);
+        } finally{
+            _class_private_field_set(this, _running, false);
+            _class_private_field_set(this, _runningPromise, null);
+        }
+    }
+    close() {
+        _class_private_field_set(this, _closed, true);
+        _class_private_field_set(this, _pending, false);
+        if (_class_private_field_get(this, _debounceTimer)) {
+            clearTimeout(_class_private_field_get(this, _debounceTimer));
+            _class_private_field_set(this, _debounceTimer, null);
+        }
+    }
+    constructor(options){
+        _class_private_method_init(this, _runLoop);
+        _class_private_method_init(this, _reportBuildError);
+        _class_private_method_init(this, _reportReloadCallbackError);
+        _class_private_field_init(this, _current, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _build, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _debounceMs, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _onReload, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _onError, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _onReloadError, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _debounceTimer, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _running, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _pending, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _runningPromise, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _closed, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _debounceTimer, null);
+        _class_private_field_set(this, _running, false);
+        _class_private_field_set(this, _pending, false);
+        _class_private_field_set(this, _runningPromise, null);
+        _class_private_field_set(this, _closed, false);
+        _class_private_field_set(this, _current, options.initialHandle ?? notReadyHandle);
+        _class_private_field_set(this, _build, options.build);
+        _class_private_field_set(this, _debounceMs, options.debounceMs ?? DEFAULT_DEBOUNCE_MS);
+        _class_private_field_set(this, _onReload, options.onReload);
+        _class_private_field_set(this, _onError, options.onError);
+        _class_private_field_set(this, _onReloadError, options.onReloadError);
+    }
+}
+async function runLoop() {
+    var _this, _this1;
+    do {
+        _class_private_field_set(this, _pending, false);
+        let next;
+        try {
+            next = await _class_private_field_get(this, _build).call(this);
+        } catch (error) {
+            _class_private_method_get(this, _reportBuildError, reportBuildError).call(this, error);
+            continue;
+        }
+        if (_class_private_field_get(this, _closed)) return;
+        _class_private_field_set(this, _current, next);
+        try {
+            null == (_this = _class_private_field_get(_this1 = this, _onReload)) || _this.call(_this1, next);
+        } catch (callbackError) {
+            _class_private_method_get(this, _reportReloadCallbackError, reportReloadCallbackError).call(this, callbackError);
+        }
+    }while (_class_private_field_get(this, _pending) && !_class_private_field_get(this, _closed));
+}
+function reportBuildError(error) {
+    if (_class_private_field_get(this, _onError)) _class_private_field_get(this, _onError).call(this, error);
+    else logger.error(`[dev-server] runtime reload build failed, keep serving previous handle:\n${error instanceof Error ? error.stack ?? error.message : error}`);
+}
+function reportReloadCallbackError(error) {
+    if (_class_private_field_get(this, _onReloadError)) _class_private_field_get(this, _onReloadError).call(this, error);
+    else logger.warn(`[dev-server] onReload callback failed after a successful swap (handle is already active):\n${error instanceof Error ? error.stack ?? error.message : error}`);
+}
+function createReloadManager(options) {
+    return new ReloadManager(options);
+}
+export { ReloadManager, createReloadManager };

package/dist/esm-node/dev-tools/runtimeOptions.mjs

@@ -0,0 +1,36 @@
+import "node:module";
+function createRuntimeServerOptions(base, assetPrefix) {
+    const baseConfig = base.config ?? {};
+    const baseOutput = baseConfig.output ?? {};
+    const baseServerConfig = base.serverConfig ?? {};
+    return {
+        ...base,
+        config: {
+            ...baseConfig,
+            output: {
+                ...baseOutput,
+                ...assetPrefix ? {
+                    assetPrefix
+                } : {}
+            }
+        },
+        serverConfig: {
+            ...baseServerConfig,
+            middlewares: [
+                ...baseServerConfig.middlewares ?? []
+            ],
+            renderMiddlewares: [
+                ...baseServerConfig.renderMiddlewares ?? []
+            ],
+            ...baseServerConfig.plugins ? {
+                plugins: [
+                    ...baseServerConfig.plugins
+                ]
+            } : {}
+        },
+        plugins: [
+            ...base.plugins ?? []
+        ]
+    };
+}
+export { createRuntimeServerOptions };

package/dist/esm-node/dev.mjs

@@ -1,41 +1,17 @@
 import "node:module";
+import node_path from "node:path";
+import { AGGRED_DIR } from "@modern-js/server-core";
 import { connectMid2HonoMid } from "@modern-js/server-core/node";
-import { API_DIR, SHARED_DIR } from "@modern-js/utils";
+import { API_DIR, SHARED_DIR, logger } from "@modern-js/utils";
 import { getDevOptions, getMockMiddleware, initFileReader, onRepack, startWatcher } from "./helpers/index.mjs";
-const devPlugin = (options, compiler)=>({
+const devRuntimeMiddlewarePlugin = (options, compiler)=>({
         name: '@modern-js/plugin-dev',
         setup (api) {
-            const { config, pwd, builder, builderDevServer } = options;
-            const closeCb = [];
+            const { pwd, builderDevServer } = options;
             const dev = getDevOptions(options.dev);
             api.onPrepare(async ()=>{
-                const { middlewares: builderMiddlewares, close, connectWebSocket } = builderDevServer || {};
-                close && closeCb.push(close);
-                const { middlewares, distDirectory, nodeServer, apiDirectory, sharedDirectory, serverBase } = api.getServerContext();
-                connectWebSocket && nodeServer && connectWebSocket({
-                    server: nodeServer
-                });
-                const hooks = api.getHooks();
-                builder?.onDevCompileDone(({ stats })=>{
-                    if ('server' !== stats.toJson({
-                        all: false
-                    }).name) onRepack(distDirectory, hooks);
-                });
-                const { watchOptions } = config.server;
-                const watcher = startWatcher({
-                    pwd,
-                    distDir: distDirectory,
-                    apiDir: apiDirectory || API_DIR,
-                    sharedDir: sharedDirectory || SHARED_DIR,
-                    watchOptions,
-                    server: serverBase
-                });
-                closeCb.push(watcher.close.bind(watcher));
-                closeCb.length > 0 && nodeServer?.on('close', ()=>{
-                    closeCb.forEach((cb)=>{
-                        cb();
-                    });
-                });
+                const { middlewares: builderMiddlewares } = builderDevServer || {};
+                const { middlewares } = api.getServerContext();
                 const before = [];
                 const after = [];
                 const { setupMiddlewares = [] } = dev;
@@ -75,4 +51,58 @@ const devPlugin = (options, compiler)=>({
             });
         }
     });
-export { devPlugin };
+function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, onFileChange, onClose, nodeServer }) {
+    const { close, connectWebSocket } = builderDevServer || {};
+    const closeCb = [];
+    close && closeCb.push(close);
+    connectWebSocket && nodeServer && connectWebSocket({
+        server: nodeServer
+    });
+    builder?.onDevCompileDone(({ stats })=>{
+        if ('server' !== stats.toJson({
+            all: false
+        }).name) {
+            const runtimeServer = getRuntimeServer();
+            if (runtimeServer) onRepack(distDir, runtimeServer.hooks);
+        }
+    });
+    const { watchOptions } = config.server;
+    const mockPath = node_path.normalize(node_path.join(pwd, AGGRED_DIR.mock));
+    const watcher = startWatcher({
+        pwd,
+        distDir,
+        apiDir: apiDir || API_DIR,
+        sharedDir: sharedDir || SHARED_DIR,
+        watchOptions,
+        onChange: (filepath, event)=>{
+            const runtimeServer = getRuntimeServer();
+            if (runtimeServer && !filepath.startsWith(mockPath)) {
+                const fileChangeEvent = {
+                    type: 'file-change',
+                    payload: [
+                        {
+                            filename: filepath,
+                            event
+                        }
+                    ]
+                };
+                Promise.resolve(runtimeServer.hooks.onReset.call({
+                    event: fileChangeEvent
+                })).catch((error)=>logger.error(error));
+            }
+            onFileChange(filepath, event);
+        }
+    });
+    closeCb.push(watcher.close.bind(watcher));
+    onClose && closeCb.push(onClose);
+    const close$ = ()=>{
+        closeCb.forEach((cb)=>{
+            cb();
+        });
+    };
+    closeCb.length > 0 && nodeServer?.on('close', close$);
+    return {
+        close: close$
+    };
+}
+export { devRuntimeMiddlewarePlugin, setupDevInfra };

package/dist/esm-node/helpers/index.mjs

@@ -2,40 +2,13 @@ import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
 import path from "path";
 import { AGGRED_DIR } from "@modern-js/server-core";
-import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR, logger } from "@modern-js/utils";
+import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR } from "@modern-js/utils";
 import dev_tools_watcher, { mergeWatchOptions } from "../dev-tools/watcher/index.mjs";
-import { initOrUpdateMockMiddlewares } from "./mock.mjs";
-import { debug } from "./utils.mjs";
 export * from "./repack.mjs";
 export * from "./devOptions.mjs";
 export * from "./fileReader.mjs";
 export * from "./mock.mjs";
-async function onServerChange({ pwd, filepath, event, server }) {
-    const { mock } = AGGRED_DIR;
-    const mockPath = path.normalize(path.join(pwd, mock));
-    const { hooks } = server;
-    if (filepath.startsWith(mockPath)) {
-        await initOrUpdateMockMiddlewares(pwd);
-        logger.info('Finish update the mock handlers');
-    } else try {
-        const fileChangeEvent = {
-            type: 'file-change',
-            payload: [
-                {
-                    filename: filepath,
-                    event
-                }
-            ]
-        };
-        await hooks.onReset.call({
-            event: fileChangeEvent
-        });
-        debug(`Finish reload server, trigger by ${filepath} ${event}`);
-    } catch (e) {
-        logger.error(e);
-    }
-}
-function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
+function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, onChange }) {
     const { mock } = AGGRED_DIR;
     const defaultWatched = [
         `${mock}/**/*`,
@@ -55,12 +28,7 @@ function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server })
         if (filepath.includes('-server-loaders.js')) return void delete require.cache[filepath];
         watcher.updateDepTree();
         watcher.cleanDepCache(filepath);
-        onServerChange({
-            pwd,
-            filepath,
-            event,
-            server
-        });
+        onChange(filepath, event);
     });
     return watcher;
 }

package/dist/esm-node/helpers/mock.mjs

@@ -2,7 +2,7 @@ import "node:module";
 import node_path from "node:path";
 import { AGGRED_DIR } from "@modern-js/server-core";
 import { connectMockMid2HonoMid } from "@modern-js/server-core/node";
-import { fs } from "@modern-js/utils";
+import { compatibleRequire, fs } from "@modern-js/utils";
 import { match } from "path-to-regexp";
 let mockAPIs = [];
 let mockConfig;
@@ -35,7 +35,7 @@ const getMockModule = async (pwd)=>{
         }
     }
     if (!mockFilePath) return;
-    const { default: mockHandlers, config } = await import(mockFilePath);
+    const { default: mockHandlers, config } = await compatibleRequire(mockFilePath, false);
     const enable = config?.enable;
     if (false === enable) return;
     if (!mockHandlers) throw new Error(`Mock file ${mockFilePath} parsed failed!`);

package/dist/types/dev-tools/reloadManager.d.ts

@@ -0,0 +1,88 @@
+/**
+ * A request handle compatible with `ServerBase.handle` (Hono's `app.fetch`)
+ * and the handler accepted by `createNodeServer`.
+ */
+export type ReloadableHandle = (request: Request, ...args: any[]) => Response | Promise<Response>;
+export interface ReloadManagerOptions {
+    /**
+     * The handle used before the first successful build. Optional: when omitted
+     * the manager serves a 503 "starting" response until the first build swaps a
+     * real handle in (use `setHandle()` for a fail-fast initial boot).
+     */
+    initialHandle?: ReloadableHandle;
+    /**
+     * Build a fresh handle (e.g. a brand new runtime `ServerBase`).
+     * If this throws, the previously active handle is retained (rollback).
+     */
+    build: () => Promise<ReloadableHandle>;
+    /** Debounce window (ms) used to coalesce rapid `schedule()` calls. */
+    debounceMs?: number;
+    /**
+     * Called after a handle is successfully built and swapped in (e.g. to clean
+     * up the previous runtime). The swap has already been committed when this
+     * runs, so throwing here does NOT roll back — it is reported via
+     * `onReloadError` instead of `onError`.
+     */
+    onReload?: (handle: ReloadableHandle) => void;
+    /**
+     * Called when `build()` throws. The previous handle is kept serving. This is
+     * the only path that counts as a failed reload.
+     */
+    onError?: (error: unknown) => void;
+    /**
+     * Called when the `onReload` callback throws. The new handle is already
+     * active; this is a post-swap cleanup/callback failure, never a rollback.
+     */
+    onReloadError?: (error: unknown) => void;
+}
+/**
+ * Owns the single mutable request handle behind a stable forwarding listener.
+ *
+ * Guarantees required by the dev-server hot-reload design:
+ * - Atomic swap: the active handle is replaced by a single assignment, so
+ *   in-flight requests always run against a consistent handle.
+ * - Failure isolation: if `build()` rejects, the previous handle stays active
+ *   (the dev server never degrades to an empty / broken handle).
+ * - Serial execution: reloads never overlap. Requests that arrive while a
+ *   reload is running are coalesced into a single trailing reload so that the
+ *   final state always reflects the latest source ("last write wins").
+ */
+export declare class ReloadManager {
+    #private;
+    constructor(options: ReloadManagerOptions);
+    /**
+     * Replace the active handle directly, bypassing `build()`. Used to seed the
+     * initial known-good handle (a fail-fast boot builds the first runtime
+     * explicitly so build errors propagate, then seeds it here).
+     */
+    setHandle(handle: ReloadableHandle): void;
+    /**
+     * Stable forwarding handle. Pass this to `createNodeServer` once; it always
+     * dispatches to the latest active handle, so the Node server never needs to
+     * be recreated on reload.
+     */
+    get handle(): ReloadableHandle;
+    /** The currently active resolved handle (introspection / tests). */
+    get currentHandle(): ReloadableHandle;
+    /** Whether a reload is currently running (introspection / tests). */
+    get isReloading(): boolean;
+    /**
+     * Request a reload, debounced. Multiple calls within the debounce window
+     * collapse into a single reload.
+     */
+    schedule(): void;
+    /**
+     * Run a reload immediately. If one is already running, mark a trailing
+     * reload and return the in-flight promise (which will include the trailing
+     * run) so callers can await final settlement.
+     */
+    reloadNow(): Promise<void>;
+    /**
+     * Stop the manager: cancel any pending debounced reload and reject all
+     * further `schedule()` / `reloadNow()` calls. Wired into the dev server's
+     * close chain so a debounce timer that fires after teardown can never
+     * rebuild a runtime once the watcher / builder dev server are gone.
+     */
+    close(): void;
+}
+export declare function createReloadManager(options: ReloadManagerOptions): ReloadManager;

package/dist/types/dev-tools/runtimeOptions.d.ts

@@ -0,0 +1,27 @@
+interface RuntimeOptionsBase {
+    config: Record<string, any>;
+    serverConfig?: Record<string, any>;
+    plugins?: any[];
+}
+/**
+ * Produce a fully-isolated options object for a single runtime build.
+ *
+ * `buildRuntimeServer` runs for the initial boot AND for every hot reload, so
+ * each build must own every container that a plugin or the apply pipeline
+ * could append to / rewrite. A shallow `{ ...base }` is NOT enough: `config`,
+ * `serverConfig` and `plugins` would still share references, letting one
+ * runtime's appended middlewares / plugins leak into the next reload.
+ *
+ * This clones:
+ * - a fresh top-level options object
+ * - a fresh `config` with a fresh `config.output` (so writing `assetPrefix`
+ *   never mutates the caller's original `options.config`)
+ * - a fresh `serverConfig` whose `middlewares` / `renderMiddlewares` /
+ *   `plugins` are new arrays
+ * - a fresh top-level `plugins` array
+ *
+ * Nested config sub-objects that are only read (never appended to) stay shared
+ * by reference, which is intentional and cheap.
+ */
+export declare function createRuntimeServerOptions<T extends RuntimeOptionsBase>(base: T, assetPrefix?: string): T;
+export {};

package/dist/types/dev.d.ts

@@ -1,9 +1,68 @@
+import type { Server as NodeServer } from 'node:http';
+import type { Http2SecureServer } from 'node:http2';
+import type { Server as NodeHttpsServer } from 'node:https';
 import type { BuilderInstance, Rspack } from '@modern-js/builder';
-import type { ServerBaseOptions, ServerPlugin } from '@modern-js/server-core';
+import type { ServerBase, ServerBaseOptions, ServerPlugin } from '@modern-js/server-core';
+import type { WatchEvent } from './dev-tools/watcher';
 import type { ModernDevServerOptions } from './types';
 type BuilderDevServer = Awaited<ReturnType<BuilderInstance['createDevServer']>>;
 export type DevPluginOptions = ModernDevServerOptions<ServerBaseOptions> & {
     builderDevServer?: BuilderDevServer;
 };
-export declare const devPlugin: (options: DevPluginOptions, compiler: Rspack.Compiler | Rspack.MultiCompiler | null) => ServerPlugin;
+/**
+ * Runtime-level dev middleware injection.
+ *
+ * This plugin is added to EVERY runtime `ServerBase` that `buildRuntimeServer`
+ * creates, so it must be safe to run repeatedly and must NOT touch any
+ * process-level resource (the file watcher / websocket / builder hooks / close
+ * callbacks all live in `setupDevInfra`). It only pushes request middlewares
+ * into the current server's middleware list:
+ * - user `dev.setupMiddlewares` (before / after)
+ * - the mock middleware
+ * - the rsbuild/builder dev middleware (a stable reference, just re-registered)
+ * - the file-reader middleware
+ */
+export declare const devRuntimeMiddlewarePlugin: (options: DevPluginOptions, compiler: Rspack.Compiler | Rspack.MultiCompiler | null) => ServerPlugin;
+export interface DevInfraOptions {
+    config: DevPluginOptions['config'];
+    pwd: string;
+    distDir: string;
+    apiDir?: string;
+    sharedDir?: string;
+    builder?: BuilderInstance;
+    builderDevServer?: BuilderDevServer;
+    compiler: Rspack.Compiler | Rspack.MultiCompiler | null;
+    nodeServer?: NodeServer | NodeHttpsServer | Http2SecureServer;
+    /** Accessor for the currently-active runtime ServerBase (a mutable ref). */
+    getRuntimeServer: () => ServerBase | undefined;
+    /**
+     * Triggered when a watched user server file changes (require cache already
+     * busted). Wired to the runtime reload scheduler.
+     */
+    onFileChange: (filepath: string, event: WatchEvent) => void;
+    /**
+     * Extra teardown run as part of the dev server close chain (e.g. stopping the
+     * reload scheduler so a pending debounced reload can't rebuild after close).
+     */
+    onClose?: () => void;
+}
+export interface DevInfra {
+    /** Tear down every process-level resource. Called when the dev server stops. */
+    close: () => void;
+}
+/**
+ * Process-level dev infrastructure, created EXACTLY ONCE for the lifetime of
+ * the dev server. None of these resources are recreated or torn down by a
+ * runtime hot reload:
+ * - the rsbuild/builder dev server websocket connection
+ * - the builder `onDevCompileDone` -> SSR cache reset hook
+ * - the file watcher
+ * - close callbacks registered on the Node server's `close` event
+ *
+ * The watcher / onRepack reach the LIVE runtime hooks through
+ * `getRuntimeServer()` (a mutable ref) instead of closing over the initial
+ * runtime, so a later phase can swap the trigger to the reload scheduler
+ * without leaking a stale closure to a dead runtime.
+ */
+export declare function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, onFileChange, onClose, nodeServer, }: DevInfraOptions): DevInfra;
 export {};

package/dist/types/helpers/index.d.ts

@@ -1,15 +1,19 @@
-import { type ServerBase } from '@modern-js/server-core';
 import { type WatchOptions } from '@modern-js/utils';
-import Watcher from '../dev-tools/watcher';
+import Watcher, { type WatchEvent } from '../dev-tools/watcher';
 export * from './repack';
 export * from './devOptions';
 export * from './fileReader';
 export * from './mock';
-export declare function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server, }: {
+export declare function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, onChange, }: {
     pwd: string;
     distDir: string;
     apiDir: string;
     sharedDir: string;
     watchOptions?: WatchOptions;
-    server: ServerBase;
+    /**
+     * Called after the require cache for a changed user server file has been
+     * busted, so the next runtime build re-imports fresh code. Server loader
+     * bundles are handled inline (cache drop only) and never reach this.
+     */
+    onChange: (filepath: string, event: WatchEvent) => void;
 }): Watcher;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0",
+  "version": "3.7.0",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -44,14 +44,14 @@
     "minimatch": "^3.1.2",
     "path-to-regexp": "^6.3.0",
     "ws": "^8.21.0",
-    "@modern-js/runtime-utils": "3.5.0",
-    "@modern-js/server-core": "3.5.0",
-    "@modern-js/server-utils": "3.5.0",
-    "@modern-js/types": "3.5.0",
-    "@modern-js/utils": "3.5.0"
+    "@modern-js/runtime-utils": "3.7.0",
+    "@modern-js/server-core": "3.7.0",
+    "@modern-js/server-utils": "3.7.0",
+    "@modern-js/types": "3.7.0",
+    "@modern-js/utils": "3.7.0"
   },
   "devDependencies": {
-    "@rslib/core": "0.23.0",
+    "@rslib/core": "0.23.2",
     "@types/connect-history-api-fallback": "^1.5.4",
     "@types/minimatch": "^3.0.5",
     "@types/node": "^20",
@@ -61,7 +61,7 @@
     "tsconfig-paths": "4.2.0",
     "typescript": "^5",
     "websocket": "^1.0.35",
-    "@modern-js/builder": "3.5.0",
+    "@modern-js/builder": "3.7.0",
     "@modern-js/rslib": "2.68.10",
     "@scripts/rstest-config": "2.66.0"
   },

package/rstest.config.mts

@@ -1,5 +1,6 @@
 import { withTestPreset } from '@scripts/rstest-config';
 
 export default withTestPreset({
+  setupFiles: ['@scripts/rstest-config/setup.ts'],
   globals: true,
 });