@modern-js/server-core 2.49.4-alpha.1 → 2.49.4

package/dist/esm/base/middlewares/customServer/index.js

@@ -161,7 +161,7 @@ var CustomServer = /* @__PURE__ */ function() {
     var _this = this;
     return function() {
       var _ref = _async_to_generator(function(c, next) {
-        var _c_env, serverMiddleware, reporter, locals, customMiddlewareCtx, getCost, cost;
+        var _c_env, serverMiddleware, reporter, locals, resArgs, customMiddlewareCtx, getCost, cost;
         return _ts_generator(this, function(_state) {
           switch (_state.label) {
             case 0:
@@ -179,7 +179,10 @@ var CustomServer = /* @__PURE__ */ function() {
               }
               reporter = c.get("reporter");
               locals = {};
-              customMiddlewareCtx = createCustomMiddlewaresCtx(c, locals);
+              resArgs = {
+                headers: new Headers()
+              };
+              customMiddlewareCtx = createCustomMiddlewaresCtx(c, locals, resArgs);
               getCost = time();
               return [
                 4,
@@ -190,6 +193,12 @@ var CustomServer = /* @__PURE__ */ function() {
               cost = getCost();
               cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_MIDDLEWARE, cost));
               c.set("locals", locals);
+              if (isRedirect(resArgs.headers, resArgs.status)) {
+                return [
+                  2,
+                  c.redirect(resArgs.headers.get("Location") || "", resArgs.status || 302)
+                ];
+              }
               if ((_c_env = c.env) === null || _c_env === void 0 ? void 0 : _c_env.node.res.headersSent) {
                 return [
                   2,
@@ -215,6 +224,14 @@ var CustomServer = /* @__PURE__ */ function() {
   };
   return CustomServer2;
 }();
+function isRedirect(headers, code) {
+  return [
+    301,
+    302,
+    307,
+    308
+  ].includes(code || 0) || headers.get("Location");
+}
 export {
   CustomServer
 };

package/dist/esm/base/middlewares/renderHandler/index.js

@@ -8,7 +8,7 @@ import { createRender } from "./render";
 function createRenderHandler(render) {
   return function() {
     var _ref = _async_to_generator(function(c, _) {
-      var _c_env_node, logger, reporter, templates, serverManifest, locals, metrics, request, nodeReq, res;
+      var _c_env_node, logger, reporter, templates, serverManifest, locals, metrics, request, nodeReq, res, body, status, headers, headersData;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
@@ -34,9 +34,14 @@ function createRenderHandler(render) {
             ];
           case 1:
             res = _state.sent();
+            body = res.body, status = res.status, headers = res.headers;
+            headersData = {};
+            headers.forEach(function(v, k) {
+              headersData[k] = v;
+            });
             return [
               2,
-              res
+              c.body(body, status, headersData)
             ];
         }
       });

package/dist/esm/base/middlewares/renderHandler/render.js

@@ -1,28 +1,64 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { cutNameByHyphen } from "@modern-js/utils/universal";
+import { TrieRouter } from "hono/router/trie-router";
 import { REPLACE_REG } from "../../../base/constants";
 import { createErrorHtml, sortRoutes, parseQuery, transformResponse, getPathname, onError as onErrorFn, ErrorDigest } from "../../utils";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
+function getRouter(routes) {
+  var sorted = routes.sort(sortRoutes);
+  var router = new TrieRouter();
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = sorted[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var route = _step.value;
+      var originUrlPath = route.urlPath;
+      var urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
+      router.add("*", urlPath, route);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return router;
+}
+function matchRoute(router, request) {
+  var pathname = getPathname(request);
+  var matched = router.match("*", pathname);
+  var result = matched[0][0];
+  return result || [];
+}
 function createRender(_) {
   return _createRender.apply(this, arguments);
 }
 function _createRender() {
   _createRender = _async_to_generator(function(param) {
-    var routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallbackFn;
+    var routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallbackFn, router;
     return _ts_generator(this, function(_state) {
       routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, forceCSR = param.forceCSR, nonce = param.nonce, onFallbackFn = param.onFallback;
+      router = getRouter(routes);
       return [
         2,
         function() {
           var _ref = _async_to_generator(function(req, param2) {
-            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, routeInfo, onFallback, html, renderMode, onError, renderOptions, response;
+            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, _matchRoute, routeInfo, params, onFallback, html, renderMode, onError, renderOptions, response;
             return _ts_generator(this, function(_state2) {
               switch (_state2.label) {
                 case 0:
                   logger = param2.logger, nodeReq = param2.nodeReq, reporter = param2.reporter, templates = param2.templates, serverManifest = param2.serverManifest, locals = param2.locals, metrics = param2.metrics;
-                  routeInfo = matchRoute(req, routes);
+                  _matchRoute = _sliced_to_array(matchRoute(router, req), 2), routeInfo = _matchRoute[0], params = _matchRoute[1];
                   onFallback = function() {
                     var _ref2 = _async_to_generator(function(reason, error) {
                       return _ts_generator(this, function(_state3) {
@@ -102,6 +138,7 @@ function _createRender() {
                     nodeReq,
                     reporter,
                     serverRoutes: routes,
+                    params,
                     locals,
                     serverManifest,
                     metrics
@@ -179,14 +216,20 @@ function renderHandler(request, options, mode, onError) {
 }
 function _renderHandler() {
   _renderHandler = _async_to_generator(function(request, options, mode, onError) {
-    var serverData, response, e;
+    var serverData, response, e, newRes, routeInfo;
+    function applyExtendHeaders(r, route) {
+      Object.entries(route.responseHeaders || {}).forEach(function(param) {
+        var _param = _sliced_to_array(param, 2), k = _param[0], v = _param[1];
+        r.headers.set(k, v);
+      });
+    }
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
           serverData = {
             router: {
               baseUrl: options.routeInfo.urlPath,
-              params: {}
+              params: options.params
             }
           };
           if (!(mode === "ssr"))
@@ -234,42 +277,18 @@ function _renderHandler() {
           response = csrRender(options.html);
           _state.label = 7;
         case 7:
+          newRes = transformResponse(response, injectServerData(serverData));
+          routeInfo = options.routeInfo;
+          applyExtendHeaders(newRes, routeInfo);
           return [
             2,
-            transformResponse(response, injectServerData(serverData))
+            newRes
           ];
       }
     });
   });
   return _renderHandler.apply(this, arguments);
 }
-function matchRoute(req, routes) {
-  var sorted = routes.sort(sortRoutes);
-  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-  try {
-    for (var _iterator = sorted[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var route = _step.value;
-      var pathname = getPathname(req);
-      if (pathname.startsWith(route.urlPath)) {
-        return route;
-      }
-    }
-  } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
-      }
-    } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
-      }
-    }
-  }
-  return void 0;
-}
 function getRenderMode(req, framework, isSSR, forceCSR, nodeReq, onFallback) {
   return _getRenderMode.apply(this, arguments);
 }

package/dist/esm/base/middlewares/renderHandler/ssrRender.js

@@ -24,11 +24,11 @@ function ssrRender(request, _) {
 }
 function _ssrRender() {
   _ssrRender = _async_to_generator(function(request, param) {
-    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, host, isSpider, responseProxy, query, headers, key, ssrContext, renderBundle, runtimeEnv, ssrResult, cacheStatus, render, cacheModuleName, ssrCache, incomingMessage, cacheControl, _ref, data, status, redirection, headers1, Readable, streamModule, createReadableStreamFromReadable, _tmp, data1;
+    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, host, isSpider, responseProxy, query, headers, key, ssrContext, renderBundle, runtimeEnv, ssrResult, cacheStatus, render, cacheModuleName, ssrCache, incomingMessage, cacheControl, _ref, data, status, redirection, headers1, Readable, streamModule, createReadableStreamFromReadable, _tmp, data1;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          routeInfo = param.routeInfo, html = param.html, staticGenerate = param.staticGenerate, nonce = param.nonce, metaName = param.metaName, reporter = param.reporter, logger = param.logger, nodeReq = param.nodeReq, serverManifest = param.serverManifest, locals = param.locals, metrics = param.metrics;
+          routeInfo = param.routeInfo, html = param.html, staticGenerate = param.staticGenerate, nonce = param.nonce, metaName = param.metaName, reporter = param.reporter, logger = param.logger, nodeReq = param.nodeReq, serverManifest = param.serverManifest, locals = param.locals, params = param.params, metrics = param.metrics;
           entryName = routeInfo.entryName;
           loadableStats = serverManifest.loadableStats || {};
           routeManifest = serverManifest.routeManifest || {};
@@ -47,7 +47,7 @@ function _ssrRender() {
           ssrContext = {
             request: {
               baseUrl: routeInfo.urlPath,
-              params: {},
+              params,
               pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : getPathname(request),
               host,
               query,

package/dist/esm-node/base/adapters/node/middlewares/serverPublic.js

@@ -14,6 +14,9 @@ function createPublicMiddleware({ pwd, routes }) {
         if (mimeType) {
           c.header("Content-Type", mimeType);
         }
+        Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
+          c.header(k, v);
+        });
         return c.body(data, 200);
       }
     }
@@ -22,7 +25,7 @@ function createPublicMiddleware({ pwd, routes }) {
 }
 function matchRoute(req, routes) {
   for (const route of routes.sort(sortRoutes)) {
-    if (!route.isSSR && !route.isApi && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
+    if (!route.isSSR && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
       return route;
     }
   }

package/dist/esm-node/base/adapters/node/middlewares/serverStatic.js

@@ -2,7 +2,6 @@ import path from "path";
 import { fs } from "@modern-js/utils";
 import { getMimeType } from "hono/utils/mime";
 import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { createErrorHtml } from "../../../utils";
 import { createPublicMiddleware } from "./serverPublic";
 function createStaticMiddleware(options) {
   const { pwd, routes } = options;
@@ -36,7 +35,7 @@ function createStaticMiddleware(options) {
     if (hit) {
       const filepath = path.join(pwd, pathname.replace(prefix, () => ""));
       if (!await fs.pathExists(filepath)) {
-        return c.html(createErrorHtml(404), 404);
+        return next();
       }
       const mimeType = getMimeType(filepath);
       if (mimeType) {

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

@@ -1,4 +1,4 @@
-import { createServer, ServerResponse } from "node:http";
+import { ServerResponse } from "node:http";
 import { createReadableStreamFromReadable, writeReadableStreamToWritable } from "./polyfills/stream";
 import { installGlobals } from "./polyfills/install";
 installGlobals();
@@ -87,9 +87,16 @@ const getRequestListener = (handler) => {
     }
   };
 };
-const createNodeServer = (requestHandler) => {
+const createNodeServer = async (requestHandler, httpsOptions) => {
   const requestListener = getRequestListener(requestHandler);
-  const nodeServer = createServer(requestListener);
+  let nodeServer;
+  if (httpsOptions) {
+    const { createServer } = await import("node:https");
+    nodeServer = createServer(httpsOptions, requestListener);
+  } else {
+    const { createServer } = await import("node:http");
+    nodeServer = createServer(requestListener);
+  }
   nodeServer.getRequestListener = () => requestListener;
   nodeServer.getRequestHandler = () => requestHandler;
   return nodeServer;

package/dist/esm-node/base/adapters/node/polyfills/stream.js

@@ -3,17 +3,24 @@ async function writeReadableStreamToWritable(stream, writable) {
   const reader = stream.getReader();
   const flushable = writable;
   try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        writable.end();
-        break;
-      }
-      writable.write(value);
-      if (typeof flushable.flush === "function") {
-        flushable.flush();
-      }
-    }
+    await new Promise((resolve, reject) => {
+      writable.on("finish", resolve);
+      writable.on("error", reject);
+      const writeAndFlush = async () => {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            writable.end();
+            break;
+          }
+          writable.write(value);
+          if (typeof flushable.flush === "function") {
+            flushable.flush();
+          }
+        }
+      };
+      writeAndFlush().catch(reject);
+    });
   } catch (error) {
     writable.destroy(error);
     throw error;

package/dist/esm-node/base/middlewares/customServer/base.js

@@ -3,12 +3,12 @@ import { _ as _class_private_field_init } from "@swc/helpers/_/_class_private_fi
 import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_field_set";
 import { getCookie } from "hono/cookie";
 import { getHost } from "../../utils";
-function createBaseHookContext(c) {
+function createBaseHookContext(c, resParams) {
   const logger = c.get("logger");
   const metrics = c.get("metrics");
   return {
     request: new BaseHookRequest(c),
-    response: new BaseHookResponse(c),
+    response: new BaseHookResponse(c, resParams),
     logger,
     metrics
   };
@@ -95,7 +95,7 @@ class BaseHookRequest {
     }));
   }
 }
-var _c1 = /* @__PURE__ */ new WeakMap();
+var _c1 = /* @__PURE__ */ new WeakMap(), _resArgs = /* @__PURE__ */ new WeakMap();
 class BaseHookResponse {
   get(key) {
     return _class_private_field_get(this, _c1).res.headers.get(key);
@@ -105,15 +105,20 @@ class BaseHookResponse {
       "set-cookie",
       "Set-Cookie"
     ].includes(key)) {
+      var _class_private_field_get1;
       _class_private_field_get(this, _c1).header(key, value.toString(), {
         append: true
       });
+      (_class_private_field_get1 = _class_private_field_get(this, _resArgs)) === null || _class_private_field_get1 === void 0 ? void 0 : _class_private_field_get1.headers.append(key, value.toString());
     } else {
+      var _class_private_field_get2;
       _class_private_field_get(this, _c1).header(key, value.toString());
+      (_class_private_field_get2 = _class_private_field_get(this, _resArgs)) === null || _class_private_field_get2 === void 0 ? void 0 : _class_private_field_get2.headers.set(key, value.toString());
     }
   }
   status(code) {
     _class_private_field_get(this, _c1).status(code);
+    _class_private_field_get(this, _resArgs) && (_class_private_field_get(this, _resArgs).status = code);
   }
   get cookies() {
     const setCookie = (key, value) => {
@@ -133,13 +138,18 @@ class BaseHookResponse {
     _class_private_field_get(this, _c1).res = _class_private_field_get(this, _c1).newResponse(body, options);
     this.private_overrided = true;
   }
-  constructor(c) {
+  constructor(c, resArgs) {
     _class_private_field_init(this, _c1, {
       writable: true,
       value: void 0
     });
+    _class_private_field_init(this, _resArgs, {
+      writable: true,
+      value: void 0
+    });
     this.private_overrided = false;
     _class_private_field_set(this, _c1, c);
+    _class_private_field_set(this, _resArgs, resArgs);
   }
 }
 export {

package/dist/esm-node/base/middlewares/customServer/context.js

@@ -13,9 +13,9 @@ async function getAfterRenderCtx(c, baseHookCtx, route) {
   afterRenderCtx.route = route;
   return afterRenderCtx;
 }
-function createCustomMiddlewaresCtx(c, locals) {
+function createCustomMiddlewaresCtx(c, locals, resArgs) {
   var _c_env_node, _c_env_node1;
-  const baseContext = createBaseHookContext(c);
+  const baseContext = createBaseHookContext(c, resArgs);
   const reporter = c.get("reporter");
   const response = baseContext.response;
   response.locals = locals;

package/dist/esm-node/base/middlewares/customServer/index.js

@@ -79,12 +79,18 @@ class CustomServer {
       }
       const reporter = c.get("reporter");
       const locals = {};
-      const customMiddlewareCtx = createCustomMiddlewaresCtx(c, locals);
+      const resArgs = {
+        headers: new Headers()
+      };
+      const customMiddlewareCtx = createCustomMiddlewaresCtx(c, locals, resArgs);
       const getCost = time();
       await serverMiddleware(customMiddlewareCtx);
       const cost = getCost();
       cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_MIDDLEWARE, cost));
       c.set("locals", locals);
+      if (isRedirect(resArgs.headers, resArgs.status)) {
+        return c.redirect(resArgs.headers.get("Location") || "", resArgs.status || 302);
+      }
       if ((_c_env = c.env) === null || _c_env === void 0 ? void 0 : _c_env.node.res.headersSent) {
         return void 0;
       }
@@ -107,6 +113,14 @@ class CustomServer {
     });
   }
 }
+function isRedirect(headers, code) {
+  return [
+    301,
+    302,
+    307,
+    308
+  ].includes(code || 0) || headers.get("Location");
+}
 export {
   CustomServer
 };

package/dist/esm-node/base/middlewares/renderHandler/index.js

@@ -22,7 +22,12 @@ function createRenderHandler(render) {
       serverManifest,
       locals
     });
-    return res;
+    const { body, status, headers } = res;
+    const headersData = {};
+    headers.forEach((v, k) => {
+      headersData[k] = v;
+    });
+    return c.body(body, status, headersData);
   };
 }
 async function getRenderHandler(options, serverBase) {

package/dist/esm-node/base/middlewares/renderHandler/render.js

@@ -1,11 +1,29 @@
 import { cutNameByHyphen } from "@modern-js/utils/universal";
+import { TrieRouter } from "hono/router/trie-router";
 import { REPLACE_REG } from "../../../base/constants";
 import { createErrorHtml, sortRoutes, parseQuery, transformResponse, getPathname, onError as onErrorFn, ErrorDigest } from "../../utils";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
+function getRouter(routes) {
+  const sorted = routes.sort(sortRoutes);
+  const router = new TrieRouter();
+  for (const route of sorted) {
+    const { urlPath: originUrlPath } = route;
+    const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
+    router.add("*", urlPath, route);
+  }
+  return router;
+}
+function matchRoute(router, request) {
+  const pathname = getPathname(request);
+  const matched = router.match("*", pathname);
+  const result = matched[0][0];
+  return result || [];
+}
 async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallback: onFallbackFn }) {
+  const router = getRouter(routes);
   return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics }) => {
-    const routeInfo = matchRoute(req, routes);
+    const [routeInfo, params] = matchRoute(router, req);
     const onFallback = async (reason, error) => {
       return onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
         logger,
@@ -46,6 +64,7 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       nodeReq,
       reporter,
       serverRoutes: routes,
+      params,
       locals,
       serverManifest,
       metrics
@@ -69,7 +88,7 @@ async function renderHandler(request, options, mode, onError) {
   const serverData = {
     router: {
       baseUrl: options.routeInfo.urlPath,
-      params: {}
+      params: options.params
     }
   };
   let response;
@@ -83,17 +102,15 @@ async function renderHandler(request, options, mode, onError) {
   } else {
     response = csrRender(options.html);
   }
-  return transformResponse(response, injectServerData(serverData));
-}
-function matchRoute(req, routes) {
-  const sorted = routes.sort(sortRoutes);
-  for (const route of sorted) {
-    const pathname = getPathname(req);
-    if (pathname.startsWith(route.urlPath)) {
-      return route;
-    }
+  const newRes = transformResponse(response, injectServerData(serverData));
+  const { routeInfo } = options;
+  applyExtendHeaders(newRes, routeInfo);
+  return newRes;
+  function applyExtendHeaders(r, route) {
+    Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
+      r.headers.set(k, v);
+    });
   }
-  return void 0;
 }
 async function getRenderMode(req, framework, isSSR, forceCSR, nodeReq, onFallback) {
   const query = parseQuery(req);

package/dist/esm-node/base/middlewares/renderHandler/ssrRender.js

@@ -15,7 +15,7 @@ const defaultReporter = {
   reportWarn() {
   }
 };
-async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics }) {
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
@@ -35,7 +35,7 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
   const ssrContext = {
     request: {
       baseUrl: routeInfo.urlPath,
-      params: {},
+      params,
       pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : getPathname(request),
       host,
       query,

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

@@ -1,13 +1,15 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Server as NodeServer } from 'node:http';
+import type { Server as NodeHttpsServer } from 'node:https';
 import { NodeRequest, NodeResponse } from '../../../core/plugin';
 import { RequestHandler } from '../../../core/server';
 export declare const createWebRequest: (req: NodeRequest, res: NodeResponse) => Request;
 export declare const sendResponse: (response: Response, res: NodeResponse) => Promise<void>;
 declare const getRequestListener: (handler: RequestHandler) => (req: NodeRequest, res: NodeResponse) => Promise<void>;
-type NodeServerWrapper = NodeServer & {
+type NodeServerWrapper = (NodeServer | NodeHttpsServer) & {
     getRequestListener: () => ReturnType<typeof getRequestListener>;
     getRequestHandler: () => RequestHandler;
 };
-export declare const createNodeServer: (requestHandler: RequestHandler) => NodeServerWrapper;
+export declare const createNodeServer: (requestHandler: RequestHandler, httpsOptions?: Record<string, unknown>) => Promise<NodeServerWrapper>;
 export {};

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

@@ -1,3 +1,7 @@
 import { HookContext } from '@modern-js/types';
 import type { Context, ServerEnv } from '../../../core/server';
-export declare function createBaseHookContext(c: Context<ServerEnv>): HookContext;
+export type ResArgs = {
+    status?: number;
+    headers: Headers;
+};
+export declare function createBaseHookContext(c: Context<ServerEnv>, resParams?: ResArgs): HookContext;

package/dist/types/base/middlewares/customServer/context.d.ts

@@ -1,7 +1,8 @@
 import { AfterMatchContext, AfterRenderContext, MiddlewareContext, AfterStreamingRenderContext, ServerRoute, HookContext } from '@modern-js/types';
 import { Context, ServerEnv } from '../../../core/server';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
+import { 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>): MiddlewareContext;
+export declare function createCustomMiddlewaresCtx(c: Context<ServerNodeEnv & ServerEnv>, locals: Record<string, any>, resArgs?: ResArgs): MiddlewareContext;
 export declare function createAfterStreamingRenderContext(baseHookCtx: HookContext, route: Partial<ServerRoute>): (chunk: string) => AfterStreamingRenderContext;

package/dist/types/base/middlewares/renderHandler/ssrRender.d.ts

@@ -2,6 +2,7 @@
 import type { IncomingMessage } from 'http';
 import type { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
 import { ServerManifest } from '../../../core/server';
+export type Params = Record<string, any>;
 export interface SSRRenderOptions {
     pwd: string;
     html: string;
@@ -10,6 +11,7 @@ export interface SSRRenderOptions {
     metaName: string;
     logger: Logger;
     serverManifest: ServerManifest;
+    params: Params;
     /** Produce by custom server hook */
     locals?: Record<string, any>;
     reporter?: Reporter;
@@ -17,5 +19,5 @@ export interface SSRRenderOptions {
     nodeReq?: IncomingMessage;
     nonce?: string;
 }
-export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics, }: SSRRenderOptions): Promise<Response>;
+export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, }: SSRRenderOptions): Promise<Response>;
 export declare function getPathnameFromNodeReq(nodeReq: IncomingMessage): string;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.49.4-alpha.1",
+  "version": "2.49.4",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -69,9 +69,9 @@
     "hono": "^3.12.2",
     "isbot": "3.8.0",
     "merge-deep": "^3.0.3",
-    "@modern-js/runtime-utils": "2.49.3",
-    "@modern-js/utils": "2.49.3",
-    "@modern-js/plugin": "2.49.3"
+    "@modern-js/plugin": "2.49.4",
+    "@modern-js/runtime-utils": "2.49.4",
+    "@modern-js/utils": "2.49.4"
   },
   "devDependencies": {
     "@types/jest": "^29",
@@ -81,9 +81,9 @@
     "jest": "^29",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "@scripts/build": "2.49.3",
-    "@modern-js/types": "2.49.3",
-    "@scripts/jest-config": "2.49.3"
+    "@modern-js/types": "2.49.4",
+    "@scripts/jest-config": "2.49.4",
+    "@scripts/build": "2.49.4"
   },
   "sideEffects": false,
   "publishConfig": {