@bleedingdev/modern-js-server 3.9.0-ultramodern.4 → 3.9.0-ultramodern.5

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/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-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/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.4",
+  "version": "3.9.0-ultramodern.5",
   "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.4",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.4",
-    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.4",
-    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.4",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.4",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.4",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.5",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.5",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.5",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.5",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.5",
     "@swc/helpers": "^0.5.23",
     "connect-history-api-fallback": "^2.0.0",
     "http-compression": "1.1.3",
@@ -52,7 +51,7 @@
     "ws": "^8.21.3"
   },
   "devDependencies": {
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.4",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.5",
     "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
     "@types/connect-history-api-fallback": "^1.5.4",