@modern-js/server-core 2.49.4-alpha.2 → 2.49.5-alpha.0

package/dist/esm/base/utils/index.js

@@ -1,7 +1,7 @@
 export * from "./env";
-export * from "./request";
 export * from "./transformStream";
 export * from "./middlewareCollector";
 export * from "./error";
 export * from "./warmup";
 export * from "./entry";
+export * from "./request";

package/dist/esm/base/utils/request.js

@@ -1,12 +1,12 @@
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-function parseQuery(request) {
-  var url = request.url;
-  var q = url.split("?")[1];
+function parseQuery(req) {
   var query = {};
+  var url = req.url;
+  var q = url.split("?")[1];
   if (q) {
-    q.split("&").forEach(function(item) {
-      var _item_split = _sliced_to_array(item.split("="), 2), key = _item_split[0], value = _item_split[1];
-      query[key] = value;
+    var search = new URLSearchParams(q);
+    search.forEach(function(v, k) {
+      query[k] = v;
     });
   }
   return query;
@@ -31,9 +31,21 @@ function getHost(request) {
   host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
   return host;
 }
+function parseCookie(req) {
+  var _cookie = req.headers.get("Cookie");
+  var cookie = {};
+  _cookie === null || _cookie === void 0 ? void 0 : _cookie.trim().split(";").forEach(function(item) {
+    var _item_trim_split = _sliced_to_array(item.trim().split("="), 2), k = _item_trim_split[0], v = _item_trim_split[1];
+    if (k) {
+      cookie[k] = v;
+    }
+  });
+  return cookie;
+}
 export {
   getHost,
   getPathname,
+  parseCookie,
   parseHeaders,
   parseQuery
 };

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/index.js

@@ -1,6 +1,6 @@
 import { createErrorHtml, onError, ErrorDigest } from "./utils";
 import { AGGRED_DIR } from "./constants";
-import { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy } from "./middlewares";
+import { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy, getLoaderCtx } from "./middlewares";
 import { createServerBase } from "./serverBase";
 export {
   AGGRED_DIR,
@@ -9,6 +9,7 @@ export {
   createErrorHtml,
   createServerBase,
   favionFallbackMiddleware,
+  getLoaderCtx,
   getRenderHandler,
   injectLogger,
   injectReporter,

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

@@ -1,8 +1,10 @@
 import { time } from "@modern-js/runtime-utils/time";
 import { transformResponse } from "../../utils";
 import { ServerReportTimings } from "../../constants";
+import { getLoaderCtx } from "./loader";
 import { getAfterMatchCtx, getAfterRenderCtx, createCustomMiddlewaresCtx, createAfterStreamingRenderContext } from "./context";
 import { createBaseHookContext } from "./base";
+import { getLoaderCtx as getLoaderCtx2 } from "./loader";
 const noop = () => {
 };
 const isHtmlResponse = (response) => {
@@ -70,22 +72,31 @@ class CustomServer {
       }
     };
   }
-  getServerMiddleware() {
+  async getServerMiddleware() {
+    const serverMiddleware = await this.serverMiddlewarePromise;
+    if (!serverMiddleware) {
+      return;
+    }
+    if (Array.isArray(serverMiddleware)) {
+      return getUnstableMiddlewares(serverMiddleware);
+    }
     return async (c, next) => {
-      var _c_env;
-      const serverMiddleware = await this.serverMiddlewarePromise;
-      if (!serverMiddleware) {
-        return next();
-      }
+      var _c_env_node_res, _c_env_node, _c_env;
       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 ((_c_env = c.env) === null || _c_env === void 0 ? void 0 : _c_env.node.res.headersSent) {
+      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 = _c_env.node) === null || _c_env_node === void 0 ? void 0 : (_c_env_node_res = _c_env_node.res) === null || _c_env_node_res === void 0 ? void 0 : _c_env_node_res.headersSent) {
         return void 0;
       }
       if (!c.finalized) {
@@ -103,10 +114,52 @@ class CustomServer {
         middleware: webExtension
       }
     }, {
-      onLast: () => null
+      onLast: () => []
     });
   }
 }
+function isRedirect(headers, code) {
+  return [
+    301,
+    302,
+    307,
+    308
+  ].includes(code || 0) || headers.get("Location");
+}
+function getUnstableMiddlewares(serverMiddleware) {
+  return serverMiddleware.map((middleware) => {
+    return async (c, next) => {
+      const context = createMiddlewareContextFromHono(c);
+      return middleware(context, next);
+    };
+  });
+}
+function createMiddlewareContextFromHono(c) {
+  const loaderContext = getLoaderCtx(c);
+  return {
+    get request() {
+      return c.req.raw;
+    },
+    get response() {
+      return c.res;
+    },
+    set response(newRes) {
+      c.res = newRes;
+    },
+    get(key) {
+      return loaderContext.get(key);
+    },
+    set(key, value) {
+      return loaderContext.set(key, value);
+    },
+    status: c.status.bind(c),
+    header: c.header.bind(c),
+    body: c.body.bind(c),
+    html: c.html.bind(c),
+    redirect: c.redirect.bind(c)
+  };
+}
 export {
-  CustomServer
+  CustomServer,
+  getLoaderCtx2 as getLoaderCtx
 };

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

@@ -0,0 +1,13 @@
+function getLoaderCtx(c) {
+  const loaderContext = c.get("loaderContext");
+  if (loaderContext) {
+    return loaderContext;
+  } else {
+    const loaderContext2 = /* @__PURE__ */ new Map();
+    c.set("loaderContext", loaderContext2);
+    return loaderContext2;
+  }
+}
+export {
+  getLoaderCtx
+};

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

@@ -3,3 +3,7 @@ export * from "./monitor";
 export * from "./renderHandler";
 export * from "./logger";
 export * from "./frameworkHeader";
+import { getLoaderCtx } from "./customServer";
+export {
+  getLoaderCtx
+};

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

@@ -1,6 +1,6 @@
 import { checkIsProd, sortRoutes, getRuntimeEnv } from "../../utils";
 import { initReporter } from "../monitor";
-import { CustomServer } from "../customServer";
+import { CustomServer, getLoaderCtx } from "../customServer";
 import { createRender } from "./render";
 function createRenderHandler(render) {
   return async (c, _) => {
@@ -11,6 +11,7 @@ function createRenderHandler(render) {
     const serverManifest = c.get("serverManifest") || {};
     const locals = c.get("locals");
     const metrics = c.get("metrics");
+    const loaderContext = getLoaderCtx(c);
     const request = c.req.raw;
     const nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
     const res = await render(request, {
@@ -20,9 +21,15 @@ function createRenderHandler(render) {
       templates,
       metrics,
       serverManifest,
+      loaderContext,
       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) {
@@ -69,8 +76,14 @@ async function bindRenderHandler(server, options) {
       const customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
       server.use(urlPath, initReporter(entryName));
       !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
-      const customServerMiddleware = customServer.getServerMiddleware();
-      server.use(urlPath, customServerMiddleware);
+      const customServerMiddleware = await customServer.getServerMiddleware();
+      if (customServerMiddleware) {
+        if (Array.isArray(customServerMiddleware)) {
+          server.use(urlPath, ...customServerMiddleware);
+        } else {
+          server.use(urlPath, customServerMiddleware);
+        }
+      }
       render && server.all(urlPath, createRenderHandler(render));
     }
   }

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

@@ -1,7 +1,7 @@
 import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
+import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest } from "../../utils";
 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) {
@@ -22,7 +22,7 @@ function matchRoute(router, request) {
 }
 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 }) => {
+  return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext }) => {
     const [routeInfo, params] = matchRoute(router, req);
     const onFallback = async (reason, error) => {
       return onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
@@ -67,7 +67,8 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       params,
       locals,
       serverManifest,
-      metrics
+      metrics,
+      loaderContext: loaderContext || /* @__PURE__ */ new Map()
     };
     switch (renderMode) {
       case "data":

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

@@ -1,8 +1,8 @@
 import { Readable } from "stream";
 import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
 import { createTransformStream, getPathname } from "../../utils";
+import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
 class CacheManager {
   async getCacheResult(req, cacheControl, render, ssrContext) {
     const key = this.computedKey(req, cacheControl);

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, params, metrics }) {
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
@@ -54,6 +54,7 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
     redirection: {},
     template: html,
     loadableStats,
+    loaderContext,
     routeManifest,
     entryName,
     staticGenerate,

package/dist/esm-node/base/utils/index.js

@@ -1,7 +1,7 @@
 export * from "./env";
-export * from "./request";
 export * from "./transformStream";
 export * from "./middlewareCollector";
 export * from "./error";
 export * from "./warmup";
 export * from "./entry";
+export * from "./request";

package/dist/esm-node/base/utils/request.js

@@ -1,11 +1,11 @@
-function parseQuery(request) {
-  const { url } = request;
-  const q = url.split("?")[1];
+function parseQuery(req) {
   const query = {};
+  const { url } = req;
+  const q = url.split("?")[1];
   if (q) {
-    q.split("&").forEach((item) => {
-      const [key, value] = item.split("=");
-      query[key] = value;
+    const search = new URLSearchParams(q);
+    search.forEach((v, k) => {
+      query[k] = v;
     });
   }
   return query;
@@ -30,9 +30,21 @@ function getHost(request) {
   host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
   return host;
 }
+function parseCookie(req) {
+  const _cookie = req.headers.get("Cookie");
+  const cookie = {};
+  _cookie === null || _cookie === void 0 ? void 0 : _cookie.trim().split(";").forEach((item) => {
+    const [k, v] = item.trim().split("=");
+    if (k) {
+      cookie[k] = v;
+    }
+  });
+  return cookie;
+}
 export {
   getHost,
   getPathname,
+  parseCookie,
   parseHeaders,
   parseQuery
 };

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/index.d.ts

@@ -1,6 +1,6 @@
 export { createErrorHtml, onError, ErrorDigest } from './utils';
 export { AGGRED_DIR } from './constants';
-export { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy, } from './middlewares';
+export { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy, getLoaderCtx, } from './middlewares';
 export type { BindRenderHandleOptions } from './middlewares';
 export type { ServerBase, ServerBaseOptions } from './serverBase';
 export { createServerBase } from './serverBase';

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/customServer/index.d.ts

@@ -3,11 +3,12 @@ import { ServerBase } from '../../serverBase';
 import { ServerHookRunner } from '../../../core/plugin';
 import { Middleware, ServerEnv } from '../../../core/server';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
+export { getLoaderCtx } from './loader';
 export declare class CustomServer {
     private runner;
     private serverMiddlewarePromise;
     private serverBase;
     constructor(runner: ServerHookRunner, serverBase: ServerBase, pwd: string);
     getHookMiddleware(entryName: string, routes: ServerRoute[]): Middleware<ServerEnv>;
-    getServerMiddleware(): Middleware<ServerNodeEnv & ServerEnv>;
+    getServerMiddleware(): Promise<Middleware<ServerNodeEnv & ServerEnv> | Array<Middleware<ServerNodeEnv & ServerEnv>> | undefined>;
 }

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

@@ -0,0 +1,10 @@
+import type { Context } from '../../../core/server';
+type LoaderContext = Map<string, unknown>;
+type Var = {
+    loaderContext: LoaderContext;
+};
+interface Env {
+    Variables: Var;
+}
+export declare function getLoaderCtx(c: Context<Env>): LoaderContext;
+export {};

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

@@ -3,3 +3,4 @@ export * from './monitor';
 export * from './renderHandler';
 export * from './logger';
 export * from './frameworkHeader';
+export { getLoaderCtx } from './customServer';

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

@@ -11,6 +11,7 @@ export interface SSRRenderOptions {
     metaName: string;
     logger: Logger;
     serverManifest: ServerManifest;
+    loaderContext: Map<string, unknown>;
     params: Params;
     /** Produce by custom server hook */
     locals?: Record<string, any>;
@@ -19,5 +20,5 @@ export interface SSRRenderOptions {
     nodeReq?: IncomingMessage;
     nonce?: string;
 }
-export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, }: SSRRenderOptions): Promise<Response>;
+export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, }: SSRRenderOptions): Promise<Response>;
 export declare function getPathnameFromNodeReq(nodeReq: IncomingMessage): string;

package/dist/types/base/utils/index.d.ts

@@ -1,7 +1,7 @@
 export * from './env';
-export * from './request';
 export * from './transformStream';
 export * from './middlewareCollector';
 export * from './error';
 export * from './warmup';
 export * from './entry';
+export * from './request';

package/dist/types/base/utils/request.d.ts

@@ -1,5 +1,7 @@
-export declare function parseQuery(request: Request): Record<string, string>;
-export declare function parseHeaders(request: Request): Record<string, string | undefined>;
+export type Query = Record<string, string>;
+export declare function parseQuery(req: Request): Query;
+export type HeadersData = Record<string, string | undefined>;
+export declare function parseHeaders(request: Request): HeadersData;
 /**
  * The function is modified based on
  * https://github.com/honojs/hono/blob/main/src/utils/url.ts
@@ -10,3 +12,6 @@ export declare function parseHeaders(request: Request): Record<string, string |
  */
 export declare function getPathname(request: Request): string;
 export declare function getHost(request: Request): string;
+type Cookie = Record<string, string>;
+export declare function parseCookie(req: Request): Cookie;
+export {};