@modern-js/server-core 2.67.2 → 2.67.4

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

@@ -53,12 +53,16 @@ async function loadServerConfigOld(pwd, configFile) {
   const serverConfig = await requireConfig(serverConfigPath);
   return serverConfig;
 }
-async function loadServerRuntimeConfig(pwd, oldServerFile = import_utils.DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+async function loadServerRuntimeConfig(pwd, oldServerFile = import_utils.DEFAULT_SERVER_CONFIG, newServerConfigPath, metaName) {
   const newServerConfig = newServerConfigPath && await loadServerConfigNew(newServerConfigPath);
   if (newServerConfig) {
     return newServerConfig;
   }
   const oldServerConfig = await loadServerConfigOld(pwd, oldServerFile);
+  if (oldServerConfig) {
+    const meta = (0, import_utils.getMeta)(metaName);
+    console.warn(`${import_utils.chalk.red("\n[Warning]")} ${import_utils.chalk.yellow.bold(`\`${oldServerFile}\``)} is no longer maintained. To extend the server, please migrate to ${import_utils.chalk.yellow.bold(`\`server/${meta}.server.ts\``)};`);
+  }
   return oldServerConfig;
 }
 function loadServerCliConfig(pwd, defaultConfig = {}) {

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

@@ -35,6 +35,7 @@ __export(node_exports, {
 });
 module.exports = __toCommonJS(node_exports);
 var import_node_http = require("node:http");
+var import_cloneable_readable = __toESM(require("cloneable-readable"));
 var import_helper = require("./helper");
 var import_install = require("./polyfills/install");
 var import_stream = require("./polyfills/stream");
@@ -42,14 +43,26 @@ var import_polyfills = require("./polyfills");
 (0, import_install.installGlobals)();
 const createWebRequest = (req, res, body) => {
   const headerRecord = [];
-  const len = req.rawHeaders.length;
-  for (let i = 0; i < len; i += 2) {
-    const key = req.rawHeaders[i];
-    if (!key.startsWith(":")) {
-      headerRecord.push([
-        key,
-        req.rawHeaders[i + 1]
-      ]);
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (key.startsWith(":")) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0) {
+          headerRecord.push([
+            key,
+            item
+          ]);
+        }
+      }
+    } else if (value !== void 0) {
+      if (typeof value === "string") {
+        headerRecord.push([
+          key,
+          value
+        ]);
+      }
     }
   }
   const { method } = req;
@@ -61,13 +74,36 @@ const createWebRequest = (req, res, body) => {
   };
   res.on("close", () => controller.abort("res closed"));
   const url = `http://${req.headers.host}${req.url}`;
-  const fullUrl = new URL(url);
-  if (body || !(method === "GET" || method === "HEAD") && fullUrl.searchParams.has("__loader") || fullUrl.searchParams.has("__pass_body") || req.headers["x-mf-micro"] || req.headers["x-rsc-action"] || req.headers["x-parse-through-body"]) {
-    init.body = body !== null && body !== void 0 ? body : (0, import_stream.createReadableStreamFromReadable)(req);
+  const needsRequestBody = body || !(method === "GET" || method === "HEAD");
+  const cloneableReq = needsRequestBody ? (0, import_cloneable_readable.default)(req) : null;
+  if (needsRequestBody) {
+    if (body) {
+      init.body = body;
+    } else {
+      const stream = cloneableReq.clone();
+      init.body = (0, import_stream.createReadableStreamFromReadable)(stream);
+    }
     init.duplex = "half";
   }
-  const request = new Request(url, init);
-  return request;
+  const originalRequest = new Request(url, init);
+  if (needsRequestBody) {
+    return new Proxy(originalRequest, {
+      get(target, prop) {
+        if ([
+          "json",
+          "text",
+          "blob",
+          "arrayBuffer",
+          "formData",
+          "body"
+        ].includes(prop)) {
+          cloneableReq.resume();
+        }
+        return target[prop];
+      }
+    });
+  }
+  return originalRequest;
 };
 const sendResponse = async (response, res) => {
   var _response_headers_get;

package/dist/cjs/context.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+__export(context_exports, {
+  run: () => run,
+  useHonoContext: () => useHonoContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_storage = require("./utils/storage");
+const { run, useHonoContext } = (0, import_storage.createStorage)();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run,
+  useHonoContext
+});

package/dist/cjs/index.js

@@ -21,15 +21,19 @@ var src_exports = {};
 __export(src_exports, {
   AGGRED_DIR: () => import_constants.AGGRED_DIR,
   ErrorDigest: () => import_utils.ErrorDigest,
+  Hono: () => import_hono.Hono,
   createErrorHtml: () => import_utils.createErrorHtml,
   createServerBase: () => import_serverBase.createServerBase,
   getLoaderCtx: () => import_helper.getLoaderCtx,
-  onError: () => import_utils.onError
+  onError: () => import_utils.onError,
+  useHonoContext: () => import_context.useHonoContext
 });
 module.exports = __toCommonJS(src_exports);
 var import_utils = require("./utils");
 var import_constants = require("./constants");
 var import_serverBase = require("./serverBase");
+var import_context = require("./context");
+var import_hono = require("hono");
 var import_helper = require("./helper");
 __reExport(src_exports, require("./plugins"), module.exports);
 __reExport(src_exports, require("./types/plugins"), module.exports);
@@ -41,10 +45,12 @@ __reExport(src_exports, require("./types/requestHandler"), module.exports);
 0 && (module.exports = {
   AGGRED_DIR,
   ErrorDigest,
+  Hono,
   createErrorHtml,
   createServerBase,
   getLoaderCtx,
   onError,
+  useHonoContext,
   ...require("./plugins"),
   ...require("./types/plugins"),
   ...require("./types/render"),

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

@@ -92,19 +92,14 @@ class CustomServer {
       }
     };
   }
-  async getServerMiddleware(renderMiddlewares) {
+  async getServerMiddleware() {
     const serverMiddleware = await this.serverMiddlewarePromise;
     if (!serverMiddleware || !(0, import_utils.isFunction)(serverMiddleware) && !(0, import_utils.isArray)(serverMiddleware)) {
-      return renderMiddlewares;
+      return;
     }
     if (Array.isArray(serverMiddleware)) {
       const unstableMiddlewares = getServerMidFromUnstableMid(serverMiddleware);
-      return [
-        ...renderMiddlewares || [],
-        ...unstableMiddlewares
-      ];
-    } else if (renderMiddlewares) {
-      return renderMiddlewares;
+      return unstableMiddlewares;
     }
     return async (c, next) => {
       var _c_env_node_res, _c_env_node, _c_env;
@@ -130,9 +125,8 @@ class CustomServer {
       }
     };
   }
-  constructor(hooks, serverBase, pwd) {
+  constructor(hooks, pwd) {
     this.hooks = hooks;
-    this.serverBase = serverBase;
     const webExtension = [];
     this.serverMiddlewarePromise = hooks.prepareWebServer.call({
       pwd,

package/dist/cjs/plugins/index.js

@@ -23,6 +23,7 @@ __export(plugins_exports, {
   faviconPlugin: () => import_favicon.faviconPlugin,
   getRenderHandler: () => import_render.getRenderHandler,
   handleSetupResult: () => import_compat.handleSetupResult,
+  injectConfigMiddlewarePlugin: () => import_middlewares.injectConfigMiddlewarePlugin,
   injectRenderHandlerPlugin: () => import_render.injectRenderHandlerPlugin,
   injectServerTiming: () => import_monitors.injectServerTiming,
   injectloggerPlugin: () => import_monitors.injectloggerPlugin,
@@ -38,6 +39,7 @@ var import_processedBy = require("./processedBy");
 var import_log = require("./log");
 var import_default = require("./default");
 var import_compat = require("./compat");
+var import_middlewares = require("./middlewares");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   compatPlugin,
@@ -45,6 +47,7 @@ var import_compat = require("./compat");
   faviconPlugin,
   getRenderHandler,
   handleSetupResult,
+  injectConfigMiddlewarePlugin,
   injectRenderHandlerPlugin,
   injectServerTiming,
   injectloggerPlugin,

package/dist/cjs/plugins/middlewares.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middlewares_exports = {};
+__export(middlewares_exports, {
+  injectConfigMiddlewarePlugin: () => injectConfigMiddlewarePlugin
+});
+module.exports = __toCommonJS(middlewares_exports);
+const injectConfigMiddlewarePlugin = (configMiddlewares = [], configRenderMiddlewares = []) => ({
+  name: "@modern-js/plugin-inject-config-middleware",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares, renderMiddlewares } = api.useAppContext();
+        configMiddlewares.forEach((m) => {
+          middlewares.push(m);
+        });
+        configRenderMiddlewares.forEach((m) => {
+          renderMiddlewares.push(m);
+        });
+      }
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectConfigMiddlewarePlugin
+});

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

@@ -33,15 +33,13 @@ const renderPlugin = () => ({
   setup(api) {
     return {
       async prepare() {
-        var _config_render;
-        const { middlewares, routes, render, distDirectory: pwd, serverBase } = api.useAppContext();
+        const { middlewares, routes, render, distDirectory: pwd, renderMiddlewares } = api.useAppContext();
         const hooks = api.getHooks();
         const config = api.useConfigContext();
         if (!routes) {
           return;
         }
-        const customServer = new import_customServer.CustomServer(hooks, serverBase, pwd);
-        const serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && (0, import_customServer.getServerMidFromUnstableMid)(config.render.middleware);
+        const customServer = new import_customServer.CustomServer(hooks, pwd);
         const pageRoutes = getPageRoutes(routes);
         middlewares.push({
           name: "page-latency",
@@ -59,7 +57,14 @@ const renderPlugin = () => ({
               handler: customServerHookMiddleware
             });
           }
-          const customServerMiddleware = await customServer.getServerMiddleware(serverMiddleware);
+          renderMiddlewares === null || renderMiddlewares === void 0 ? void 0 : renderMiddlewares.forEach((m) => {
+            middlewares.push({
+              name: m.name,
+              path: urlPath,
+              handler: m.handler
+            });
+          });
+          const customServerMiddleware = await customServer.getServerMiddleware();
           customServerMiddleware && middlewares.push({
             name: "custom-server-middleware",
             path: urlPath,

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

@@ -28,7 +28,6 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig }) => ({
   setup(api) {
     return {
       async prepare() {
-        var _config_render;
         const { distDirectory: pwd, routes, metaName } = api.useAppContext();
         const config = api.useConfigContext();
         const hookRunner = api.useHookRunners();
@@ -47,7 +46,8 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig }) => ({
           routes,
           config,
           metaName,
-          cacheConfig: ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.cache) || cacheConfig,
+          // TODO: support modern.server.ts cache config
+          cacheConfig,
           staticGenerate,
           onFallback
         };

package/dist/cjs/serverBase.js

@@ -26,6 +26,7 @@ var import_class_private_method_get = require("@swc/helpers/_/_class_private_met
 var import_class_private_method_init = require("@swc/helpers/_/_class_private_method_init");
 var import_server = require("@modern-js/plugin-v2/server");
 var import_hono = require("hono");
+var import_context = require("./context");
 var import_hooks = require("./plugins/compat/hooks");
 var import_utils = require("./utils");
 var _applyMiddlewares = /* @__PURE__ */ new WeakSet();
@@ -41,7 +42,6 @@ class ServerBase {
       cliConfig,
       serverConfig: serverConfig || {}
     });
-    this.addPlugins(mergedConfig.plugins || []);
     const { serverContext } = await import_server.server.run({
       plugins: this.plugins,
       options: this.options,
@@ -99,6 +99,7 @@ class ServerBase {
     this.serverContext = null;
     this.options = options;
     this.app = new import_hono.Hono();
+    this.app.use("*", import_context.run);
   }
 }
 function applyMiddlewares() {

package/dist/cjs/utils/storage.js

@@ -0,0 +1,74 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 storage_exports = {};
+__export(storage_exports, {
+  createStorage: () => createStorage
+});
+module.exports = __toCommonJS(storage_exports);
+var ah = __toESM(require("async_hooks"));
+const createStorage = () => {
+  let storage;
+  if (typeof ah.AsyncLocalStorage !== "undefined") {
+    storage = new ah.AsyncLocalStorage();
+  }
+  const run = (context, cb) => {
+    if (!storage) {
+      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+    }
+    return new Promise((resolve, reject) => {
+      storage.run(context, () => {
+        try {
+          return resolve(cb());
+        } catch (error) {
+          return reject(error);
+        }
+      });
+    });
+  };
+  const useHonoContext = () => {
+    if (!storage) {
+      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+    }
+    const context = storage.getStore();
+    if (!context) {
+      throw new Error(`Can't call useContext out of server scope`);
+    }
+    return context;
+  };
+  return {
+    run,
+    useHonoContext
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStorage
+});

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

@@ -1,7 +1,7 @@
 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 { fs, DEFAULT_SERVER_CONFIG, OUTPUT_CONFIG_FILE, lodash as _, compatibleRequire, ensureAbsolutePath, requireExistModule } from "@modern-js/utils";
+import { fs, DEFAULT_SERVER_CONFIG, OUTPUT_CONFIG_FILE, lodash as _, chalk, compatibleRequire, ensureAbsolutePath, getMeta, requireExistModule } from "@modern-js/utils";
 import { parse } from "flatted";
 var requireConfig = function() {
   var _ref = _async_to_generator(function(serverConfigPath) {
@@ -82,12 +82,12 @@ function loadServerRuntimeConfig(pwd) {
 }
 function _loadServerRuntimeConfig() {
   _loadServerRuntimeConfig = _async_to_generator(function(pwd) {
-    var oldServerFile, newServerConfigPath, newServerConfig, _tmp, oldServerConfig;
+    var oldServerFile, newServerConfigPath, metaName, newServerConfig, _tmp, oldServerConfig, meta;
     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;
+          oldServerFile = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : DEFAULT_SERVER_CONFIG, newServerConfigPath = _arguments.length > 2 ? _arguments[2] : void 0, metaName = _arguments.length > 3 ? _arguments[3] : void 0;
           _tmp = newServerConfigPath;
           if (!_tmp)
             return [
@@ -115,6 +115,10 @@ function _loadServerRuntimeConfig() {
           ];
         case 3:
           oldServerConfig = _state.sent();
+          if (oldServerConfig) {
+            meta = getMeta(metaName);
+            console.warn("".concat(chalk.red("\n[Warning]"), " ").concat(chalk.yellow.bold("`".concat(oldServerFile, "`")), " is no longer maintained. To extend the server, please migrate to ").concat(chalk.yellow.bold("`server/".concat(meta, ".server.ts`")), ";"));
+          }
           return [
             2,
             oldServerConfig

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

@@ -4,6 +4,7 @@ import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { ServerResponse } from "node:http";
+import cloneable from "cloneable-readable";
 import { isResFinalized } from "./helper";
 import { installGlobals } from "./polyfills/install";
 import { createReadableStreamFromReadable, writeReadableStreamToWritable } from "./polyfills/stream";
@@ -11,14 +12,60 @@ import { writeReadableStreamToWritable as writeReadableStreamToWritable2 } from
 installGlobals();
 var createWebRequest = function(req, res, body) {
   var headerRecord = [];
-  var len = req.rawHeaders.length;
-  for (var i = 0; i < len; i += 2) {
-    var key = req.rawHeaders[i];
-    if (!key.startsWith(":")) {
-      headerRecord.push([
-        key,
-        req.rawHeaders[i + 1]
-      ]);
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.entries(req.headers)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+      if (key.startsWith(":")) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = value[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+            var item = _step1.value;
+            if (item !== void 0) {
+              headerRecord.push([
+                key,
+                item
+              ]);
+            }
+          }
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+              _iterator1.return();
+            }
+          } finally {
+            if (_didIteratorError1) {
+              throw _iteratorError1;
+            }
+          }
+        }
+      } else if (value !== void 0) {
+        if (typeof value === "string") {
+          headerRecord.push([
+            key,
+            value
+          ]);
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
     }
   }
   var method = req.method;
@@ -32,13 +79,36 @@ var createWebRequest = function(req, res, body) {
     return controller.abort("res closed");
   });
   var url = "http://".concat(req.headers.host).concat(req.url);
-  var fullUrl = new URL(url);
-  if (body || !(method === "GET" || method === "HEAD") && fullUrl.searchParams.has("__loader") || fullUrl.searchParams.has("__pass_body") || req.headers["x-mf-micro"] || req.headers["x-rsc-action"] || req.headers["x-parse-through-body"]) {
-    init.body = body !== null && body !== void 0 ? body : createReadableStreamFromReadable(req);
+  var needsRequestBody = body || !(method === "GET" || method === "HEAD");
+  var cloneableReq = needsRequestBody ? cloneable(req) : null;
+  if (needsRequestBody) {
+    if (body) {
+      init.body = body;
+    } else {
+      var stream = cloneableReq.clone();
+      init.body = createReadableStreamFromReadable(stream);
+    }
     init.duplex = "half";
   }
-  var request = new Request(url, init);
-  return request;
+  var originalRequest = new Request(url, init);
+  if (needsRequestBody) {
+    return new Proxy(originalRequest, {
+      get: function get(target, prop) {
+        if ([
+          "json",
+          "text",
+          "blob",
+          "arrayBuffer",
+          "formData",
+          "body"
+        ].includes(prop)) {
+          cloneableReq.resume();
+        }
+        return target[prop];
+      }
+    });
+  }
+  return originalRequest;
 };
 var sendResponse = function() {
   var _ref = _async_to_generator(function(response, res) {

package/dist/esm/context.js

@@ -0,0 +1,6 @@
+import { createStorage } from "./utils/storage";
+var _createStorage = createStorage(), run = _createStorage.run, useHonoContext = _createStorage.useHonoContext;
+export {
+  run,
+  useHonoContext
+};

package/dist/esm/index.js

@@ -1,6 +1,8 @@
 import { createErrorHtml, onError, ErrorDigest } from "./utils";
 import { AGGRED_DIR } from "./constants";
 import { createServerBase } from "./serverBase";
+import { useHonoContext } from "./context";
+import { Hono } from "hono";
 import { getLoaderCtx } from "./helper";
 export * from "./plugins";
 export * from "./types/plugins";
@@ -11,8 +13,10 @@ export * from "./types/requestHandler";
 export {
   AGGRED_DIR,
   ErrorDigest,
+  Hono,
   createErrorHtml,
   createServerBase,
   getLoaderCtx,
-  onError
+  onError,
+  useHonoContext
 };

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

@@ -1,6 +1,5 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
-import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { time } from "@modern-js/runtime-utils/time";
 import { isArray, isFunction } from "@modern-js/utils";
@@ -17,10 +16,9 @@ var isHtmlResponse = function(response) {
 };
 var CustomServer = /* @__PURE__ */ function() {
   "use strict";
-  function CustomServer2(hooks, serverBase, pwd) {
+  function CustomServer2(hooks, pwd) {
     _class_call_check(this, CustomServer2);
     this.hooks = hooks;
-    this.serverBase = serverBase;
     var webExtension = [];
     this.serverMiddlewarePromise = hooks.prepareWebServer.call({
       pwd,
@@ -165,7 +163,7 @@ var CustomServer = /* @__PURE__ */ function() {
       };
     }();
   };
-  _proto.getServerMiddleware = function getServerMiddleware(renderMiddlewares) {
+  _proto.getServerMiddleware = function getServerMiddleware() {
     var _this = this;
     return _async_to_generator(function() {
       var serverMiddleware, unstableMiddlewares;
@@ -180,20 +178,14 @@ var CustomServer = /* @__PURE__ */ function() {
             serverMiddleware = _state.sent();
             if (!serverMiddleware || !isFunction(serverMiddleware) && !isArray(serverMiddleware)) {
               return [
-                2,
-                renderMiddlewares
+                2
               ];
             }
             if (Array.isArray(serverMiddleware)) {
               unstableMiddlewares = getServerMidFromUnstableMid(serverMiddleware);
               return [
                 2,
-                _to_consumable_array(renderMiddlewares || []).concat(_to_consumable_array(unstableMiddlewares))
-              ];
-            } else if (renderMiddlewares) {
-              return [
-                2,
-                renderMiddlewares
+                unstableMiddlewares
               ];
             }
             return [