@bleedingdev/modern-js-server 3.5.0-ultramodern.10 → 3.5.0-ultramodern.100

package/dist/cjs/helpers/index.js

@@ -15,12 +15,6 @@ var __webpack_modules__ = {
     "./repack" (module) {
         module.exports = require("./repack.js");
     },
-    "./utils" (module) {
-        module.exports = require("./utils.js");
-    },
-    "@modern-js/server-core" (module) {
-        module.exports = require("@modern-js/server-core");
-    },
     "@modern-js/utils" (module) {
         module.exports = require("@modern-js/utils");
     },
@@ -75,92 +69,59 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _modern_js_server_core__rspack_import_0 = __webpack_require__("@modern-js/server-core");
-    var _modern_js_utils__rspack_import_1 = __webpack_require__("@modern-js/utils");
-    var path__rspack_import_2 = __webpack_require__("path");
-    var path__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(path__rspack_import_2);
-    var _dev_tools_watcher__rspack_import_3 = __webpack_require__("../dev-tools/watcher");
-    var _dev_tools_watcher__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(_dev_tools_watcher__rspack_import_3);
-    var _mock__rspack_import_4 = __webpack_require__("./mock");
-    var _utils__rspack_import_5 = __webpack_require__("./utils");
-    var _devOptions__rspack_import_6 = __webpack_require__("./devOptions");
+    var _modern_js_utils__rspack_import_0 = __webpack_require__("@modern-js/utils");
+    var path__rspack_import_1 = __webpack_require__("path");
+    var path__rspack_import_1_default = /*#__PURE__*/ __webpack_require__.n(path__rspack_import_1);
+    var _dev_tools_watcher__rspack_import_2 = __webpack_require__("../dev-tools/watcher");
+    var _dev_tools_watcher__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(_dev_tools_watcher__rspack_import_2);
+    var _mock__rspack_import_3 = __webpack_require__("./mock");
+    var _devOptions__rspack_import_4 = __webpack_require__("./devOptions");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _devOptions__rspack_import_6)if ([
+    for(const __rspack_import_key in _devOptions__rspack_import_4)if ([
         "startWatcher",
         "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_devOptions__rspack_import_6[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_devOptions__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _fileReader__rspack_import_7 = __webpack_require__("./fileReader");
+    var _fileReader__rspack_import_5 = __webpack_require__("./fileReader");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _fileReader__rspack_import_7)if ([
+    for(const __rspack_import_key in _fileReader__rspack_import_5)if ([
         "startWatcher",
         "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_fileReader__rspack_import_7[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_fileReader__rspack_import_5[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _mock__rspack_import_4)if ([
+    for(const __rspack_import_key in _mock__rspack_import_3)if ([
         "startWatcher",
         "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_mock__rspack_import_4[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_mock__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _repack__rspack_import_8 = __webpack_require__("./repack");
+    var _repack__rspack_import_6 = __webpack_require__("./repack");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _repack__rspack_import_8)if ([
+    for(const __rspack_import_key in _repack__rspack_import_6)if ([
         "startWatcher",
         "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_repack__rspack_import_8[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_repack__rspack_import_6[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    async function onServerChange({ pwd, filepath, event, server }) {
-        const { mock } = _modern_js_server_core__rspack_import_0.AGGRED_DIR;
-        const mockPath = path__rspack_import_2_default().normalize(path__rspack_import_2_default().join(pwd, mock));
-        const { hooks } = server;
-        if (filepath.startsWith(mockPath)) {
-            await (0, _mock__rspack_import_4.initOrUpdateMockMiddlewares)(pwd);
-            _modern_js_utils__rspack_import_1.logger.info('Finish update the mock handlers');
-        } else try {
-            const fileChangeEvent = {
-                type: 'file-change',
-                payload: [
-                    {
-                        filename: filepath,
-                        event
-                    }
-                ]
-            };
-            await hooks.onReset.call({
-                event: fileChangeEvent
-            });
-            (0, _utils__rspack_import_5.debug)(`Finish reload server, trigger by ${filepath} ${event}`);
-        } catch (e) {
-            _modern_js_utils__rspack_import_1.logger.error(e);
-        }
-    }
-    function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
-        const { mock } = _modern_js_server_core__rspack_import_0.AGGRED_DIR;
+    function startWatcher({ pwd, distDir, apiDir, sharedDir, mockDir, watchOptions, onChange }) {
         const defaultWatched = [
-            `${mock}/**/*`,
-            `${_modern_js_utils__rspack_import_1.SERVER_DIR}/**/*`,
+            path__rspack_import_1_default().join((0, _mock__rspack_import_3.resolveMockDirectory)(pwd, mockDir), '**/*'),
+            `${_modern_js_utils__rspack_import_0.SERVER_DIR}/**/*`,
             `${apiDir}/**`,
             `${sharedDir}/**/*`,
-            `${distDir}/${_modern_js_utils__rspack_import_1.SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+            `${distDir}/${_modern_js_utils__rspack_import_0.SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
         ];
-        const mergedWatchOptions = (0, _dev_tools_watcher__rspack_import_3.mergeWatchOptions)(watchOptions);
+        const mergedWatchOptions = (0, _dev_tools_watcher__rspack_import_2.mergeWatchOptions)(watchOptions);
         const defaultWatchedPaths = defaultWatched.map((p)=>{
-            const finalPath = path__rspack_import_2_default().isAbsolute(p) ? p : path__rspack_import_2_default().join(pwd, p);
-            return path__rspack_import_2_default().normalize(finalPath);
+            const finalPath = path__rspack_import_1_default().isAbsolute(p) ? p : path__rspack_import_1_default().join(pwd, p);
+            return path__rspack_import_1_default().normalize(finalPath);
         });
-        const watcher = new (_dev_tools_watcher__rspack_import_3_default())();
+        const watcher = new (_dev_tools_watcher__rspack_import_2_default())();
         watcher.createDepTree();
         watcher.listen(defaultWatchedPaths, mergedWatchOptions, (filepath, event)=>{
             if (filepath.includes('-server-loaders.js')) return void delete require.cache[filepath];
             watcher.updateDepTree();
             watcher.cleanDepCache(filepath);
-            onServerChange({
-                pwd,
-                filepath,
-                event,
-                server
-            });
+            onChange(filepath, event);
         });
         return watcher;
     }

package/dist/cjs/helpers/mock.js

@@ -39,7 +39,9 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     getMatched: ()=>getMatched,
     getMockMiddleware: ()=>getMockMiddleware,
-    initOrUpdateMockMiddlewares: ()=>initOrUpdateMockMiddlewares
+    initOrUpdateMockMiddlewares: ()=>initOrUpdateMockMiddlewares,
+    isPathInsideDirectory: ()=>isPathInsideDirectory,
+    resolveMockDirectory: ()=>resolveMockDirectory
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
@@ -49,6 +51,11 @@ const utils_namespaceObject = require("@modern-js/utils");
 const external_path_to_regexp_namespaceObject = require("path-to-regexp");
 let mockAPIs = [];
 let mockConfig;
+const resolveMockDirectory = (pwd, mockDir = server_core_namespaceObject.AGGRED_DIR.mock)=>external_node_path_default().resolve(pwd, mockDir);
+const isPathInsideDirectory = (filepath, directory)=>{
+    const relativePath = external_node_path_default().relative(directory, external_node_path_default().resolve(filepath));
+    return '' === relativePath || '..' !== relativePath && !relativePath.startsWith(`..${external_node_path_default().sep}`) && !external_node_path_default().isAbsolute(relativePath);
+};
 const parseKey = (key)=>{
     const _blank = ' ';
     const splitted = key.split(_blank).filter(Boolean);
@@ -64,21 +71,22 @@ const parseKey = (key)=>{
         path: key
     };
 };
-const getMockModule = async (pwd)=>{
+const getMockModule = async (pwd, mockDir)=>{
     const exts = [
         '.ts',
         '.js'
     ];
     let mockFilePath = '';
+    const mockDirectory = resolveMockDirectory(pwd, mockDir);
     for (const ext of exts){
-        const maybeMatch = external_node_path_default().join(pwd, `${server_core_namespaceObject.AGGRED_DIR.mock}/index${ext}`);
+        const maybeMatch = external_node_path_default().join(mockDirectory, `index${ext}`);
         if (await utils_namespaceObject.fs.pathExists(maybeMatch)) {
             mockFilePath = maybeMatch;
             break;
         }
     }
     if (!mockFilePath) return;
-    const { default: mockHandlers, config } = await import(mockFilePath);
+    const { default: mockHandlers, config } = await (0, utils_namespaceObject.compatibleRequire)(mockFilePath, false);
     const enable = config?.enable;
     if (false === enable) return;
     if (!mockHandlers) throw new Error(`Mock file ${mockFilePath} parsed failed!`);
@@ -98,8 +106,8 @@ const getMatched = (request, mockApis)=>{
     });
     return matched;
 };
-async function initOrUpdateMockMiddlewares(pwd) {
-    const mockModule = await getMockModule(pwd);
+async function initOrUpdateMockMiddlewares(pwd, mockDir) {
+    const mockModule = await getMockModule(pwd, mockDir);
     mockConfig = mockModule?.config;
     mockAPIs = Object.entries(mockModule?.mockHandlers || {}).map(([key, handler])=>{
         const { method, path } = parseKey(key);
@@ -110,8 +118,8 @@ async function initOrUpdateMockMiddlewares(pwd) {
         };
     });
 }
-async function getMockMiddleware(pwd) {
-    await initOrUpdateMockMiddlewares(pwd);
+async function getMockMiddleware(pwd, mockDir) {
+    await initOrUpdateMockMiddlewares(pwd, mockDir);
     const mockMiddleware = async (c, next)=>{
         if ('function' == typeof mockConfig?.enable) {
             const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
@@ -130,10 +138,14 @@ async function getMockMiddleware(pwd) {
 exports.getMatched = __webpack_exports__.getMatched;
 exports.getMockMiddleware = __webpack_exports__.getMockMiddleware;
 exports.initOrUpdateMockMiddlewares = __webpack_exports__.initOrUpdateMockMiddlewares;
+exports.isPathInsideDirectory = __webpack_exports__.isPathInsideDirectory;
+exports.resolveMockDirectory = __webpack_exports__.resolveMockDirectory;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getMatched",
     "getMockMiddleware",
-    "initOrUpdateMockMiddlewares"
+    "initOrUpdateMockMiddlewares",
+    "isPathInsideDirectory",
+    "resolveMockDirectory"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/esm/createDevServer.mjs

@@ -1,7 +1,10 @@
 import node_path from "node:path";
 import { createServerBase } from "@modern-js/server-core";
 import { createNodeServer, loadServerRuntimeConfig } from "@modern-js/server-core/node";
-import { devPlugin } from "./dev.mjs";
+import { logger } from "@modern-js/utils";
+import { devRuntimeMiddlewarePlugin, setupDevInfra } from "./dev.mjs";
+import { 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) {
     const { config, pwd, serverConfigPath, builder } = options;
@@ -20,33 +23,76 @@ async function createDevServer(options, applyPlugins) {
             ...options.plugins || []
         ]
     };
-    const server = createServerBase(prodServerOptions);
-    const devHttpsOption = 'object' == typeof dev && dev.https;
-    const isHttp2 = !!devHttpsOption;
-    let nodeServer;
-    if (devHttpsOption) {
-        const { genHttpsOptions } = await import("./dev-tools/https/index.mjs");
-        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
-        nodeServer = await createNodeServer(server.handle.bind(server), httpsOptions, isHttp2);
-    } else nodeServer = await createNodeServer(server.handle.bind(server));
-    const promise = getDevAssetPrefix(builder);
     let compiler = null;
     builder?.onAfterCreateCompiler((context)=>{
         compiler = context.compiler;
     });
+    const assetPrefixPromise = getDevAssetPrefix(builder);
     const builderDevServer = await builder?.createDevServer({
         runCompile: options.runCompile
     });
-    server.addPlugins([
-        devPlugin({
-            ...options,
-            builderDevServer
-        }, compiler)
-    ]);
-    const assetPrefix = await promise;
-    if (assetPrefix) prodServerOptions.config.output.assetPrefix = assetPrefix;
-    await applyPlugins(server, prodServerOptions, nodeServer);
-    await server.init();
+    const assetPrefix = await assetPrefixPromise;
+    let currentRuntimeServer;
+    let nodeServer;
+    const buildRuntimeServer = async ()=>{
+        const freshServerConfig = await loadServerRuntimeConfig(serverConfigPath) || {};
+        const runtimeOptions = createRuntimeServerOptions({
+            ...prodServerOptions,
+            serverConfig: {
+                ...freshServerConfig,
+                ...options.serverConfig
+            },
+            plugins: [
+                ...freshServerConfig.plugins || [],
+                ...options.plugins || []
+            ]
+        }, assetPrefix);
+        const runtimeServer = createServerBase(runtimeOptions);
+        runtimeServer.addPlugins([
+            devRuntimeMiddlewarePlugin({
+                ...options,
+                builderDevServer
+            }, compiler)
+        ]);
+        await applyPlugins(runtimeServer, runtimeOptions, nodeServer);
+        await runtimeServer.init();
+        currentRuntimeServer = runtimeServer;
+        return runtimeServer.handle;
+    };
+    const pendingReloadFiles = new Set();
+    const reloadManager = createReloadManager({
+        build: buildRuntimeServer,
+        onReload: ()=>{
+            const files = Array.from(pendingReloadFiles);
+            pendingReloadFiles.clear();
+            logger.info(files.length > 0 ? `Server runtime reloaded (${files.join(', ')})` : 'Server runtime reloaded');
+        }
+    });
+    const devHttpsOption = 'object' == typeof dev && dev.https;
+    const isHttp2 = !!devHttpsOption;
+    if (devHttpsOption) {
+        const { genHttpsOptions } = await import("./dev-tools/https/index.mjs");
+        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
+        nodeServer = await createNodeServer(reloadManager.handle, httpsOptions, isHttp2);
+    } else nodeServer = await createNodeServer(reloadManager.handle);
+    reloadManager.setHandle(await buildRuntimeServer());
+    setupDevInfra({
+        config,
+        pwd,
+        distDir,
+        apiDir: options.appContext?.apiDirectory,
+        sharedDir: options.appContext?.sharedDirectory,
+        builder,
+        builderDevServer,
+        compiler,
+        nodeServer,
+        getRuntimeServer: ()=>currentRuntimeServer,
+        onFileChange: (filepath)=>{
+            pendingReloadFiles.add(node_path.relative(pwd, filepath));
+            reloadManager.schedule();
+        },
+        onClose: ()=>reloadManager.close()
+    });
     const afterListen = async ()=>{
         await builderDevServer?.afterListen();
     };

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

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

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

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

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

@@ -1,3 +1,4 @@
+import node_path from "node:path";
 import * as __rspack_external_minimatch from "minimatch";
 const defaultIgnores = [
     '**/coverage/**',
@@ -41,8 +42,9 @@ class DependencyTree {
         }
     }
     shouldIgnore(path) {
-        return !path || Boolean(this.ignore.find((rule)=>__rspack_external_minimatch.match([
-                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));