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

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

@@ -9,7 +9,7 @@ function writeReadableStreamToWritable(stream, writable) {
 }
 function _writeReadableStreamToWritable() {
   _writeReadableStreamToWritable = _async_to_generator(function(stream, writable) {
-    var reader, flushable, _ref, done, value, error;
+    var reader, flushable, error;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -19,48 +19,72 @@ function _writeReadableStreamToWritable() {
         case 1:
           _state.trys.push([
             1,
-            5,
+            3,
             ,
-            6
+            4
           ]);
-          _state.label = 2;
-        case 2:
-          if (false)
-            return [
-              3,
-              4
-            ];
           return [
             4,
-            reader.read()
+            new Promise(function(resolve, reject) {
+              writable.on("finish", resolve);
+              writable.on("error", reject);
+              var writeAndFlush = function() {
+                var _ref = _async_to_generator(function() {
+                  var _ref2, done, value;
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        if (false)
+                          return [
+                            3,
+                            2
+                          ];
+                        return [
+                          4,
+                          reader.read()
+                        ];
+                      case 1:
+                        _ref2 = _state2.sent(), done = _ref2.done, value = _ref2.value;
+                        if (done) {
+                          writable.end();
+                          return [
+                            3,
+                            2
+                          ];
+                        }
+                        writable.write(value);
+                        if (typeof flushable.flush === "function") {
+                          flushable.flush();
+                        }
+                        return [
+                          3,
+                          0
+                        ];
+                      case 2:
+                        return [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return function writeAndFlush2() {
+                  return _ref.apply(this, arguments);
+                };
+              }();
+              writeAndFlush().catch(reject);
+            })
           ];
-        case 3:
-          _ref = _state.sent(), done = _ref.done, value = _ref.value;
-          if (done) {
-            writable.end();
-            return [
-              3,
-              4
-            ];
-          }
-          writable.write(value);
-          if (typeof flushable.flush === "function") {
-            flushable.flush();
-          }
-          return [
-            3,
-            2
-          ];
-        case 4:
+        case 2:
+          _state.sent();
           return [
             3,
-            6
+            4
           ];
-        case 5:
+        case 3:
           error = _state.sent();
           writable.destroy(error);
           throw error;
-        case 6:
+        case 4:
           return [
             2
           ];

package/dist/esm/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/base/middlewares/customServer/base.js

@@ -5,12 +5,12 @@ import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_fie
 import { _ as _create_class } from "@swc/helpers/_/_create_class";
 import { getCookie } from "hono/cookie";
 import { getHost } from "../../utils";
-function createBaseHookContext(c) {
+function createBaseHookContext(c, resParams) {
   var logger = c.get("logger");
   var metrics = c.get("metrics");
   return {
     request: new BaseHookRequest(c),
-    response: new BaseHookResponse(c),
+    response: new BaseHookResponse(c, resParams),
     logger,
     metrics
   };
@@ -137,17 +137,22 @@ var BaseHookRequest = /* @__PURE__ */ function() {
   ]);
   return BaseHookRequest2;
 }();
-var _c1 = /* @__PURE__ */ new WeakMap();
+var _c1 = /* @__PURE__ */ new WeakMap(), _resArgs = /* @__PURE__ */ new WeakMap();
 var BaseHookResponse = /* @__PURE__ */ function() {
   "use strict";
-  function BaseHookResponse2(c) {
+  function BaseHookResponse2(c, resArgs) {
     _class_call_check(this, BaseHookResponse2);
     _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);
   }
   var _proto = BaseHookResponse2.prototype;
   _proto.get = function get(key) {
@@ -158,15 +163,20 @@ var BaseHookResponse = /* @__PURE__ */ function() {
       "set-cookie",
       "Set-Cookie"
     ].includes(key)) {
+      var _$_class_private_field_get;
       _class_private_field_get(this, _c1).header(key, value.toString(), {
         append: true
       });
+      (_$_class_private_field_get = _class_private_field_get(this, _resArgs)) === null || _$_class_private_field_get === void 0 ? void 0 : _$_class_private_field_get.headers.append(key, value.toString());
     } else {
+      var _$_class_private_field_get1;
       _class_private_field_get(this, _c1).header(key, value.toString());
+      (_$_class_private_field_get1 = _class_private_field_get(this, _resArgs)) === null || _$_class_private_field_get1 === void 0 ? void 0 : _$_class_private_field_get1.headers.set(key, value.toString());
     }
   };
   _proto.status = function status(code) {
     _class_private_field_get(this, _c1).status(code);
+    _class_private_field_get(this, _resArgs) && (_class_private_field_get(this, _resArgs).status = code);
   };
   _proto.raw = function raw(body, options) {
     _class_private_field_get(this, _c1).res = _class_private_field_get(this, _c1).newResponse(body, options);

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

@@ -37,9 +37,9 @@ function _getAfterRenderCtx() {
   });
   return _getAfterRenderCtx.apply(this, arguments);
 }
-function createCustomMiddlewaresCtx(c, locals) {
+function createCustomMiddlewaresCtx(c, locals, resArgs) {
   var _c_env_node, _c_env_node1;
-  var baseContext = createBaseHookContext(c);
+  var baseContext = createBaseHookContext(c, resArgs);
   var reporter = c.get("reporter");
   var response = baseContext.response;
   response.locals = locals;

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

@@ -4,8 +4,10 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 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";
 var noop = function() {
 };
 var isHtmlResponse = function(response) {
@@ -26,7 +28,7 @@ var CustomServer = /* @__PURE__ */ function() {
       }
     }, {
       onLast: function() {
-        return null;
+        return [];
       }
     });
   }
@@ -159,62 +161,140 @@ var CustomServer = /* @__PURE__ */ function() {
   };
   _proto.getServerMiddleware = function getServerMiddleware() {
     var _this = this;
-    return function() {
-      var _ref = _async_to_generator(function(c, next) {
-        var _c_env, serverMiddleware, reporter, locals, customMiddlewareCtx, getCost, cost;
-        return _ts_generator(this, function(_state) {
-          switch (_state.label) {
-            case 0:
+    return _async_to_generator(function() {
+      var serverMiddleware;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              _this.serverMiddlewarePromise
+            ];
+          case 1:
+            serverMiddleware = _state.sent();
+            if (!serverMiddleware) {
               return [
-                4,
-                _this.serverMiddlewarePromise
+                2
               ];
-            case 1:
-              serverMiddleware = _state.sent();
-              if (!serverMiddleware) {
-                return [
-                  2,
-                  next()
-                ];
-              }
-              reporter = c.get("reporter");
-              locals = {};
-              customMiddlewareCtx = createCustomMiddlewaresCtx(c, locals);
-              getCost = time();
+            }
+            if (Array.isArray(serverMiddleware)) {
               return [
-                4,
-                serverMiddleware(customMiddlewareCtx)
+                2,
+                getUnstableMiddlewares(serverMiddleware)
               ];
-            case 2:
-              _state.sent();
-              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) {
-                return [
-                  2,
-                  void 0
-                ];
-              }
-              if (!c.finalized) {
-                return [
-                  2,
-                  next()
-                ];
-              }
-              return [
-                2
-              ];
-          }
+            }
+            return [
+              2,
+              function() {
+                var _ref = _async_to_generator(function(c, next) {
+                  var _c_env_node_res, _c_env_node, _c_env, reporter, locals, resArgs, customMiddlewareCtx, getCost, cost;
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        reporter = c.get("reporter");
+                        locals = {};
+                        resArgs = {
+                          headers: new Headers()
+                        };
+                        customMiddlewareCtx = createCustomMiddlewaresCtx(c, locals, resArgs);
+                        getCost = time();
+                        return [
+                          4,
+                          serverMiddleware(customMiddlewareCtx)
+                        ];
+                      case 1:
+                        _state2.sent();
+                        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 = _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 [
+                            2,
+                            void 0
+                          ];
+                        }
+                        if (!c.finalized) {
+                          return [
+                            2,
+                            next()
+                          ];
+                        }
+                        return [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return function(c, next) {
+                  return _ref.apply(this, arguments);
+                };
+              }()
+            ];
+        }
+      });
+    })();
+  };
+  return CustomServer2;
+}();
+function isRedirect(headers, code) {
+  return [
+    301,
+    302,
+    307,
+    308
+  ].includes(code || 0) || headers.get("Location");
+}
+function getUnstableMiddlewares(serverMiddleware) {
+  return serverMiddleware.map(function(middleware) {
+    return function() {
+      var _ref = _async_to_generator(function(c, next) {
+        var context;
+        return _ts_generator(this, function(_state) {
+          context = createMiddlewareContextFromHono(c);
+          return [
+            2,
+            middleware(context, next)
+          ];
         });
       });
       return function(c, next) {
         return _ref.apply(this, arguments);
       };
     }();
+  });
+}
+function createMiddlewareContextFromHono(c) {
+  var loaderContext = getLoaderCtx(c);
+  return {
+    get request() {
+      return c.req.raw;
+    },
+    get response() {
+      return c.res;
+    },
+    set response(newRes) {
+      c.res = newRes;
+    },
+    get: function get(key) {
+      return loaderContext.get(key);
+    },
+    set: function 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)
   };
-  return CustomServer2;
-}();
+}
 export {
-  CustomServer
+  CustomServer,
+  getLoaderCtx2 as getLoaderCtx
 };

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

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

package/dist/esm/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/base/middlewares/renderHandler/index.js

@@ -1,14 +1,15 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 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 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, loaderContext, request, nodeReq, res, body, status, headers, headersData;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
@@ -18,6 +19,7 @@ function createRenderHandler(render) {
             serverManifest = c.get("serverManifest") || {};
             locals = c.get("locals");
             metrics = c.get("metrics");
+            loaderContext = getLoaderCtx(c);
             request = c.req.raw;
             nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
             return [
@@ -29,14 +31,20 @@ function createRenderHandler(render) {
                 templates,
                 metrics,
                 serverManifest,
+                loaderContext,
                 locals
               })
             ];
           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)
             ];
         }
       });
@@ -109,7 +117,7 @@ function bindRenderHandler(server, options) {
 }
 function _bindRenderHandler() {
   _bindRenderHandler = _async_to_generator(function(server, options) {
-    var routes, pwd, disableCustomHook, runner, customServer, cacheModuleName, ssrCache, pageRoutes, render, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, originUrlPath, entryName, urlPath, customServerHookMiddleware, customServerMiddleware;
+    var routes, pwd, disableCustomHook, runner, customServer, cacheModuleName, ssrCache, pageRoutes, render, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, originUrlPath, entryName, urlPath, customServerHookMiddleware, customServerMiddleware, _server, err;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -118,7 +126,7 @@ function _bindRenderHandler() {
           if (!(routes && routes.length > 0))
             return [
               3,
-              5
+              12
             ];
           customServer = new CustomServer(runner, server, pwd);
           if (!(getRuntimeEnv() === "node"))
@@ -151,34 +159,79 @@ function _bindRenderHandler() {
         case 4:
           render = _state.sent();
           _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-          try {
-            for (_iterator = pageRoutes[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-              route = _step.value;
-              originUrlPath = route.urlPath, entryName = route.entryName;
-              urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
-              customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
-              server.use(urlPath, initReporter(entryName));
-              !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
-              customServerMiddleware = customServer.getServerMiddleware();
+          _state.label = 5;
+        case 5:
+          _state.trys.push([
+            5,
+            10,
+            11,
+            12
+          ]);
+          _iterator = pageRoutes[Symbol.iterator]();
+          _state.label = 6;
+        case 6:
+          if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+            return [
+              3,
+              9
+            ];
+          route = _step.value;
+          originUrlPath = route.urlPath, entryName = route.entryName;
+          urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
+          customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
+          server.use(urlPath, initReporter(entryName));
+          !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
+          return [
+            4,
+            customServer.getServerMiddleware()
+          ];
+        case 7:
+          customServerMiddleware = _state.sent();
+          if (customServerMiddleware) {
+            if (Array.isArray(customServerMiddleware)) {
+              ;
+              (_server = server).use.apply(_server, [
+                urlPath
+              ].concat(_to_consumable_array(customServerMiddleware)));
+            } else {
               server.use(urlPath, customServerMiddleware);
-              render && server.all(urlPath, createRenderHandler(render));
             }
-          } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
+          }
+          render && server.all(urlPath, createRenderHandler(render));
+          _state.label = 8;
+        case 8:
+          _iteratorNormalCompletion = true;
+          return [
+            3,
+            6
+          ];
+        case 9:
+          return [
+            3,
+            12
+          ];
+        case 10:
+          err = _state.sent();
+          _didIteratorError = true;
+          _iteratorError = err;
+          return [
+            3,
+            12
+          ];
+        case 11:
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
           } finally {
-            try {
-              if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-              }
-            } finally {
-              if (_didIteratorError) {
-                throw _iteratorError;
-              }
+            if (_didIteratorError) {
+              throw _iteratorError;
             }
           }
-          _state.label = 5;
-        case 5:
+          return [
+            7
+          ];
+        case 12:
           return [
             2
           ];

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

@@ -3,8 +3,8 @@ 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 { 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) {
@@ -53,11 +53,11 @@ function _createRender() {
         2,
         function() {
           var _ref = _async_to_generator(function(req, param2) {
-            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, _matchRoute, routeInfo, params, onFallback, html, renderMode, onError, renderOptions, response;
+            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext, _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;
+                  logger = param2.logger, nodeReq = param2.nodeReq, reporter = param2.reporter, templates = param2.templates, serverManifest = param2.serverManifest, locals = param2.locals, metrics = param2.metrics, loaderContext = param2.loaderContext;
                   _matchRoute = _sliced_to_array(matchRoute(router, req), 2), routeInfo = _matchRoute[0], params = _matchRoute[1];
                   onFallback = function() {
                     var _ref2 = _async_to_generator(function(reason, error) {
@@ -141,7 +141,8 @@ function _createRender() {
                     params,
                     locals,
                     serverManifest,
-                    metrics
+                    metrics,
+                    loaderContext: loaderContext || /* @__PURE__ */ new Map()
                   };
                   switch (renderMode) {
                     case "data":

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

@@ -6,8 +6,8 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 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";
 var CacheManager = /* @__PURE__ */ function() {
   "use strict";
   function CacheManager2(container) {

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, 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;
+    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, _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, params = param.params, 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, loaderContext = param.loaderContext;
           entryName = routeInfo.entryName;
           loadableStats = serverManifest.loadableStats || {};
           routeManifest = serverManifest.routeManifest || {};
@@ -66,6 +66,7 @@ function _ssrRender() {
             redirection: {},
             template: html,
             loadableStats,
+            loaderContext,
             routeManifest,
             entryName,
             staticGenerate,