@modern-js/server-core 2.58.1 → 2.58.2

package/dist/cjs/adapters/node/helper/loadCache.js

@@ -34,9 +34,9 @@ module.exports = __toCommonJS(loadCache_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 const CACHE_FILENAME = "cache";
-function loadCacheConfig(pwd) {
+async function loadCacheConfig(pwd) {
   const serverCacheFilepath = import_path.default.resolve(pwd, import_utils.SERVER_DIR, CACHE_FILENAME);
-  const mod = (0, import_utils.requireExistModule)(serverCacheFilepath, {
+  const mod = await (0, import_utils.requireExistModule)(serverCacheFilepath, {
     interop: false
   });
   if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {

package/dist/cjs/adapters/node/helper/loadConfig.js

@@ -35,30 +35,30 @@ module.exports = __toCommonJS(loadConfig_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 var import_flatted = require("flatted");
-const requireConfig = (serverConfigPath) => {
+const requireConfig = async (serverConfigPath) => {
   if (import_utils.fs.pathExistsSync(serverConfigPath)) {
-    return (0, import_utils.compatRequire)(serverConfigPath);
+    return (0, import_utils.compatibleRequire)(serverConfigPath);
   }
   return void 0;
 };
-function loadServerConfigNew(serverConfigPath) {
-  const mod = (0, import_utils.requireExistModule)(serverConfigPath);
+async function loadServerConfigNew(serverConfigPath) {
+  const mod = await (0, import_utils.requireExistModule)(serverConfigPath);
   if (mod) {
     return mod;
   }
   return void 0;
 }
-function loadServerConfigOld(pwd, configFile) {
-  const serverConfigPath = import_path.default.join(pwd, `${configFile}.js`);
-  const serverConfig = requireConfig(serverConfigPath);
+async function loadServerConfigOld(pwd, configFile) {
+  const serverConfigPath = import_path.default.join(pwd, `${configFile}.cjs`);
+  const serverConfig = await requireConfig(serverConfigPath);
   return serverConfig;
 }
-function loadServerRuntimeConfig(pwd, oldServerFile = import_utils.DEFAULT_SERVER_CONFIG, newServerConfigPath) {
-  const newServerConfig = newServerConfigPath && loadServerConfigNew(newServerConfigPath);
+async function loadServerRuntimeConfig(pwd, oldServerFile = import_utils.DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+  const newServerConfig = newServerConfigPath && await loadServerConfigNew(newServerConfigPath);
   if (newServerConfig) {
     return newServerConfig;
   }
-  const oldServerConfig = loadServerConfigOld(pwd, oldServerFile);
+  const oldServerConfig = await loadServerConfigOld(pwd, oldServerFile);
   return oldServerConfig;
 }
 function loadServerCliConfig(pwd, defaultConfig = {}) {

package/dist/cjs/adapters/node/helper/loadPlugin.js

@@ -22,15 +22,15 @@ __export(loadPlugin_exports, {
 });
 module.exports = __toCommonJS(loadPlugin_exports);
 var import_utils = require("@modern-js/utils");
-function resolveServerPlugin(plugin, appDirectory) {
+async function resolveServerPlugin(plugin, appDirectory) {
   const { name, options } = plugin;
   const pluginPath = (0, import_utils.tryResolve)(name, appDirectory);
-  const module2 = (0, import_utils.compatRequire)(pluginPath);
+  const module2 = await (0, import_utils.compatibleRequire)(pluginPath);
   const pluginInstance = module2(options);
   return pluginInstance;
 }
-function loadServerPlugins(serverPlugins, appDirectory) {
-  const instances = serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory));
+async function loadServerPlugins(serverPlugins, appDirectory) {
+  const instances = await Promise.all(serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory)));
   return instances;
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/adapters/node/node.js

@@ -128,10 +128,10 @@ const createNodeServer = async (requestHandler, httpsOptions) => {
   const requestListener = getRequestListener(requestHandler);
   let nodeServer;
   if (httpsOptions) {
-    const { createServer } = await Promise.resolve().then(() => __toESM(require("node:https")));
+    const { createServer } = await import("node:https");
     nodeServer = createServer(httpsOptions, requestListener);
   } else {
-    const { createServer } = await Promise.resolve().then(() => __toESM(require("node:http")));
+    const { createServer } = await import("node:http");
     nodeServer = createServer(requestListener);
   }
   nodeServer.getRequestListener = () => requestListener;

package/dist/cjs/adapters/node/plugins/resource.js

@@ -64,22 +64,17 @@ function injectTemplates(pwd, routes) {
     await next();
   };
 }
-const dynamicImport = (filePath) => {
-  try {
-    const module2 = require(filePath);
-    return Promise.resolve(module2);
-  } catch (e) {
-    return Promise.reject(e);
-  }
-};
 const loadBundle = async (filepath, logger) => {
   if (!await import_utils.fs.pathExists(filepath)) {
     return void 0;
   }
-  return dynamicImport(filepath).catch((e) => {
-    logger === null || logger === void 0 ? void 0 : logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
+  try {
+    const module2 = await (0, import_utils.compatibleRequire)(filepath, false);
+    return module2;
+  } catch (e) {
+    logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
     return void 0;
-  });
+  }
 };
 async function getServerManifest(pwd, routes, logger) {
   const loaderBundles = {};
@@ -94,11 +89,11 @@ async function getServerManifest(pwd, routes, logger) {
     loaderBundle && (loaderBundles[entryName] = loaderBundle);
   }));
   const loadableUri = import_path.default.join(pwd, import_utils.LOADABLE_STATS_FILE);
-  const loadableStats = await Promise.resolve().then(() => __toESM(require(loadableUri))).catch((_) => ({}));
+  const loadableStats = await (0, import_utils.compatibleRequire)(loadableUri).catch((_) => ({}));
   const routesManifestUri = import_path.default.join(pwd, import_utils.ROUTE_MANIFEST_FILE);
-  const routeManifest = await Promise.resolve().then(() => __toESM(require(routesManifestUri))).catch((_) => ({}));
+  const routeManifest = await (0, import_utils.compatibleRequire)(routesManifestUri).catch((_) => ({}));
   const nestedRoutesJsonPath = import_path.default.join(pwd, import_utils.NESTED_ROUTE_SPEC_FILE);
-  const nestedRoutesJson = await Promise.resolve().then(() => __toESM(require(nestedRoutesJsonPath))).catch((_) => ({}));
+  const nestedRoutesJson = await (0, import_utils.compatibleRequire)(nestedRoutesJsonPath).catch((_) => ({}));
   return {
     loaderBundles,
     renderBundles,

package/dist/cjs/plugins/customServer/index.js

@@ -65,7 +65,14 @@ class CustomServer {
       if (current !== entryName) {
         const rewriteRoute = routes.find((route) => route.entryName === current);
         if (rewriteRoute) {
-          return this.serverBase.request(rewriteRoute.urlPath);
+          const { headers, method, signal } = c.req.raw;
+          const url2 = new URL(c.req.url);
+          const newUrl = new URL(rewriteRoute.urlPath, url2.origin);
+          return this.serverBase.request(newUrl, {
+            headers,
+            method,
+            signal
+          }, c.env);
         }
       }
       if (c.finalized) {
@@ -175,8 +182,7 @@ async function createMiddlewareContextFromHono(c) {
     "GET",
     "HEAD"
   ].includes(method) && !rawRequest.body && c.env.node.req) {
-    const streamPath = "../../adapters/node/polyfills/stream";
-    const { createReadableStreamFromReadable } = await Promise.resolve().then(() => __toESM(require(streamPath)));
+    const { createReadableStreamFromReadable } = await import("../../adapters/node/polyfills/stream.js");
     const init = {
       body: createReadableStreamFromReadable(c.env.node.req),
       headers: rawRequest.headers,

package/dist/cjs/plugins/render/render.js

@@ -37,6 +37,7 @@ var import_utils = require("../../utils");
 var import_constants = require("../../constants");
 var import_dataHandler = require("./dataHandler");
 var import_ssrRender = require("./ssrRender");
+var import_utils2 = require("@modern-js/utils");
 const DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
   const dynamicRoutes = [];
@@ -164,7 +165,7 @@ async function renderHandler(request, options, mode, onError) {
     const { nestedRoutesJson } = serverManifest;
     const routes = nestedRoutesJson === null || nestedRoutesJson === void 0 ? void 0 : nestedRoutesJson[options.routeInfo.entryName];
     if (routes) {
-      const { matchRoutes } = await Promise.resolve().then(() => __toESM(require("@modern-js/runtime-utils/remix-router")));
+      const { matchRoutes } = await (0, import_utils2.compatibleRequire)(require.resolve("@modern-js/runtime-utils/remix-router"), false);
       const url = new URL(request.url);
       const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
       if (!matchedRoutes) {

package/dist/cjs/utils/warmup.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var warmup_exports = {};
 __export(warmup_exports, {
@@ -33,7 +23,7 @@ __export(warmup_exports, {
 module.exports = __toCommonJS(warmup_exports);
 function warmup(bundles) {
   bundles.forEach((bundle) => {
-    bundle && Promise.resolve().then(() => __toESM(require(bundle))).catch((_) => {
+    bundle && import(bundle).catch((_) => {
     });
   });
 }

package/dist/esm/adapters/node/helper/loadCache.js

@@ -1,18 +1,43 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
 var CACHE_FILENAME = "cache";
 function loadCacheConfig(pwd) {
-  var serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
-  var mod = requireExistModule(serverCacheFilepath, {
-    interop: false
+  return _loadCacheConfig.apply(this, arguments);
+}
+function _loadCacheConfig() {
+  _loadCacheConfig = _async_to_generator(function(pwd) {
+    var serverCacheFilepath, mod;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+          return [
+            4,
+            requireExistModule(serverCacheFilepath, {
+              interop: false
+            })
+          ];
+        case 1:
+          mod = _state.sent();
+          if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {
+            return [
+              2,
+              {
+                strategy: mod.cacheOption,
+                container: mod.customContainer
+              }
+            ];
+          }
+          return [
+            2,
+            void 0
+          ];
+      }
+    });
   });
-  if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {
-    return {
-      strategy: mod.cacheOption,
-      container: mod.customContainer
-    };
-  }
-  return void 0;
+  return _loadCacheConfig.apply(this, arguments);
 }
 export {
   loadCacheConfig

package/dist/esm/adapters/node/helper/loadConfig.js

@@ -1,32 +1,128 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
-import { compatRequire, fs, DEFAULT_SERVER_CONFIG, requireExistModule, ensureAbsolutePath, OUTPUT_CONFIG_FILE, lodash as _ } from "@modern-js/utils";
+import { fs, DEFAULT_SERVER_CONFIG, requireExistModule, ensureAbsolutePath, OUTPUT_CONFIG_FILE, lodash as _, compatibleRequire } from "@modern-js/utils";
 import { parse } from "flatted";
-var requireConfig = function(serverConfigPath) {
-  if (fs.pathExistsSync(serverConfigPath)) {
-    return compatRequire(serverConfigPath);
-  }
-  return void 0;
-};
+var requireConfig = function() {
+  var _ref = _async_to_generator(function(serverConfigPath) {
+    return _ts_generator(this, function(_state) {
+      if (fs.pathExistsSync(serverConfigPath)) {
+        return [
+          2,
+          compatibleRequire(serverConfigPath)
+        ];
+      }
+      return [
+        2,
+        void 0
+      ];
+    });
+  });
+  return function requireConfig2(serverConfigPath) {
+    return _ref.apply(this, arguments);
+  };
+}();
 function loadServerConfigNew(serverConfigPath) {
-  var mod = requireExistModule(serverConfigPath);
-  if (mod) {
-    return mod;
-  }
-  return void 0;
+  return _loadServerConfigNew.apply(this, arguments);
+}
+function _loadServerConfigNew() {
+  _loadServerConfigNew = _async_to_generator(function(serverConfigPath) {
+    var mod;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            requireExistModule(serverConfigPath)
+          ];
+        case 1:
+          mod = _state.sent();
+          if (mod) {
+            return [
+              2,
+              mod
+            ];
+          }
+          return [
+            2,
+            void 0
+          ];
+      }
+    });
+  });
+  return _loadServerConfigNew.apply(this, arguments);
 }
 function loadServerConfigOld(pwd, configFile) {
-  var serverConfigPath = path.join(pwd, "".concat(configFile, ".js"));
-  var serverConfig = requireConfig(serverConfigPath);
-  return serverConfig;
+  return _loadServerConfigOld.apply(this, arguments);
+}
+function _loadServerConfigOld() {
+  _loadServerConfigOld = _async_to_generator(function(pwd, configFile) {
+    var serverConfigPath, serverConfig;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          serverConfigPath = path.join(pwd, "".concat(configFile, ".cjs"));
+          return [
+            4,
+            requireConfig(serverConfigPath)
+          ];
+        case 1:
+          serverConfig = _state.sent();
+          return [
+            2,
+            serverConfig
+          ];
+      }
+    });
+  });
+  return _loadServerConfigOld.apply(this, arguments);
 }
 function loadServerRuntimeConfig(pwd) {
-  var oldServerFile = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_SERVER_CONFIG, newServerConfigPath = arguments.length > 2 ? arguments[2] : void 0;
-  var newServerConfig = newServerConfigPath && loadServerConfigNew(newServerConfigPath);
-  if (newServerConfig) {
-    return newServerConfig;
-  }
-  var oldServerConfig = loadServerConfigOld(pwd, oldServerFile);
-  return oldServerConfig;
+  return _loadServerRuntimeConfig.apply(this, arguments);
+}
+function _loadServerRuntimeConfig() {
+  _loadServerRuntimeConfig = _async_to_generator(function(pwd) {
+    var oldServerFile, newServerConfigPath, newServerConfig, _tmp, oldServerConfig;
+    var _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          oldServerFile = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : DEFAULT_SERVER_CONFIG, newServerConfigPath = _arguments.length > 2 ? _arguments[2] : void 0;
+          _tmp = newServerConfigPath;
+          if (!_tmp)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            loadServerConfigNew(newServerConfigPath)
+          ];
+        case 1:
+          _tmp = _state.sent();
+          _state.label = 2;
+        case 2:
+          newServerConfig = _tmp;
+          if (newServerConfig) {
+            return [
+              2,
+              newServerConfig
+            ];
+          }
+          return [
+            4,
+            loadServerConfigOld(pwd, oldServerFile)
+          ];
+        case 3:
+          oldServerConfig = _state.sent();
+          return [
+            2,
+            oldServerConfig
+          ];
+      }
+    });
+  });
+  return _loadServerRuntimeConfig.apply(this, arguments);
 }
 function loadServerCliConfig(pwd) {
   var defaultConfig = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};

package/dist/esm/adapters/node/helper/loadPlugin.js

@@ -1,16 +1,58 @@
-import { compatRequire, tryResolve } from "@modern-js/utils";
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { compatibleRequire, tryResolve } from "@modern-js/utils";
 function resolveServerPlugin(plugin, appDirectory) {
-  var name = plugin.name, options = plugin.options;
-  var pluginPath = tryResolve(name, appDirectory);
-  var module = compatRequire(pluginPath);
-  var pluginInstance = module(options);
-  return pluginInstance;
+  return _resolveServerPlugin.apply(this, arguments);
+}
+function _resolveServerPlugin() {
+  _resolveServerPlugin = _async_to_generator(function(plugin, appDirectory) {
+    var name, options, pluginPath, module, pluginInstance;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          name = plugin.name, options = plugin.options;
+          pluginPath = tryResolve(name, appDirectory);
+          return [
+            4,
+            compatibleRequire(pluginPath)
+          ];
+        case 1:
+          module = _state.sent();
+          pluginInstance = module(options);
+          return [
+            2,
+            pluginInstance
+          ];
+      }
+    });
+  });
+  return _resolveServerPlugin.apply(this, arguments);
 }
 function loadServerPlugins(serverPlugins, appDirectory) {
-  var instances = serverPlugins.map(function(plugin) {
-    return resolveServerPlugin(plugin, appDirectory);
+  return _loadServerPlugins.apply(this, arguments);
+}
+function _loadServerPlugins() {
+  _loadServerPlugins = _async_to_generator(function(serverPlugins, appDirectory) {
+    var instances;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            Promise.all(serverPlugins.map(function(plugin) {
+              return resolveServerPlugin(plugin, appDirectory);
+            }))
+          ];
+        case 1:
+          instances = _state.sent();
+          return [
+            2,
+            instances
+          ];
+      }
+    });
   });
-  return instances;
+  return _loadServerPlugins.apply(this, arguments);
 }
 export {
   loadServerPlugins

package/dist/esm/adapters/node/plugins/resource.js

@@ -3,7 +3,7 @@ import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs } from "@modern-js/utils";
+import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs, compatibleRequire } from "@modern-js/utils";
 function getHtmlTemplates(pwd, routes) {
   return _getHtmlTemplates.apply(this, arguments);
 }
@@ -110,16 +110,9 @@ function injectTemplates(pwd, routes) {
     };
   }();
 }
-var dynamicImport = function(filePath) {
-  try {
-    var module = require(filePath);
-    return Promise.resolve(module);
-  } catch (e) {
-    return Promise.reject(e);
-  }
-};
 var loadBundle = function() {
   var _ref = _async_to_generator(function(filepath, logger) {
+    var module, e;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -134,12 +127,34 @@ var loadBundle = function() {
               void 0
             ];
           }
+          _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            4,
+            ,
+            5
+          ]);
+          return [
+            4,
+            compatibleRequire(filepath, false)
+          ];
+        case 3:
+          module = _state.sent();
           return [
             2,
-            dynamicImport(filepath).catch(function(e) {
-              logger === null || logger === void 0 ? void 0 : logger.error("Load ".concat(filepath, " bundle failed, error = %s"), _instanceof(e, Error) ? e.stack || e.message : e);
-              return void 0;
-            })
+            module
+          ];
+        case 4:
+          e = _state.sent();
+          logger.error("Load ".concat(filepath, " bundle failed, error = %s"), _instanceof(e, Error) ? e.stack || e.message : e);
+          return [
+            2,
+            void 0
+          ];
+        case 5:
+          return [
+            2
           ];
       }
     });
@@ -202,7 +217,7 @@ function _getServerManifest() {
           loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
           return [
             4,
-            import(loadableUri).catch(function(_) {
+            compatibleRequire(loadableUri).catch(function(_) {
               return {};
             })
           ];
@@ -211,7 +226,7 @@ function _getServerManifest() {
           routesManifestUri = path.join(pwd, ROUTE_MANIFEST_FILE);
           return [
             4,
-            import(routesManifestUri).catch(function(_) {
+            compatibleRequire(routesManifestUri).catch(function(_) {
               return {};
             })
           ];
@@ -220,7 +235,7 @@ function _getServerManifest() {
           nestedRoutesJsonPath = path.join(pwd, NESTED_ROUTE_SPEC_FILE);
           return [
             4,
-            import(nestedRoutesJsonPath).catch(function(_) {
+            compatibleRequire(nestedRoutesJsonPath).catch(function(_) {
               return {};
             })
           ];

package/dist/esm/plugins/customServer/index.js

@@ -36,7 +36,7 @@ var CustomServer = /* @__PURE__ */ function() {
     var _this = this;
     return function() {
       var _ref = _async_to_generator(function(c, next) {
-        var routeInfo, monitors, baseHookCtx, afterMatchCtx, getCost, cost, _afterMatchCtx_router, url, status, current, rewriteRoute, afterStreamingRenderContext, afterRenderCtx, getCost1, cost1, newBody;
+        var routeInfo, monitors, baseHookCtx, afterMatchCtx, getCost, cost, _afterMatchCtx_router, url, status, current, rewriteRoute, _c_req_raw, headers, method, signal, url1, newUrl, afterStreamingRenderContext, afterRenderCtx, getCost1, cost1, newBody;
         return _ts_generator(this, function(_state) {
           switch (_state.label) {
             case 0:
@@ -70,9 +70,16 @@ var CustomServer = /* @__PURE__ */ function() {
                   return route.entryName === current;
                 });
                 if (rewriteRoute) {
+                  _c_req_raw = c.req.raw, headers = _c_req_raw.headers, method = _c_req_raw.method, signal = _c_req_raw.signal;
+                  url1 = new URL(c.req.url);
+                  newUrl = new URL(rewriteRoute.urlPath, url1.origin);
                   return [
                     2,
-                    _this.serverBase.request(rewriteRoute.urlPath)
+                    _this.serverBase.request(newUrl, {
+                      headers,
+                      method,
+                      signal
+                    }, c.env)
                   ];
                 }
               }
@@ -281,7 +288,7 @@ function createMiddlewareContextFromHono(c) {
 }
 function _createMiddlewareContextFromHono() {
   _createMiddlewareContextFromHono = _async_to_generator(function(c) {
-    var loaderContext, rawRequest, method, streamPath, createReadableStreamFromReadable, init;
+    var loaderContext, rawRequest, method, createReadableStreamFromReadable, init;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -296,10 +303,9 @@ function _createMiddlewareContextFromHono() {
               3,
               2
             ];
-          streamPath = "../../adapters/node/polyfills/stream";
           return [
             4,
-            import(streamPath)
+            import("../../adapters/node/polyfills/stream.js")
           ];
         case 1:
           createReadableStreamFromReadable = _state.sent().createReadableStreamFromReadable;

package/dist/esm/plugins/render/render.js

@@ -12,6 +12,7 @@ import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse
 import { REPLACE_REG, X_MODERNJS_RENDER } from "../../constants";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
+import { compatibleRequire } from "@modern-js/utils";
 var DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
   var dynamicRoutes = [];
@@ -290,7 +291,7 @@ function _renderHandler() {
             ];
           return [
             4,
-            import("@modern-js/runtime-utils/remix-router")
+            compatibleRequire(require.resolve("@modern-js/runtime-utils/remix-router"), false)
           ];
         case 1:
           matchRoutes = _state.sent().matchRoutes;

package/dist/esm-node/adapters/node/helper/loadCache.js

@@ -1,9 +1,9 @@
 import path from "path";
 import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
 const CACHE_FILENAME = "cache";
-function loadCacheConfig(pwd) {
+async function loadCacheConfig(pwd) {
   const serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
-  const mod = requireExistModule(serverCacheFilepath, {
+  const mod = await requireExistModule(serverCacheFilepath, {
     interop: false
   });
   if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {

package/dist/esm-node/adapters/node/helper/loadConfig.js

@@ -1,30 +1,30 @@
 import path from "path";
-import { compatRequire, fs, DEFAULT_SERVER_CONFIG, requireExistModule, ensureAbsolutePath, OUTPUT_CONFIG_FILE, lodash as _ } from "@modern-js/utils";
+import { fs, DEFAULT_SERVER_CONFIG, requireExistModule, ensureAbsolutePath, OUTPUT_CONFIG_FILE, lodash as _, compatibleRequire } from "@modern-js/utils";
 import { parse } from "flatted";
-const requireConfig = (serverConfigPath) => {
+const requireConfig = async (serverConfigPath) => {
   if (fs.pathExistsSync(serverConfigPath)) {
-    return compatRequire(serverConfigPath);
+    return compatibleRequire(serverConfigPath);
   }
   return void 0;
 };
-function loadServerConfigNew(serverConfigPath) {
-  const mod = requireExistModule(serverConfigPath);
+async function loadServerConfigNew(serverConfigPath) {
+  const mod = await requireExistModule(serverConfigPath);
   if (mod) {
     return mod;
   }
   return void 0;
 }
-function loadServerConfigOld(pwd, configFile) {
-  const serverConfigPath = path.join(pwd, `${configFile}.js`);
-  const serverConfig = requireConfig(serverConfigPath);
+async function loadServerConfigOld(pwd, configFile) {
+  const serverConfigPath = path.join(pwd, `${configFile}.cjs`);
+  const serverConfig = await requireConfig(serverConfigPath);
   return serverConfig;
 }
-function loadServerRuntimeConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath) {
-  const newServerConfig = newServerConfigPath && loadServerConfigNew(newServerConfigPath);
+async function loadServerRuntimeConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+  const newServerConfig = newServerConfigPath && await loadServerConfigNew(newServerConfigPath);
   if (newServerConfig) {
     return newServerConfig;
   }
-  const oldServerConfig = loadServerConfigOld(pwd, oldServerFile);
+  const oldServerConfig = await loadServerConfigOld(pwd, oldServerFile);
   return oldServerConfig;
 }
 function loadServerCliConfig(pwd, defaultConfig = {}) {

package/dist/esm-node/adapters/node/helper/loadPlugin.js

@@ -1,13 +1,13 @@
-import { compatRequire, tryResolve } from "@modern-js/utils";
-function resolveServerPlugin(plugin, appDirectory) {
+import { compatibleRequire, tryResolve } from "@modern-js/utils";
+async function resolveServerPlugin(plugin, appDirectory) {
   const { name, options } = plugin;
   const pluginPath = tryResolve(name, appDirectory);
-  const module = compatRequire(pluginPath);
+  const module = await compatibleRequire(pluginPath);
   const pluginInstance = module(options);
   return pluginInstance;
 }
-function loadServerPlugins(serverPlugins, appDirectory) {
-  const instances = serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory));
+async function loadServerPlugins(serverPlugins, appDirectory) {
+  const instances = await Promise.all(serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory)));
   return instances;
 }
 export {

package/dist/esm-node/adapters/node/plugins/resource.js

@@ -1,6 +1,6 @@
 import path from "path";
 import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs } from "@modern-js/utils";
+import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs, compatibleRequire } from "@modern-js/utils";
 async function getHtmlTemplates(pwd, routes) {
   const htmls = await Promise.all(routes.map(async (route) => {
     let html;
@@ -27,22 +27,17 @@ function injectTemplates(pwd, routes) {
     await next();
   };
 }
-const dynamicImport = (filePath) => {
-  try {
-    const module = require(filePath);
-    return Promise.resolve(module);
-  } catch (e) {
-    return Promise.reject(e);
-  }
-};
 const loadBundle = async (filepath, logger) => {
   if (!await fs.pathExists(filepath)) {
     return void 0;
   }
-  return dynamicImport(filepath).catch((e) => {
-    logger === null || logger === void 0 ? void 0 : logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
+  try {
+    const module = await compatibleRequire(filepath, false);
+    return module;
+  } catch (e) {
+    logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
     return void 0;
-  });
+  }
 };
 async function getServerManifest(pwd, routes, logger) {
   const loaderBundles = {};
@@ -57,11 +52,11 @@ async function getServerManifest(pwd, routes, logger) {
     loaderBundle && (loaderBundles[entryName] = loaderBundle);
   }));
   const loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
-  const loadableStats = await import(loadableUri).catch((_) => ({}));
+  const loadableStats = await compatibleRequire(loadableUri).catch((_) => ({}));
   const routesManifestUri = path.join(pwd, ROUTE_MANIFEST_FILE);
-  const routeManifest = await import(routesManifestUri).catch((_) => ({}));
+  const routeManifest = await compatibleRequire(routesManifestUri).catch((_) => ({}));
   const nestedRoutesJsonPath = path.join(pwd, NESTED_ROUTE_SPEC_FILE);
-  const nestedRoutesJson = await import(nestedRoutesJsonPath).catch((_) => ({}));
+  const nestedRoutesJson = await compatibleRequire(nestedRoutesJsonPath).catch((_) => ({}));
   return {
     loaderBundles,
     renderBundles,

package/dist/esm-node/plugins/customServer/index.js

@@ -31,7 +31,14 @@ class CustomServer {
       if (current !== entryName) {
         const rewriteRoute = routes.find((route) => route.entryName === current);
         if (rewriteRoute) {
-          return this.serverBase.request(rewriteRoute.urlPath);
+          const { headers, method, signal } = c.req.raw;
+          const url2 = new URL(c.req.url);
+          const newUrl = new URL(rewriteRoute.urlPath, url2.origin);
+          return this.serverBase.request(newUrl, {
+            headers,
+            method,
+            signal
+          }, c.env);
         }
       }
       if (c.finalized) {
@@ -141,8 +148,7 @@ async function createMiddlewareContextFromHono(c) {
     "GET",
     "HEAD"
   ].includes(method) && !rawRequest.body && c.env.node.req) {
-    const streamPath = "../../adapters/node/polyfills/stream";
-    const { createReadableStreamFromReadable } = await import(streamPath);
+    const { createReadableStreamFromReadable } = await import("../../adapters/node/polyfills/stream.js");
     const init = {
       body: createReadableStreamFromReadable(c.env.node.req),
       headers: rawRequest.headers,

package/dist/esm-node/plugins/render/render.js

@@ -4,6 +4,7 @@ import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse
 import { REPLACE_REG, X_MODERNJS_RENDER } from "../../constants";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
+import { compatibleRequire } from "@modern-js/utils";
 const DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
   const dynamicRoutes = [];
@@ -131,7 +132,7 @@ async function renderHandler(request, options, mode, onError) {
     const { nestedRoutesJson } = serverManifest;
     const routes = nestedRoutesJson === null || nestedRoutesJson === void 0 ? void 0 : nestedRoutesJson[options.routeInfo.entryName];
     if (routes) {
-      const { matchRoutes } = await import("@modern-js/runtime-utils/remix-router");
+      const { matchRoutes } = await compatibleRequire(require.resolve("@modern-js/runtime-utils/remix-router"), false);
       const url = new URL(request.url);
       const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
       if (!matchedRoutes) {

package/dist/types/adapters/node/helper/loadCache.d.ts

@@ -1,2 +1,2 @@
-import { CacheConfig } from '../../../types';
-export declare function loadCacheConfig(pwd: string): CacheConfig | undefined;
+import type { CacheConfig } from '../../../types';
+export declare function loadCacheConfig(pwd: string): Promise<CacheConfig | undefined>;

package/dist/types/adapters/node/helper/loadConfig.d.ts

@@ -1,3 +1,3 @@
-import { CliConfig, ServerConfig, UserConfig } from '../../../types';
-export declare function loadServerRuntimeConfig(pwd: string, oldServerFile?: string, newServerConfigPath?: string): ServerConfig | undefined;
+import type { CliConfig, ServerConfig, UserConfig } from '../../../types';
+export declare function loadServerRuntimeConfig(pwd: string, oldServerFile?: string, newServerConfigPath?: string): Promise<ServerConfig | undefined>;
 export declare function loadServerCliConfig(pwd: string, defaultConfig?: UserConfig): CliConfig;

package/dist/types/adapters/node/helper/loadPlugin.d.ts

@@ -1,3 +1,3 @@
-import { ServerPlugin } from '@modern-js/types';
-import { ServerPlugin as ServerPluginInstance } from '../../../types';
-export declare function loadServerPlugins(serverPlugins: ServerPlugin[], appDirectory: string): ServerPluginInstance[];
+import type { ServerPlugin } from '@modern-js/types';
+import type { ServerPlugin as ServerPluginInstance } from '../../../types';
+export declare function loadServerPlugins(serverPlugins: ServerPlugin[], appDirectory: string): Promise<ServerPluginInstance[]>;

package/dist/types/adapters/node/hono.d.ts

@@ -1,4 +1,4 @@
-import { NodeRequest, NodeResponse, Context, HonoRequest, ServerEnv, Middleware, Next, ServerManifest } from '../../types';
+import type { NodeRequest, NodeResponse, Context, HonoRequest, ServerEnv, Middleware, Next, ServerManifest } from '../../types';
 type NodeBindings = {
     node: {
         req: NodeRequest & {

package/dist/types/adapters/node/node.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { Server as NodeServer } from 'node:http';
+import { type Server as NodeServer } from 'node:http';
 import type { Server as NodeHttpsServer } from 'node:https';
-import { NodeRequest, NodeResponse, RequestHandler } from '../../types';
+import type { NodeRequest, NodeResponse, RequestHandler } from '../../types';
 export { writeReadableStreamToWritable } from './polyfills';
 export declare const createWebRequest: (req: NodeRequest, res: NodeResponse, body?: BodyInit) => Request;
 export declare const sendResponse: (response: Response, res: NodeResponse) => Promise<void>;

package/dist/types/adapters/node/plugins/nodeServer.d.ts

@@ -1,4 +1,4 @@
-import { ServerPlugin, NodeServer } from '../../../types';
+import type { ServerPlugin, NodeServer } from '../../../types';
 export declare const injectNodeSeverPlugin: ({ nodeServer, }: {
     nodeServer: NodeServer;
 }) => ServerPlugin;

package/dist/types/adapters/node/plugins/resource.d.ts

@@ -1,5 +1,5 @@
 import type { Logger, ServerRoute } from '@modern-js/types';
-import { Middleware, ServerEnv, ServerManifest, ServerPlugin } from '../../../types';
+import type { Middleware, ServerEnv, ServerManifest, ServerPlugin } from '../../../types';
 export declare function getHtmlTemplates(pwd: string, routes: ServerRoute[]): Promise<Record<string, string>>;
 export declare function injectTemplates(pwd: string, routes?: ServerRoute[]): Middleware<ServerEnv>;
 export declare function getServerManifest(pwd: string, routes: ServerRoute[], logger: Logger): Promise<ServerManifest>;

package/dist/types/adapters/node/plugins/static.d.ts

@@ -1,4 +1,4 @@
-import { ServerRoute } from '@modern-js/types';
+import type { ServerRoute } from '@modern-js/types';
 import type { OutputNormalizedConfig, HtmlNormalizedConfig, Middleware, ServerPlugin } from '../../../types';
 export declare const serverStaticPlugin: () => ServerPlugin;
 export type PublicMiddlwareOptions = {

package/dist/types/plugins/customServer/base.d.ts

@@ -1,4 +1,4 @@
-import { HookContext } from '@modern-js/types';
+import type { HookContext } from '@modern-js/types';
 import type { Context, ServerEnv } from '../../types';
 export type ResArgs = {
     status?: number;

package/dist/types/plugins/customServer/context.d.ts

@@ -1,7 +1,7 @@
-import { AfterMatchContext, AfterRenderContext, MiddlewareContext, AfterStreamingRenderContext, ServerRoute, HookContext } from '@modern-js/types';
-import { Context, ServerEnv } from '../../types';
+import type { AfterMatchContext, AfterRenderContext, MiddlewareContext, AfterStreamingRenderContext, ServerRoute, HookContext } from '@modern-js/types';
+import type { Context, ServerEnv } from '../../types';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
-import { ResArgs } from './base';
+import { type ResArgs } from './base';
 export declare function getAfterMatchCtx(entryName: string, baseHookCtx: HookContext): AfterMatchContext;
 export declare function getAfterRenderCtx(c: Context, baseHookCtx: HookContext, route: Partial<ServerRoute>): Promise<AfterRenderContext>;
 export declare function createCustomMiddlewaresCtx(c: Context<ServerNodeEnv & ServerEnv>, locals: Record<string, any>, resArgs?: ResArgs): MiddlewareContext;

package/dist/types/plugins/customServer/index.d.ts

@@ -1,6 +1,6 @@
-import { ServerRoute, UnstableMiddleware } from '@modern-js/types';
-import { ServerBase } from '../../serverBase';
-import { ServerHookRunner, Middleware, ServerEnv } from '../../types';
+import type { ServerRoute, UnstableMiddleware } from '@modern-js/types';
+import type { ServerBase } from '../../serverBase';
+import type { ServerHookRunner, Middleware, ServerEnv } from '../../types';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
 export declare class CustomServer {
     private runner;

package/dist/types/plugins/default.d.ts

@@ -1,6 +1,6 @@
-import { Logger } from '@modern-js/types';
+import type { Logger } from '@modern-js/types';
 import type { ServerPlugin } from '../types';
-import { InjectRenderHandlerOptions } from './render';
+import { type InjectRenderHandlerOptions } from './render';
 export type CreateDefaultPluginsOptions = InjectRenderHandlerOptions & {
     logger?: Logger;
 };

package/dist/types/plugins/favicon.d.ts

@@ -1,2 +1,2 @@
-import { ServerPlugin } from '../types';
+import type { ServerPlugin } from '../types';
 export declare const faviconPlugin: () => ServerPlugin;

package/dist/types/plugins/processedBy.d.ts

@@ -1,2 +1,2 @@
-import { ServerPlugin } from '../types';
+import type { ServerPlugin } from '../types';
 export declare const processedByPlugin: () => ServerPlugin;

package/dist/types/plugins/render/dataHandler.d.ts

@@ -1,5 +1,5 @@
 import type { ServerRoute } from '@modern-js/types';
-import { SSRRenderOptions } from './ssrRender';
+import type { SSRRenderOptions } from './ssrRender';
 export declare const dataHandler: (request: Request, { routeInfo, serverRoutes, reporter, onError, onTiming, serverManifest, }: SSRRenderOptions & {
     serverRoutes: ServerRoute[];
 }) => Promise<Response | void>;

package/dist/types/plugins/render/index.d.ts

@@ -1,3 +1,3 @@
-import { ServerPlugin } from '../../types';
+import type { ServerPlugin } from '../../types';
 export * from './inject';
 export declare const renderPlugin: () => ServerPlugin;

package/dist/types/plugins/render/render.d.ts

@@ -1,6 +1,6 @@
-import { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
+import type { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
 import type { CacheConfig, FallbackReason, UserConfig } from '../../types';
-import { Render } from '../../types';
+import type { Render } from '../../types';
 export type OnFallback = (reason: FallbackReason, utils: {
     logger: Logger;
     metrics?: Metrics;

package/dist/types/plugins/render/ssrCache.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import type { IncomingMessage } from 'http';
 import type { CacheControl, CacheOption, Container } from '@modern-js/types';
-import { RequestHandler, RequestHandlerOptions } from '../../types/requestHandler';
+import type { RequestHandler, RequestHandlerOptions } from '../../types/requestHandler';
 export type CacheStatus = 'hit' | 'stale' | 'expired' | 'miss';
 type MaybeAsync<T> = Promise<T> | T;
 export declare function matchCacheControl(cacheOption?: CacheOption, req?: IncomingMessage): MaybeAsync<CacheControl | undefined | false>;

package/dist/types/plugins/render/ssrRender.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 import type { IncomingMessage } from 'http';
 import type { Reporter, ServerRoute, Logger, Metrics } from '@modern-js/types';
-import { OnError, OnTiming, Params } from '../../types/requestHandler';
-import { CacheConfig, ServerManifest, UserConfig } from '../../types';
+import type { OnError, OnTiming, Params } from '../../types/requestHandler';
+import type { CacheConfig, ServerManifest, UserConfig } from '../../types';
 export interface SSRRenderOptions {
     pwd: string;
     html: string;

package/dist/types/serverBase.d.ts

@@ -1,4 +1,4 @@
-import { ServerRoute } from '@modern-js/types';
+import type { ServerRoute } from '@modern-js/types';
 import { Hono } from 'hono';
 import type { Env, ServerConfig, ServerHookRunner, ServerPlugin } from './types';
 import type { CliConfig } from './types/config';

package/dist/types/types/config/index.d.ts

@@ -1,11 +1,11 @@
-import { BffNormalizedConfig, BffUserConfig } from './bff';
-import { DevNormalizedConfig, DevUserConfig } from './dev';
-import { HtmlNormalizedConfig, HtmlUserConfig } from './html';
-import { OutputNormalizedConfig, OutputUserConfig } from './output';
-import { SecurityNormalizedConfig, SecurityUserConfig } from './security';
-import { ServerNormalizedConfig, ServerUserConfig } from './server';
-import { SourceNormalizedConfig, SourceUserConfig } from './source';
-import { ToolsNormalizedConfig, ToolsUserConfig } from './tools';
+import type { BffNormalizedConfig, BffUserConfig } from './bff';
+import type { DevNormalizedConfig, DevUserConfig } from './dev';
+import type { HtmlNormalizedConfig, HtmlUserConfig } from './html';
+import type { OutputNormalizedConfig, OutputUserConfig } from './output';
+import type { SecurityNormalizedConfig, SecurityUserConfig } from './security';
+import type { ServerNormalizedConfig, ServerUserConfig } from './server';
+import type { SourceNormalizedConfig, SourceUserConfig } from './source';
+import type { ToolsNormalizedConfig, ToolsUserConfig } from './tools';
 export * from './bff';
 export * from './html';
 export * from './output';

package/dist/types/types/config/tools.d.ts

@@ -1,5 +1,5 @@
-import { BabelTransformOptions } from '@modern-js/types/common';
-import { ConfigChain } from './share';
+import type { BabelTransformOptions } from '@modern-js/types/common';
+import type { ConfigChain } from './share';
 type ToolsBabelConfig = ConfigChain<BabelTransformOptions, any>;
 export interface ToolsUserConfig {
     babel?: ToolsBabelConfig;

package/dist/types/types/plugin.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="node" />
 /** Hooks */
 import type { Server as NodeServer, IncomingMessage, ServerResponse } from 'http';
-import { AsyncWaterfall, ParallelWorkflow, ToRunners, ToThreads, CommonAPI, PluginOptions, AsyncSetup, createContext, AsyncPipeline } from '@modern-js/plugin';
-import { AfterMatchContext, AfterRenderContext, AfterStreamingRenderContext, CacheOption, Container, HttpMethodDecider, ISAppContext, Logger, Metrics, MiddlewareContext, Reporter, ServerRoute, UnstableMiddleware } from '@modern-js/types';
-import { MiddlewareHandler } from 'hono';
-import { UserConfig } from './config';
-import { Render } from './render';
+import type { AsyncWaterfall, ParallelWorkflow, ToRunners, ToThreads, CommonAPI, PluginOptions, AsyncSetup, createContext, AsyncPipeline } from '@modern-js/plugin';
+import type { AfterMatchContext, AfterRenderContext, AfterStreamingRenderContext, CacheOption, Container, HttpMethodDecider, ISAppContext, Logger, Metrics, MiddlewareContext, Reporter, ServerRoute, UnstableMiddleware } from '@modern-js/types';
+import type { MiddlewareHandler } from 'hono';
+import type { UserConfig } from './config';
+import type { Render } from './render';
 export type ChangeEvent = 'add' | 'change' | 'unlink';
 export interface Change {
     filename: string;
@@ -116,7 +116,7 @@ declare module '@modern-js/types' {
 }
 export type NodeRequest = IncomingMessage;
 export type NodeResponse = ServerResponse;
-export { NodeServer };
+export type { NodeServer };
 export type AppContext = ReturnType<typeof createContext<ISAppContext>>;
 export type ConfigContext = ReturnType<typeof createContext<ServerConfig>>;
 export type ServerPluginAPI = {

package/dist/types/types/requestHandler.d.ts

@@ -1,5 +1,5 @@
-import { Metrics, Reporter, ServerRoute, Logger } from '@modern-js/types';
-import { ServerUserConfig } from './config';
+import type { Metrics, Reporter, ServerRoute, Logger } from '@modern-js/types';
+import type { ServerUserConfig } from './config';
 export type Resource = {
     loadableStats: Record<string, any>;
     routeManifest: Record<string, any>;

package/dist/types/types/server.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import type { Readable } from 'node:stream';
 import type { Metrics, Logger, Reporter, BaseSSRServerContext, ServerRoute, NestedRoute, Monitors } from '@modern-js/types';
-import { RequestHandler as BundleRequestHandler, OnError, OnTiming } from './requestHandler';
+import type { RequestHandler as BundleRequestHandler, OnError, OnTiming } from './requestHandler';
 export type SSRServerContext = BaseSSRServerContext & {
     staticGenerate?: boolean;
 };

package/dist/types/utils/entry.d.ts

@@ -1,2 +1,2 @@
-import { ServerRoute } from '@modern-js/types';
+import type { ServerRoute } from '@modern-js/types';
 export declare const sortRoutes: (route1: ServerRoute, route2: ServerRoute) => number;

package/dist/types/utils/serverConfig.d.ts

@@ -1,4 +1,4 @@
-import { CliConfig, ServerConfig } from '../types';
+import type { CliConfig, ServerConfig } from '../types';
 /**
  * 对配置进行合并，cliConfig 与 serverConfig 进行深合并
  */

package/dist/types/utils/transformStream.d.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync } from '@modern-js/plugin';
+import type { MaybeAsync } from '@modern-js/plugin';
 type TransformCb = (tempalte: string) => MaybeAsync<string>;
 export declare function createTransformStream(fn?: TransformCb): TransformStream<any, any>;
 export declare function transformResponse(response: Response, transformCb: Array<TransformCb> | TransformCb): Response;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.58.1",
+  "version": "2.58.2",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -53,9 +53,9 @@
     "flatted": "^3.2.9",
     "hono": "^3.12.2",
     "ts-deepmerge": "7.0.0",
-    "@modern-js/plugin": "2.58.1",
-    "@modern-js/runtime-utils": "2.58.1",
-    "@modern-js/utils": "2.58.1"
+    "@modern-js/plugin": "2.58.2",
+    "@modern-js/runtime-utils": "2.58.2",
+    "@modern-js/utils": "2.58.2"
   },
   "devDependencies": {
     "@types/jest": "^29",
@@ -65,9 +65,9 @@
     "jest": "^29",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "@modern-js/types": "2.58.1",
-    "@scripts/build": "2.58.1",
-    "@scripts/jest-config": "2.58.1"
+    "@modern-js/types": "2.58.2",
+    "@scripts/build": "2.58.2",
+    "@scripts/jest-config": "2.58.2"
   },
   "sideEffects": false,
   "publishConfig": {