@bleedingdev/modern-js-server 3.5.0-ultramodern.98 → 3.8.1-ultramodern.1

package/dist/esm-node/dev.mjs

@@ -1,41 +1,15 @@
 import "node:module";
 import { connectMid2HonoMid } from "@modern-js/server-core/node";
-import { API_DIR, SHARED_DIR } from "@modern-js/utils";
-import { getDevOptions, getMockMiddleware, initFileReader, onRepack, startWatcher } from "./helpers/index.mjs";
-const devPlugin = (options, compiler)=>({
+import { API_DIR, SHARED_DIR, logger } from "@modern-js/utils";
+import { getDevOptions, getMockMiddleware, initFileReader, isPathInsideDirectory, onRepack, resolveMockDirectory, startWatcher } from "./helpers/index.mjs";
+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;
@@ -53,7 +27,7 @@ const devPlugin = (options, compiler)=>({
                         handler: connectMid2HonoMid(middleware)
                     });
                 });
-                const mockMiddleware = await getMockMiddleware(pwd);
+                const mockMiddleware = await getMockMiddleware(pwd, options.config?.dev?.mockDir);
                 middlewares.push({
                     name: 'mock-dev',
                     handler: mockMiddleware
@@ -75,4 +49,60 @@ 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 mockDir = config.dev?.mockDir;
+    const mockPath = resolveMockDirectory(pwd, mockDir);
+    const watcher = startWatcher({
+        pwd,
+        distDir,
+        apiDir: apiDir || API_DIR,
+        sharedDir: sharedDir || SHARED_DIR,
+        mockDir,
+        watchOptions,
+        onChange: (filepath, event)=>{
+            const runtimeServer = getRuntimeServer();
+            if (runtimeServer && !isPathInsideDirectory(filepath, 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

@@ -1,44 +1,16 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-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 path from "path";
 import dev_tools_watcher, { mergeWatchOptions } from "../dev-tools/watcher/index.mjs";
-import { initOrUpdateMockMiddlewares } from "./mock.mjs";
-import { debug } from "./utils.mjs";
+import { resolveMockDirectory } from "./mock.mjs";
 export * from "./devOptions.mjs";
 export * from "./fileReader.mjs";
 export * from "./mock.mjs";
 export * from "./repack.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 }) {
-    const { mock } = AGGRED_DIR;
+function startWatcher({ pwd, distDir, apiDir, sharedDir, mockDir, watchOptions, onChange }) {
     const defaultWatched = [
-        `${mock}/**/*`,
+        path.join(resolveMockDirectory(pwd, mockDir), '**/*'),
         `${SERVER_DIR}/**/*`,
         `${apiDir}/**`,
         `${sharedDir}/**/*`,
@@ -55,12 +27,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,10 +2,15 @@ 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;
+const resolveMockDirectory = (pwd, mockDir = AGGRED_DIR.mock)=>node_path.resolve(pwd, mockDir);
+const isPathInsideDirectory = (filepath, directory)=>{
+    const relativePath = node_path.relative(directory, node_path.resolve(filepath));
+    return '' === relativePath || '..' !== relativePath && !relativePath.startsWith(`..${node_path.sep}`) && !node_path.isAbsolute(relativePath);
+};
 const parseKey = (key)=>{
     const _blank = ' ';
     const splitted = key.split(_blank).filter(Boolean);
@@ -21,21 +26,22 @@ const parseKey = (key)=>{
         path: key
     };
 };
-const getMockModule = async (pwd)=>{
+const getMockModule = async (pwd, mockDir)=>{
     const exts = [
         '.ts',
         '.js'
     ];
     let mockFilePath = '';
+    const mockDirectory = resolveMockDirectory(pwd, mockDir);
     for (const ext of exts){
-        const maybeMatch = node_path.join(pwd, `${AGGRED_DIR.mock}/index${ext}`);
+        const maybeMatch = node_path.join(mockDirectory, `index${ext}`);
         if (await fs.pathExists(maybeMatch)) {
             mockFilePath = maybeMatch;
             break;
         }
     }
     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!`);
@@ -55,8 +61,8 @@ const getMatched = (request, mockApis)=>{
     });
     return matched;
 };
-async function initOrUpdateMockMiddlewares(pwd) {
-    const mockModule = await getMockModule(pwd);
+async function initOrUpdateMockMiddlewares(pwd, mockDir) {
+    const mockModule = await getMockModule(pwd, mockDir);
     mockConfig = mockModule?.config;
     mockAPIs = Object.entries(mockModule?.mockHandlers || {}).map(([key, handler])=>{
         const { method, path } = parseKey(key);
@@ -67,8 +73,8 @@ async function initOrUpdateMockMiddlewares(pwd) {
         };
     });
 }
-async function getMockMiddleware(pwd) {
-    await initOrUpdateMockMiddlewares(pwd);
+async function getMockMiddleware(pwd, mockDir) {
+    await initOrUpdateMockMiddlewares(pwd, mockDir);
     const mockMiddleware = async (c, next)=>{
         if ('function' == typeof mockConfig?.enable) {
             const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
@@ -84,4 +90,4 @@ async function getMockMiddleware(pwd) {
     };
     return mockMiddleware;
 }
-export { getMatched, getMockMiddleware, initOrUpdateMockMiddlewares };
+export { getMatched, getMockMiddleware, initOrUpdateMockMiddlewares, isPathInsideDirectory, resolveMockDirectory };

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,20 @@
-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 './devOptions';
 export * from './fileReader';
 export * from './mock';
 export * from './repack';
-export declare function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server, }: {
+export declare function startWatcher({ pwd, distDir, apiDir, sharedDir, mockDir, watchOptions, onChange, }: {
     pwd: string;
     distDir: string;
     apiDir: string;
     sharedDir: string;
+    mockDir?: 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/dist/types/helpers/mock.d.ts

@@ -10,7 +10,9 @@ type MockAPI = {
     path: string;
     handler: MockHandler;
 };
+export declare const resolveMockDirectory: (pwd: string, mockDir?: string) => string;
+export declare const isPathInsideDirectory: (filepath: string, directory: string) => boolean;
 export declare const getMatched: (request: InternalRequest, mockApis: MockAPI[]) => MockAPI | undefined;
-export declare function initOrUpdateMockMiddlewares(pwd: string): Promise<void>;
-export declare function getMockMiddleware(pwd: string): Promise<Middleware>;
+export declare function initOrUpdateMockMiddlewares(pwd: string, mockDir?: string): Promise<void>;
+export declare function getMockMiddleware(pwd: string, mockDir?: string): Promise<Middleware>;
 export {};

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.98",
+  "version": "3.8.1-ultramodern.1",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -38,11 +38,11 @@
     }
   },
   "dependencies": {
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.98",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.5.0-ultramodern.98",
-    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.5.0-ultramodern.98",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.98",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.98",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.8.1-ultramodern.1",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.8.1-ultramodern.1",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.8.1-ultramodern.1",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.8.1-ultramodern.1",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.8.1-ultramodern.1",
     "@swc/helpers": "^0.5.23",
     "axios": "^1.18.1",
     "connect-history-api-fallback": "^2.0.0",
@@ -52,11 +52,11 @@
     "ws": "^8.21.0"
   },
   "devDependencies": {
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.5.0-ultramodern.98",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.8.1-ultramodern.1",
     "@rslib/core": "0.23.2",
     "@scripts/rstest-config": "2.66.0",
     "@types/connect-history-api-fallback": "^1.5.4",
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.2.0",
     "@types/ws": "^8.18.1",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "node-mocks-http": "^1.18.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,
 });