@bleedingdev/modern-js-server 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

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,

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,
@@ -123,7 +153,7 @@ 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));
+        _class_private_method_get(this, _dispose, reloadManager_dispose).call(this, _class_private_field_get(this, _current));
     }
     constructor(options){
         _class_private_method_init(this, _runLoop);
@@ -198,15 +228,18 @@ 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);
+        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 +250,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 +261,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/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,

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,
@@ -90,7 +119,7 @@ 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));
+        _class_private_method_get(this, _dispose, reloadManager_dispose).call(this, _class_private_field_get(this, _current));
     }
     constructor(options){
         _class_private_method_init(this, _runLoop);
@@ -165,15 +194,18 @@ 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);
+        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 +216,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 +226,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-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,

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,
@@ -91,7 +120,7 @@ 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));
+        _class_private_method_get(this, _dispose, reloadManager_dispose).call(this, _class_private_field_get(this, _current));
     }
     constructor(options){
         _class_private_method_init(this, _runLoop);
@@ -166,15 +195,18 @@ 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);
+        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 +217,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 +227,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/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

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.9.0-ultramodern.1",
+  "version": "3.9.0-ultramodern.11",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -38,28 +38,27 @@
     }
   },
   "dependencies": {
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.1",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.1",
-    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.1",
-    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.1",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.1",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.1",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.11",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.11",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.11",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.11",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.11",
     "@swc/helpers": "^0.5.23",
     "connect-history-api-fallback": "^2.0.0",
     "http-compression": "1.1.3",
-    "minimatch": "^10.2.5",
+    "minimatch": "^10.2.6",
     "path-to-regexp": "^8.4.2",
     "ws": "^8.21.3"
   },
   "devDependencies": {
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.1",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.11",
     "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
     "@types/connect-history-api-fallback": "^1.5.4",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "@types/ws": "^8.18.1",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "node-mocks-http": "^1.18.0",
+    "node-mocks-http": "^1.18.1",
     "tsconfig-paths": "4.2.0",
     "websocket": "^1.0.35"
   },