@bleedingdev/modern-js-server 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/cjs/createDevServer.js

@@ -43,7 +43,6 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const server_core_namespaceObject = require("@modern-js/server-core");
 const node_namespaceObject = require("@modern-js/server-core/node");
-const runtime_lifecycle_namespaceObject = require("@modern-js/server-runtime-extensions/runtime-lifecycle");
 const utils_namespaceObject = require("@modern-js/utils");
 const external_dev_js_namespaceObject = require("./dev.js");
 const reloadManager_js_namespaceObject = require("./dev-tools/reloadManager.js");
@@ -98,12 +97,17 @@ async function createDevServer(options, applyPlugins) {
                 builderDevServer
             }, compiler)
         ]);
-        const handle = await (0, runtime_lifecycle_namespaceObject.initializeDisposableServerRuntime)(runtimeServer, runtimeServer.handle, async ()=>{
+        try {
             await applyPlugins(runtimeServer, runtimeOptions, nodeServer);
             await runtimeServer.init();
-        });
+        } catch (error) {
+            await runtimeServer.dispose().catch((disposeError)=>{
+                utils_namespaceObject.logger.error(disposeError);
+            });
+            throw error;
+        }
         nextRuntimeServer = runtimeServer;
-        return handle;
+        return (0, reloadManager_js_namespaceObject.createDrainingHandle)(runtimeServer.handle, ()=>runtimeServer.dispose());
     };
     const pendingReloadFiles = new Set();
     const reloadManager = (0, reloadManager_js_namespaceObject.createReloadManager)({
@@ -122,8 +126,18 @@ async function createDevServer(options, applyPlugins) {
         const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
         nodeServer = await (0, node_namespaceObject.createNodeServer)(reloadManager.handle, httpsOptions, isHttp2);
     } else nodeServer = await (0, node_namespaceObject.createNodeServer)(reloadManager.handle);
-    reloadManager.setHandle(await buildRuntimeServer());
-    currentRuntimeServer = nextRuntimeServer;
+    try {
+        reloadManager.setHandle(await buildRuntimeServer());
+        currentRuntimeServer = nextRuntimeServer;
+    } catch (error) {
+        reloadManager.close();
+        const cleanup = await Promise.allSettled([
+            Promise.resolve().then(()=>builderDevServer?.close()),
+            Promise.resolve().then(()=>nodeServer.close())
+        ]);
+        for (const result of cleanup)if ('rejected' === result.status) utils_namespaceObject.logger.error(result.reason);
+        throw error;
+    }
     (0, external_dev_js_namespaceObject.setupDevInfra)({
         config,
         pwd,
@@ -135,6 +149,7 @@ async function createDevServer(options, applyPlugins) {
         compiler,
         nodeServer,
         getRuntimeServer: ()=>currentRuntimeServer,
+        holdRequests: (task)=>reloadManager.hold(task),
         onFileChange: (filepath)=>{
             pendingReloadFiles.add(external_node_path_default().relative(pwd, filepath));
             reloadManager.schedule();

package/dist/cjs/dev-tools/reloadManager.js

@@ -29,6 +29,7 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     ReloadManager: ()=>ReloadManager,
+    createDrainingHandle: ()=>createDrainingHandle,
     createReloadManager: ()=>createReloadManager
 });
 const utils_namespaceObject = require("@modern-js/utils");
@@ -71,6 +72,35 @@ function _class_private_method_init(obj, privateSet) {
     _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
+function createDrainingHandle(handle, dispose) {
+    let activeRequests = 0;
+    let retired = false;
+    let resolveDrained;
+    let disposePromise;
+    return Object.assign(async (request, ...args)=>{
+        if (retired) throw new Error('Cannot dispatch through a retired server runtime.');
+        activeRequests += 1;
+        try {
+            return await handle(request, ...args);
+        } finally{
+            activeRequests -= 1;
+            if (0 === activeRequests) resolveDrained?.();
+        }
+    }, {
+        dispose: ()=>{
+            if (!disposePromise) {
+                retired = true;
+                disposePromise = Promise.resolve().then(async ()=>{
+                    if (activeRequests > 0) await new Promise((resolve)=>{
+                        resolveDrained = resolve;
+                    });
+                    await dispose();
+                });
+            }
+            return disposePromise;
+        }
+    });
+}
 const DEFAULT_DEBOUNCE_MS = 300;
 const notReadyHandle = ()=>new Response('Dev server is starting…', {
         status: 503,
@@ -78,13 +108,21 @@ const notReadyHandle = ()=>new Response('Dev server is starting…', {
             '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(), _dispose = /*#__PURE__*/ new WeakSet();
+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(), _held = /*#__PURE__*/ new WeakMap(), _holding = /*#__PURE__*/ new WeakMap(), _released = /*#__PURE__*/ new WeakSet(), _runLoop = /*#__PURE__*/ new WeakSet(), _reportBuildError = /*#__PURE__*/ new WeakSet(), _reportReloadCallbackError = /*#__PURE__*/ new WeakSet(), _dispose = /*#__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);
+        return (request, ...args)=>0 === _class_private_field_get(this, _holding) ? _class_private_field_get(this, _current).call(this, request, ...args) : _class_private_method_get(this, _released, released).call(this).then(()=>_class_private_field_get(this, _current).call(this, request, ...args));
+    }
+    hold(task) {
+        _class_private_field_set(this, _holding, _class_private_field_get(this, _holding) + 1);
+        const run = _class_private_field_get(this, _held).then(task).finally(()=>{
+            _class_private_field_set(this, _holding, _class_private_field_get(this, _holding) - 1);
+        });
+        _class_private_field_set(this, _held, run.catch(()=>{}));
+        return run;
     }
     get currentHandle() {
         return _class_private_field_get(this, _current);
@@ -123,9 +161,11 @@ class ReloadManager {
             clearTimeout(_class_private_field_get(this, _debounceTimer));
             _class_private_field_set(this, _debounceTimer, null);
         }
-        _class_private_method_get(this, _dispose, dispose).call(this, _class_private_field_get(this, _current));
+        const current = _class_private_field_get(this, _current);
+        _class_private_method_get(this, _released, released).call(this).then(()=>_class_private_method_get(this, _dispose, reloadManager_dispose).call(this, current));
     }
     constructor(options){
+        _class_private_method_init(this, _released);
         _class_private_method_init(this, _runLoop);
         _class_private_method_init(this, _reportBuildError);
         _class_private_method_init(this, _reportReloadCallbackError);
@@ -174,11 +214,21 @@ class ReloadManager {
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _held, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _holding, {
+            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, _held, Promise.resolve());
+        _class_private_field_set(this, _holding, 0);
         _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);
@@ -187,6 +237,9 @@ class ReloadManager {
         _class_private_field_set(this, _onReloadError, options.onReloadError);
     }
 }
+async function released() {
+    while(_class_private_field_get(this, _holding) > 0)await _class_private_field_get(this, _held);
+}
 async function runLoop() {
     var _this, _this1;
     do {
@@ -198,15 +251,19 @@ async function runLoop() {
             _class_private_method_get(this, _reportBuildError, reportBuildError).call(this, error);
             continue;
         }
-        if (_class_private_field_get(this, _closed)) return void await _class_private_method_get(this, _dispose, dispose).call(this, next);
+        await _class_private_method_get(this, _released, released).call(this);
+        if (_class_private_field_get(this, _closed)) return void await _class_private_method_get(this, _dispose, reloadManager_dispose).call(this, next);
         const previous = _class_private_field_get(this, _current);
         _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);
+            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);
+            }
+        } finally{
+            await _class_private_method_get(this, _dispose, reloadManager_dispose).call(this, previous);
         }
-        await _class_private_method_get(this, _dispose, dispose).call(this, previous);
     }while (_class_private_field_get(this, _pending) && !_class_private_field_get(this, _closed));
 }
 function reportBuildError(error) {
@@ -217,7 +274,7 @@ function reportReloadCallbackError(error) {
     if (_class_private_field_get(this, _onReloadError)) _class_private_field_get(this, _onReloadError).call(this, error);
     else utils_namespaceObject.logger.warn(`[dev-server] onReload callback failed after a successful swap (handle is already active):\n${error instanceof Error ? error.stack ?? error.message : error}`);
 }
-async function dispose(handle) {
+async function reloadManager_dispose(handle) {
     try {
         await handle.dispose?.();
     } catch (error) {
@@ -228,9 +285,11 @@ function createReloadManager(options) {
     return new ReloadManager(options);
 }
 exports.ReloadManager = __webpack_exports__.ReloadManager;
+exports.createDrainingHandle = __webpack_exports__.createDrainingHandle;
 exports.createReloadManager = __webpack_exports__.createReloadManager;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ReloadManager",
+    "createDrainingHandle",
     "createReloadManager"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/dev-tools/watcher/dependencyTree.js

@@ -69,34 +69,28 @@ class DependencyTree {
         for (const treeNode of this.tree.values()){
             const { parent } = treeNode.module;
             const { children } = treeNode.module;
-            if (parent && !this.shouldIgnore(parent.filename)) {
+            if (parent) {
                 const parentTreeNode = this.tree.get(parent.filename);
                 if (parentTreeNode) treeNode.parent.add(parentTreeNode);
             }
             children?.forEach((child)=>{
-                if (!this.shouldIgnore(child.filename)) {
-                    const childTreeNode = this.tree.get(child.filename);
-                    if (childTreeNode) {
-                        treeNode.children.add(childTreeNode);
-                        childTreeNode.parent.add(treeNode);
-                    }
+                const childTreeNode = this.tree.get(child.filename);
+                if (childTreeNode) {
+                    treeNode.children.add(childTreeNode);
+                    childTreeNode.parent.add(treeNode);
                 }
             });
         }
     }
     shouldIgnore(path) {
         const matchPath = path && external_node_path_default().isAbsolute(path) ? external_node_path_default().relative(process.cwd(), path) : path;
-        return !matchPath || Boolean(this.ignore.find((rule)=>external_minimatch_namespaceObject.match([
-                matchPath
-            ], rule, {
-                dot: true
-            }).length > 0));
+        return !matchPath || this.ignore.some((rule)=>rule.match(matchPath));
     }
     constructor(){
         this.tree = new Map();
-        this.ignore = [
-            ...defaultIgnores
-        ];
+        this.ignore = defaultIgnores.map((rule)=>new external_minimatch_namespaceObject.Minimatch(rule, {
+                dot: true
+            }));
     }
 }
 exports.DependencyTree = __webpack_exports__.DependencyTree;

package/dist/cjs/dev-tools/watcher/index.js

@@ -49,7 +49,7 @@ const external_dependencyTree_js_namespaceObject = require("./dependencyTree.js"
 const external_statsCache_js_namespaceObject = require("./statsCache.js");
 const defaultWatchOptions = {
     ignoreInitial: true,
-    ignored: /api\/typings\/.*/
+    ignored: /api\/typings\/.*|(?:^|[/\\])node_modules(?:[/\\]|$)/
 };
 const getWatchedFiles = (watcher)=>{
     const watched = watcher.getWatched();

package/dist/cjs/dev.js

@@ -81,7 +81,7 @@ const devRuntimeMiddlewarePlugin = (options, compiler)=>({
             });
         }
     });
-function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, onFileChange, onClose, nodeServer }) {
+function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, holdRequests, onFileChange, onClose, nodeServer }) {
     const { close, connectWebSocket } = builderDevServer || {};
     const closeCb = [];
     close && closeCb.push(close);
@@ -91,10 +91,10 @@ function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, build
     builder?.onDevCompileDone(({ stats })=>{
         if ('server' !== stats.toJson({
             all: false
-        }).name) {
+        }).name) holdRequests(async ()=>{
             const runtimeServer = getRuntimeServer();
-            if (runtimeServer) (0, index_js_namespaceObject.onRepack)(distDir, runtimeServer.hooks);
-        }
+            if (runtimeServer) await (0, index_js_namespaceObject.onRepack)(distDir, runtimeServer.hooks);
+        }).catch((error)=>utils_namespaceObject.logger.error(error));
     });
     const { watchOptions } = config.server;
     const mockDir = config.dev?.mockDir;

package/dist/cjs/helpers/mock.js

@@ -129,7 +129,7 @@ async function getMockMiddleware(pwd, mockDir) {
         if (matchedMockAPI) {
             const { handler } = matchedMockAPI;
             if ('function' == typeof handler) return await (0, node_namespaceObject.connectMockMid2HonoMid)(handler)(c, next);
-            return c.json(handler);
+            else return c.json(handler);
         }
         return next();
     };

package/dist/cjs/helpers/repack.js

@@ -36,14 +36,17 @@ const cleanSSRCache = (distDir)=>{
         if (key.startsWith(distDir)) delete require.cache[key];
     });
 };
-const onRepack = (distDir, hooks)=>{
-    cleanSSRCache(distDir);
-    fileReader_namespaceObject.fileReader.reset();
-    hooks.onReset.call({
-        event: {
-            type: 'repack'
-        }
-    });
+const onRepack = async (distDir, hooks)=>{
+    try {
+        await hooks.onReset.call({
+            event: {
+                type: 'repack'
+            }
+        });
+    } finally{
+        cleanSSRCache(distDir);
+        fileReader_namespaceObject.fileReader.reset();
+    }
 };
 exports.onRepack = __webpack_exports__.onRepack;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/esm/createDevServer.mjs

@@ -1,10 +1,9 @@
 import node_path from "node:path";
 import { createServerBase } from "@modern-js/server-core";
 import { createNodeServer, loadServerRuntimeConfig } from "@modern-js/server-core/node";
-import { initializeDisposableServerRuntime } from "@modern-js/server-runtime-extensions/runtime-lifecycle";
 import { logger } from "@modern-js/utils";
 import { devRuntimeMiddlewarePlugin, setupDevInfra } from "./dev.mjs";
-import { createReloadManager } from "./dev-tools/reloadManager.mjs";
+import { createDrainingHandle, createReloadManager } from "./dev-tools/reloadManager.mjs";
 import { createRuntimeServerOptions } from "./dev-tools/runtimeOptions.mjs";
 import { getDevAssetPrefix, getDevOptions } from "./helpers/index.mjs";
 async function createDevServer(options, applyPlugins) {
@@ -56,12 +55,17 @@ async function createDevServer(options, applyPlugins) {
                 builderDevServer
             }, compiler)
         ]);
-        const handle = await initializeDisposableServerRuntime(runtimeServer, runtimeServer.handle, async ()=>{
+        try {
             await applyPlugins(runtimeServer, runtimeOptions, nodeServer);
             await runtimeServer.init();
-        });
+        } catch (error) {
+            await runtimeServer.dispose().catch((disposeError)=>{
+                logger.error(disposeError);
+            });
+            throw error;
+        }
         nextRuntimeServer = runtimeServer;
-        return handle;
+        return createDrainingHandle(runtimeServer.handle, ()=>runtimeServer.dispose());
     };
     const pendingReloadFiles = new Set();
     const reloadManager = createReloadManager({
@@ -80,8 +84,18 @@ async function createDevServer(options, applyPlugins) {
         const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
         nodeServer = await createNodeServer(reloadManager.handle, httpsOptions, isHttp2);
     } else nodeServer = await createNodeServer(reloadManager.handle);
-    reloadManager.setHandle(await buildRuntimeServer());
-    currentRuntimeServer = nextRuntimeServer;
+    try {
+        reloadManager.setHandle(await buildRuntimeServer());
+        currentRuntimeServer = nextRuntimeServer;
+    } catch (error) {
+        reloadManager.close();
+        const cleanup = await Promise.allSettled([
+            Promise.resolve().then(()=>builderDevServer?.close()),
+            Promise.resolve().then(()=>nodeServer.close())
+        ]);
+        for (const result of cleanup)if ('rejected' === result.status) logger.error(result.reason);
+        throw error;
+    }
     setupDevInfra({
         config,
         pwd,
@@ -93,6 +107,7 @@ async function createDevServer(options, applyPlugins) {
         compiler,
         nodeServer,
         getRuntimeServer: ()=>currentRuntimeServer,
+        holdRequests: (task)=>reloadManager.hold(task),
         onFileChange: (filepath)=>{
             pendingReloadFiles.add(node_path.relative(pwd, filepath));
             reloadManager.schedule();

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

@@ -38,6 +38,35 @@ function _class_private_method_init(obj, privateSet) {
     _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
+function createDrainingHandle(handle, dispose) {
+    let activeRequests = 0;
+    let retired = false;
+    let resolveDrained;
+    let disposePromise;
+    return Object.assign(async (request, ...args)=>{
+        if (retired) throw new Error('Cannot dispatch through a retired server runtime.');
+        activeRequests += 1;
+        try {
+            return await handle(request, ...args);
+        } finally{
+            activeRequests -= 1;
+            if (0 === activeRequests) resolveDrained?.();
+        }
+    }, {
+        dispose: ()=>{
+            if (!disposePromise) {
+                retired = true;
+                disposePromise = Promise.resolve().then(async ()=>{
+                    if (activeRequests > 0) await new Promise((resolve)=>{
+                        resolveDrained = resolve;
+                    });
+                    await dispose();
+                });
+            }
+            return disposePromise;
+        }
+    });
+}
 const DEFAULT_DEBOUNCE_MS = 300;
 const notReadyHandle = ()=>new Response('Dev server is starting…', {
         status: 503,
@@ -45,13 +74,21 @@ const notReadyHandle = ()=>new Response('Dev server is starting…', {
             '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(), _dispose = /*#__PURE__*/ new WeakSet();
+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(), _held = /*#__PURE__*/ new WeakMap(), _holding = /*#__PURE__*/ new WeakMap(), _released = /*#__PURE__*/ new WeakSet(), _runLoop = /*#__PURE__*/ new WeakSet(), _reportBuildError = /*#__PURE__*/ new WeakSet(), _reportReloadCallbackError = /*#__PURE__*/ new WeakSet(), _dispose = /*#__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);
+        return (request, ...args)=>0 === _class_private_field_get(this, _holding) ? _class_private_field_get(this, _current).call(this, request, ...args) : _class_private_method_get(this, _released, released).call(this).then(()=>_class_private_field_get(this, _current).call(this, request, ...args));
+    }
+    hold(task) {
+        _class_private_field_set(this, _holding, _class_private_field_get(this, _holding) + 1);
+        const run = _class_private_field_get(this, _held).then(task).finally(()=>{
+            _class_private_field_set(this, _holding, _class_private_field_get(this, _holding) - 1);
+        });
+        _class_private_field_set(this, _held, run.catch(()=>{}));
+        return run;
     }
     get currentHandle() {
         return _class_private_field_get(this, _current);
@@ -90,9 +127,11 @@ class ReloadManager {
             clearTimeout(_class_private_field_get(this, _debounceTimer));
             _class_private_field_set(this, _debounceTimer, null);
         }
-        _class_private_method_get(this, _dispose, dispose).call(this, _class_private_field_get(this, _current));
+        const current = _class_private_field_get(this, _current);
+        _class_private_method_get(this, _released, released).call(this).then(()=>_class_private_method_get(this, _dispose, reloadManager_dispose).call(this, current));
     }
     constructor(options){
+        _class_private_method_init(this, _released);
         _class_private_method_init(this, _runLoop);
         _class_private_method_init(this, _reportBuildError);
         _class_private_method_init(this, _reportReloadCallbackError);
@@ -141,11 +180,21 @@ class ReloadManager {
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _held, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _holding, {
+            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, _held, Promise.resolve());
+        _class_private_field_set(this, _holding, 0);
         _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);
@@ -154,6 +203,9 @@ class ReloadManager {
         _class_private_field_set(this, _onReloadError, options.onReloadError);
     }
 }
+async function released() {
+    while(_class_private_field_get(this, _holding) > 0)await _class_private_field_get(this, _held);
+}
 async function runLoop() {
     var _this, _this1;
     do {
@@ -165,15 +217,19 @@ async function runLoop() {
             _class_private_method_get(this, _reportBuildError, reportBuildError).call(this, error);
             continue;
         }
-        if (_class_private_field_get(this, _closed)) return void await _class_private_method_get(this, _dispose, dispose).call(this, next);
+        await _class_private_method_get(this, _released, released).call(this);
+        if (_class_private_field_get(this, _closed)) return void await _class_private_method_get(this, _dispose, reloadManager_dispose).call(this, next);
         const previous = _class_private_field_get(this, _current);
         _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);
+            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);
+            }
+        } finally{
+            await _class_private_method_get(this, _dispose, reloadManager_dispose).call(this, previous);
         }
-        await _class_private_method_get(this, _dispose, dispose).call(this, previous);
     }while (_class_private_field_get(this, _pending) && !_class_private_field_get(this, _closed))
 }
 function reportBuildError(error) {
@@ -184,7 +240,7 @@ 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}`);
 }
-async function dispose(handle) {
+async function reloadManager_dispose(handle) {
     try {
         await handle.dispose?.();
     } catch (error) {
@@ -194,4 +250,4 @@ async function dispose(handle) {
 function createReloadManager(options) {
     return new ReloadManager(options);
 }
-export { ReloadManager, createReloadManager };
+export { ReloadManager, createDrainingHandle, createReloadManager };

package/dist/esm/dev-tools/watcher/dependencyTree.mjs

@@ -26,34 +26,28 @@ class DependencyTree {
         for (const treeNode of this.tree.values()){
             const { parent } = treeNode.module;
             const { children } = treeNode.module;
-            if (parent && !this.shouldIgnore(parent.filename)) {
+            if (parent) {
                 const parentTreeNode = this.tree.get(parent.filename);
                 if (parentTreeNode) treeNode.parent.add(parentTreeNode);
             }
             children?.forEach((child)=>{
-                if (!this.shouldIgnore(child.filename)) {
-                    const childTreeNode = this.tree.get(child.filename);
-                    if (childTreeNode) {
-                        treeNode.children.add(childTreeNode);
-                        childTreeNode.parent.add(treeNode);
-                    }
+                const childTreeNode = this.tree.get(child.filename);
+                if (childTreeNode) {
+                    treeNode.children.add(childTreeNode);
+                    childTreeNode.parent.add(treeNode);
                 }
             });
         }
     }
     shouldIgnore(path) {
         const matchPath = path && node_path.isAbsolute(path) ? node_path.relative(process.cwd(), path) : path;
-        return !matchPath || Boolean(this.ignore.find((rule)=>__rspack_external_minimatch.match([
-                matchPath
-            ], rule, {
-                dot: true
-            }).length > 0));
+        return !matchPath || this.ignore.some((rule)=>rule.match(matchPath));
     }
     constructor(){
         this.tree = new Map();
-        this.ignore = [
-            ...defaultIgnores
-        ];
+        this.ignore = defaultIgnores.map((rule)=>new __rspack_external_minimatch.Minimatch(rule, {
+                dot: true
+            }));
     }
 }
 export { DependencyTree, defaultIgnores };

package/dist/esm/dev-tools/watcher/index.mjs

@@ -4,7 +4,7 @@ import { DependencyTree } from "./dependencyTree.mjs";
 import { StatsCache } from "./statsCache.mjs";
 const defaultWatchOptions = {
     ignoreInitial: true,
-    ignored: /api\/typings\/.*/
+    ignored: /api\/typings\/.*|(?:^|[/\\])node_modules(?:[/\\]|$)/
 };
 const getWatchedFiles = (watcher)=>{
     const watched = watcher.getWatched();

package/dist/esm/dev.mjs

@@ -48,7 +48,7 @@ const devRuntimeMiddlewarePlugin = (options, compiler)=>({
             });
         }
     });
-function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, onFileChange, onClose, nodeServer }) {
+function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, holdRequests, onFileChange, onClose, nodeServer }) {
     const { close, connectWebSocket } = builderDevServer || {};
     const closeCb = [];
     close && closeCb.push(close);
@@ -58,10 +58,10 @@ function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, build
     builder?.onDevCompileDone(({ stats })=>{
         if ('server' !== stats.toJson({
             all: false
-        }).name) {
+        }).name) holdRequests(async ()=>{
             const runtimeServer = getRuntimeServer();
-            if (runtimeServer) onRepack(distDir, runtimeServer.hooks);
-        }
+            if (runtimeServer) await onRepack(distDir, runtimeServer.hooks);
+        }).catch((error)=>logger.error(error));
     });
     const { watchOptions } = config.server;
     const mockDir = config.dev?.mockDir;

package/dist/esm/helpers/mock.mjs

@@ -83,7 +83,7 @@ async function getMockMiddleware(pwd, mockDir) {
         if (matchedMockAPI) {
             const { handler } = matchedMockAPI;
             if ('function' == typeof handler) return await connectMockMid2HonoMid(handler)(c, next);
-            return c.json(handler);
+            else return c.json(handler);
         }
         return next();
     };

package/dist/esm/helpers/repack.mjs

@@ -4,13 +4,16 @@ const cleanSSRCache = (distDir)=>{
         if (key.startsWith(distDir)) delete require.cache[key];
     });
 };
-const onRepack = (distDir, hooks)=>{
-    cleanSSRCache(distDir);
-    fileReader.reset();
-    hooks.onReset.call({
-        event: {
-            type: 'repack'
-        }
-    });
+const onRepack = async (distDir, hooks)=>{
+    try {
+        await hooks.onReset.call({
+            event: {
+                type: 'repack'
+            }
+        });
+    } finally{
+        cleanSSRCache(distDir);
+        fileReader.reset();
+    }
 };
 export { onRepack };

package/dist/esm-node/createDevServer.mjs

@@ -2,10 +2,9 @@ import "node:module";
 import node_path from "node:path";
 import { createServerBase } from "@modern-js/server-core";
 import { createNodeServer, loadServerRuntimeConfig } from "@modern-js/server-core/node";
-import { initializeDisposableServerRuntime } from "@modern-js/server-runtime-extensions/runtime-lifecycle";
 import { logger } from "@modern-js/utils";
 import { devRuntimeMiddlewarePlugin, setupDevInfra } from "./dev.mjs";
-import { createReloadManager } from "./dev-tools/reloadManager.mjs";
+import { createDrainingHandle, createReloadManager } from "./dev-tools/reloadManager.mjs";
 import { createRuntimeServerOptions } from "./dev-tools/runtimeOptions.mjs";
 import { getDevAssetPrefix, getDevOptions } from "./helpers/index.mjs";
 async function createDevServer(options, applyPlugins) {
@@ -57,12 +56,17 @@ async function createDevServer(options, applyPlugins) {
                 builderDevServer
             }, compiler)
         ]);
-        const handle = await initializeDisposableServerRuntime(runtimeServer, runtimeServer.handle, async ()=>{
+        try {
             await applyPlugins(runtimeServer, runtimeOptions, nodeServer);
             await runtimeServer.init();
-        });
+        } catch (error) {
+            await runtimeServer.dispose().catch((disposeError)=>{
+                logger.error(disposeError);
+            });
+            throw error;
+        }
         nextRuntimeServer = runtimeServer;
-        return handle;
+        return createDrainingHandle(runtimeServer.handle, ()=>runtimeServer.dispose());
     };
     const pendingReloadFiles = new Set();
     const reloadManager = createReloadManager({
@@ -81,8 +85,18 @@ async function createDevServer(options, applyPlugins) {
         const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
         nodeServer = await createNodeServer(reloadManager.handle, httpsOptions, isHttp2);
     } else nodeServer = await createNodeServer(reloadManager.handle);
-    reloadManager.setHandle(await buildRuntimeServer());
-    currentRuntimeServer = nextRuntimeServer;
+    try {
+        reloadManager.setHandle(await buildRuntimeServer());
+        currentRuntimeServer = nextRuntimeServer;
+    } catch (error) {
+        reloadManager.close();
+        const cleanup = await Promise.allSettled([
+            Promise.resolve().then(()=>builderDevServer?.close()),
+            Promise.resolve().then(()=>nodeServer.close())
+        ]);
+        for (const result of cleanup)if ('rejected' === result.status) logger.error(result.reason);
+        throw error;
+    }
     setupDevInfra({
         config,
         pwd,
@@ -94,6 +108,7 @@ async function createDevServer(options, applyPlugins) {
         compiler,
         nodeServer,
         getRuntimeServer: ()=>currentRuntimeServer,
+        holdRequests: (task)=>reloadManager.hold(task),
         onFileChange: (filepath)=>{
             pendingReloadFiles.add(node_path.relative(pwd, filepath));
             reloadManager.schedule();

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

@@ -39,6 +39,35 @@ function _class_private_method_init(obj, privateSet) {
     _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
+function createDrainingHandle(handle, dispose) {
+    let activeRequests = 0;
+    let retired = false;
+    let resolveDrained;
+    let disposePromise;
+    return Object.assign(async (request, ...args)=>{
+        if (retired) throw new Error('Cannot dispatch through a retired server runtime.');
+        activeRequests += 1;
+        try {
+            return await handle(request, ...args);
+        } finally{
+            activeRequests -= 1;
+            if (0 === activeRequests) resolveDrained?.();
+        }
+    }, {
+        dispose: ()=>{
+            if (!disposePromise) {
+                retired = true;
+                disposePromise = Promise.resolve().then(async ()=>{
+                    if (activeRequests > 0) await new Promise((resolve)=>{
+                        resolveDrained = resolve;
+                    });
+                    await dispose();
+                });
+            }
+            return disposePromise;
+        }
+    });
+}
 const DEFAULT_DEBOUNCE_MS = 300;
 const notReadyHandle = ()=>new Response('Dev server is starting…', {
         status: 503,
@@ -46,13 +75,21 @@ const notReadyHandle = ()=>new Response('Dev server is starting…', {
             '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(), _dispose = /*#__PURE__*/ new WeakSet();
+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(), _held = /*#__PURE__*/ new WeakMap(), _holding = /*#__PURE__*/ new WeakMap(), _released = /*#__PURE__*/ new WeakSet(), _runLoop = /*#__PURE__*/ new WeakSet(), _reportBuildError = /*#__PURE__*/ new WeakSet(), _reportReloadCallbackError = /*#__PURE__*/ new WeakSet(), _dispose = /*#__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);
+        return (request, ...args)=>0 === _class_private_field_get(this, _holding) ? _class_private_field_get(this, _current).call(this, request, ...args) : _class_private_method_get(this, _released, released).call(this).then(()=>_class_private_field_get(this, _current).call(this, request, ...args));
+    }
+    hold(task) {
+        _class_private_field_set(this, _holding, _class_private_field_get(this, _holding) + 1);
+        const run = _class_private_field_get(this, _held).then(task).finally(()=>{
+            _class_private_field_set(this, _holding, _class_private_field_get(this, _holding) - 1);
+        });
+        _class_private_field_set(this, _held, run.catch(()=>{}));
+        return run;
     }
     get currentHandle() {
         return _class_private_field_get(this, _current);
@@ -91,9 +128,11 @@ class ReloadManager {
             clearTimeout(_class_private_field_get(this, _debounceTimer));
             _class_private_field_set(this, _debounceTimer, null);
         }
-        _class_private_method_get(this, _dispose, dispose).call(this, _class_private_field_get(this, _current));
+        const current = _class_private_field_get(this, _current);
+        _class_private_method_get(this, _released, released).call(this).then(()=>_class_private_method_get(this, _dispose, reloadManager_dispose).call(this, current));
     }
     constructor(options){
+        _class_private_method_init(this, _released);
         _class_private_method_init(this, _runLoop);
         _class_private_method_init(this, _reportBuildError);
         _class_private_method_init(this, _reportReloadCallbackError);
@@ -142,11 +181,21 @@ class ReloadManager {
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _held, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _holding, {
+            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, _held, Promise.resolve());
+        _class_private_field_set(this, _holding, 0);
         _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);
@@ -155,6 +204,9 @@ class ReloadManager {
         _class_private_field_set(this, _onReloadError, options.onReloadError);
     }
 }
+async function released() {
+    while(_class_private_field_get(this, _holding) > 0)await _class_private_field_get(this, _held);
+}
 async function runLoop() {
     var _this, _this1;
     do {
@@ -166,15 +218,19 @@ async function runLoop() {
             _class_private_method_get(this, _reportBuildError, reportBuildError).call(this, error);
             continue;
         }
-        if (_class_private_field_get(this, _closed)) return void await _class_private_method_get(this, _dispose, dispose).call(this, next);
+        await _class_private_method_get(this, _released, released).call(this);
+        if (_class_private_field_get(this, _closed)) return void await _class_private_method_get(this, _dispose, reloadManager_dispose).call(this, next);
         const previous = _class_private_field_get(this, _current);
         _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);
+            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);
+            }
+        } finally{
+            await _class_private_method_get(this, _dispose, reloadManager_dispose).call(this, previous);
         }
-        await _class_private_method_get(this, _dispose, dispose).call(this, previous);
     }while (_class_private_field_get(this, _pending) && !_class_private_field_get(this, _closed));
 }
 function reportBuildError(error) {
@@ -185,7 +241,7 @@ 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}`);
 }
-async function dispose(handle) {
+async function reloadManager_dispose(handle) {
     try {
         await handle.dispose?.();
     } catch (error) {
@@ -195,4 +251,4 @@ async function dispose(handle) {
 function createReloadManager(options) {
     return new ReloadManager(options);
 }
-export { ReloadManager, createReloadManager };
+export { ReloadManager, createDrainingHandle, createReloadManager };

package/dist/esm-node/dev-tools/watcher/dependencyTree.mjs

@@ -27,34 +27,28 @@ class DependencyTree {
         for (const treeNode of this.tree.values()){
             const { parent } = treeNode.module;
             const { children } = treeNode.module;
-            if (parent && !this.shouldIgnore(parent.filename)) {
+            if (parent) {
                 const parentTreeNode = this.tree.get(parent.filename);
                 if (parentTreeNode) treeNode.parent.add(parentTreeNode);
             }
             children?.forEach((child)=>{
-                if (!this.shouldIgnore(child.filename)) {
-                    const childTreeNode = this.tree.get(child.filename);
-                    if (childTreeNode) {
-                        treeNode.children.add(childTreeNode);
-                        childTreeNode.parent.add(treeNode);
-                    }
+                const childTreeNode = this.tree.get(child.filename);
+                if (childTreeNode) {
+                    treeNode.children.add(childTreeNode);
+                    childTreeNode.parent.add(treeNode);
                 }
             });
         }
     }
     shouldIgnore(path) {
         const matchPath = path && node_path.isAbsolute(path) ? node_path.relative(process.cwd(), path) : path;
-        return !matchPath || Boolean(this.ignore.find((rule)=>__rspack_external_minimatch.match([
-                matchPath
-            ], rule, {
-                dot: true
-            }).length > 0));
+        return !matchPath || this.ignore.some((rule)=>rule.match(matchPath));
     }
     constructor(){
         this.tree = new Map();
-        this.ignore = [
-            ...defaultIgnores
-        ];
+        this.ignore = defaultIgnores.map((rule)=>new __rspack_external_minimatch.Minimatch(rule, {
+                dot: true
+            }));
     }
 }
 export { DependencyTree, defaultIgnores };

package/dist/esm-node/dev-tools/watcher/index.mjs

@@ -6,7 +6,7 @@ import { DependencyTree } from "./dependencyTree.mjs";
 import { StatsCache } from "./statsCache.mjs";
 const defaultWatchOptions = {
     ignoreInitial: true,
-    ignored: /api\/typings\/.*/
+    ignored: /api\/typings\/.*|(?:^|[/\\])node_modules(?:[/\\]|$)/
 };
 const getWatchedFiles = (watcher)=>{
     const watched = watcher.getWatched();

package/dist/esm-node/dev.mjs

@@ -49,7 +49,7 @@ const devRuntimeMiddlewarePlugin = (options, compiler)=>({
             });
         }
     });
-function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, onFileChange, onClose, nodeServer }) {
+function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, holdRequests, onFileChange, onClose, nodeServer }) {
     const { close, connectWebSocket } = builderDevServer || {};
     const closeCb = [];
     close && closeCb.push(close);
@@ -59,10 +59,10 @@ function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, build
     builder?.onDevCompileDone(({ stats })=>{
         if ('server' !== stats.toJson({
             all: false
-        }).name) {
+        }).name) holdRequests(async ()=>{
             const runtimeServer = getRuntimeServer();
-            if (runtimeServer) onRepack(distDir, runtimeServer.hooks);
-        }
+            if (runtimeServer) await onRepack(distDir, runtimeServer.hooks);
+        }).catch((error)=>logger.error(error));
     });
     const { watchOptions } = config.server;
     const mockDir = config.dev?.mockDir;

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

@@ -84,7 +84,7 @@ async function getMockMiddleware(pwd, mockDir) {
         if (matchedMockAPI) {
             const { handler } = matchedMockAPI;
             if ('function' == typeof handler) return await connectMockMid2HonoMid(handler)(c, next);
-            return c.json(handler);
+            else return c.json(handler);
         }
         return next();
     };

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

@@ -6,13 +6,16 @@ const cleanSSRCache = (distDir)=>{
         if (key.startsWith(distDir)) delete require.cache[key];
     });
 };
-const onRepack = (distDir, hooks)=>{
-    cleanSSRCache(distDir);
-    fileReader.reset();
-    hooks.onReset.call({
-        event: {
-            type: 'repack'
-        }
-    });
+const onRepack = async (distDir, hooks)=>{
+    try {
+        await hooks.onReset.call({
+            event: {
+                type: 'repack'
+            }
+        });
+    } finally{
+        cleanSSRCache(distDir);
+        fileReader.reset();
+    }
 };
 export { onRepack };

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

@@ -5,6 +5,13 @@
 export type ReloadableHandle = ((request: Request, ...args: any[]) => Response | Promise<Response>) & {
     dispose?: () => void | Promise<void>;
 };
+/**
+ * Retire a request handle before waiting for its active handler promises.
+ * This preserves handler completion semantics; response streams are not drained.
+ */
+export declare function createDrainingHandle(handle: ReloadableHandle, dispose: () => void | Promise<void>): ReloadableHandle & {
+    dispose: () => Promise<void>;
+};
 export interface ReloadManagerOptions {
     /**
      * The handle used before the first successful build. Optional: when omitted
@@ -64,6 +71,15 @@ export declare class ReloadManager {
      * be recreated on reload.
      */
     get handle(): ReloadableHandle;
+    /**
+     * Run `task` after the previously held tasks, and make requests arriving
+     * through `handle` wait until it settles. A reload waits for it before it
+     * swaps the runtime. Requests already dispatched are not waited for: an SSR
+     * loader fetching its own dev server would deadlock. The task itself must
+     * not await a request to this handle, which waits for the task.
+     * Returns the task's own result, rejection included.
+     */
+    hold(task: () => Promise<void>): Promise<void>;
     /** The currently active resolved handle (introspection / tests). */
     get currentHandle(): ReloadableHandle;
     /** Whether a reload is currently running (introspection / tests). */

package/dist/types/dev.d.ts

@@ -35,6 +35,11 @@ export interface DevInfraOptions {
     nodeServer?: NodeServer | NodeHttpsServer | Http2SecureServer;
     /** Accessor for the currently-active runtime ServerBase (a mutable ref). */
     getRuntimeServer: () => ServerBase | undefined;
+    /**
+     * Run a repack task while new requests wait for it (`ReloadManager.hold`),
+     * so no request re-requires the server bundle mid-reset.
+     */
+    holdRequests: (task: () => Promise<void>) => Promise<void>;
     /**
      * Triggered when a watched user server file changes (require cache already
      * busted). Wired to the runtime reload scheduler.
@@ -64,5 +69,5 @@ export interface DevInfra {
  * 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 declare function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, holdRequests, onFileChange, onClose, nodeServer, }: DevInfraOptions): DevInfra;
 export {};

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

@@ -1,2 +1,17 @@
 import type { ServerPluginHooks } from '@modern-js/server-core';
-export declare const onRepack: (distDir: string, hooks: ServerPluginHooks) => void;
+/**
+ * Reset the dev server after the server bundle is rebuilt.
+ *
+ * Runtime state a rebuilt bundle keeps outside the require cache belongs to
+ * the plugin that owns it and is reset by that plugin's `onReset` handler:
+ * `@module-federation/modern-js-v3/server` resets the Module Federation
+ * runtime on `globalThis` there (module-federation/core#5152).
+ *
+ * Contract: the `onReset({ event: { type: 'repack' } })` handlers run in
+ * registration order and are awaited before the previous generation is purged.
+ * The caller holds new requests until this promise settles, so no request
+ * re-requires the bundle while a handler is still running. As with every async
+ * server hook, a rejecting handler skips the handlers after it; the generation
+ * is still purged and the promise rejects with that error.
+ */
+export declare const onRepack: (distDir: string, hooks: ServerPluginHooks) => Promise<void>;

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.9.0-ultramodern.2",
+  "version": "3.9.0-ultramodern.21",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -38,12 +38,11 @@
     }
   },
   "dependencies": {
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.2",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.2",
-    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.2",
-    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.2",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.2",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.2",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.21",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.21",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.21",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.21",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.21",
     "@swc/helpers": "^0.5.23",
     "connect-history-api-fallback": "^2.0.0",
     "http-compression": "1.1.3",
@@ -52,11 +51,12 @@
     "ws": "^8.21.3"
   },
   "devDependencies": {
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.2",
-    "@rslib/core": "1.0.0",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.21",
+    "@module-federation/runtime": "2.9.2",
+    "@rslib/core": "1.0.2",
     "@scripts/rstest-config": "2.66.0",
     "@types/connect-history-api-fallback": "^1.5.4",
-    "@types/node": "^26.4.1",
+    "@types/node": "^26.6.2",
     "@types/ws": "^8.18.1",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "node-mocks-http": "^1.18.1",