@modern-js/prod-server 2.42.2 → 2.44.0

package/dist/cjs/libs/{render/cache/page-caches/index.js → hook-api/afterRenderForStream.js}

@@ -16,21 +16,19 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var page_caches_exports = {};
-__export(page_caches_exports, {
-  createPageCaches: () => createPageCaches
+var afterRenderForStream_exports = {};
+__export(afterRenderForStream_exports, {
+  afterRenderInjectableStream: () => afterRenderInjectableStream
+});
+module.exports = __toCommonJS(afterRenderForStream_exports);
+var import_stream = require("stream");
+const afterRenderInjectableStream = (fn) => new import_stream.Transform({
+  async write(chunk, _, callback) {
+    this.push(await fn(chunk.toString()));
+    callback();
+  }
 });
-module.exports = __toCommonJS(page_caches_exports);
-var import_lru = require("./lru");
-async function createPageCaches(max) {
-  const constructorOptions = {
-    max
-  };
-  const cacheInstance = new import_lru.LRUCaches(constructorOptions);
-  await cacheInstance.init();
-  return cacheInstance;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createPageCaches
+  afterRenderInjectableStream
 });

package/dist/cjs/libs/hook-api/index.js

@@ -21,6 +21,7 @@ __export(hook_api_exports, {
   base: () => base,
   createAfterMatchContext: () => createAfterMatchContext,
   createAfterRenderContext: () => createAfterRenderContext,
+  createAfterStreamingRenderContext: () => createAfterStreamingRenderContext,
   createMiddlewareContext: () => createMiddlewareContext
 });
 module.exports = __toCommonJS(hook_api_exports);
@@ -51,6 +52,16 @@ const createAfterRenderContext = (context, route, content) => {
     template: new import_template.TemplateAPI(content)
   };
 };
+const createAfterStreamingRenderContext = (context, route) => {
+  const baseContext = base(context);
+  return (chunk) => {
+    return {
+      ...baseContext,
+      route,
+      chunk
+    };
+  };
+};
 const createMiddlewareContext = (context) => {
   const baseContext = base(context);
   baseContext.response.locals = context.res.locals || {};
@@ -69,5 +80,6 @@ const createMiddlewareContext = (context) => {
   base,
   createAfterMatchContext,
   createAfterRenderContext,
+  createAfterStreamingRenderContext,
   createMiddlewareContext
 });

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

@@ -33,10 +33,10 @@ __export(render_exports, {
 module.exports = __toCommonJS(render_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
 var import_constants = require("../../constants");
 var import_shouldFlushServerHeader = require("../preload/shouldFlushServerHeader");
 var import_static = require("./static");
-var import_reader = require("./reader");
 var ssr = __toESM(require("./ssr"));
 var import_utils2 = require("./utils");
 const calcFallback = (metaName) => `x-${(0, import_utils.cutNameByHyphen)(metaName)}-ssr-fallback`;
@@ -51,7 +51,7 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
     return result;
   }
   const templatePath = entry;
-  const content = await (0, import_reader.readFile)(templatePath);
+  const content = await import_fileReader.fileReader.readFile(templatePath);
   if (!content) {
     return null;
   }
@@ -74,22 +74,12 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
       }
       const ssrRenderOptions = {
         distDir,
-        entryName: route.entryName,
-        urlPath: route.urlPath,
-        bundle: route.bundle,
+        route,
         template: content.toString(),
         staticGenerate,
         nonce
       };
-      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, {
-        distDir,
-        entryName: route.entryName,
-        urlPath: route.urlPath,
-        bundle: route.bundle,
-        template: content.toString(),
-        staticGenerate,
-        nonce
-      }, runner));
+      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, ssrRenderOptions, runner));
       return result;
     } catch (err) {
       ctx.error(import_constants.ERROR_DIGEST.ERENDER, err.stack || err.message);

package/dist/cjs/libs/render/ssr.js

@@ -33,12 +33,15 @@ __export(ssr_exports, {
 module.exports = __toCommonJS(ssr_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
-var import_cache = __toESM(require("./cache"));
+var import_hook_api = require("../hook-api");
+var import_afterRenderForStream = require("../hook-api/afterRenderForStream");
 var import_measure = require("./measure");
 var import_utils2 = require("./utils");
+var import_ssrCache = require("./ssrCache");
 const render = async (ctx, renderOptions, runner) => {
   var _ctx_res;
-  const { urlPath, bundle, distDir, template, entryName, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
+  const { distDir, route, template, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
+  const { urlPath, bundle, entryName } = route;
   const bundleJS = import_path.default.join(distDir, bundle);
   const loadableUri = import_path.default.join(distDir, import_utils.LOADABLE_STATS_FILE);
   const loadableStats = import_utils.fs.existsSync(loadableUri) ? require(loadableUri) : "";
@@ -83,7 +86,7 @@ const render = async (ctx, renderOptions, runner) => {
   runner.extendSSRContext(context);
   const bundleJSContent = await Promise.resolve(require(bundleJS));
   const serverRender = bundleJSContent[import_utils.SERVER_RENDER_FUNCTION_NAME];
-  const content = await (0, import_cache.default)(serverRender, ctx)(context);
+  const content = await (0, import_ssrCache.ssrCache)(ctx.req, serverRender, context);
   const { url, status = 302 } = context.redirection;
   if (url) {
     return {
@@ -99,9 +102,17 @@ const render = async (ctx, renderOptions, runner) => {
       contentType: import_utils.mime.contentType("html")
     };
   } else {
+    let contentStream = (0, import_utils2.injectServerDataStream)(content, ctx);
+    const afterStreamingRenderContext = (0, import_hook_api.createAfterStreamingRenderContext)(ctx, route);
+    contentStream = contentStream.pipe((0, import_afterRenderForStream.afterRenderInjectableStream)((chunk) => {
+      const context2 = afterStreamingRenderContext(chunk);
+      return runner.afterStreamingRender(context2, {
+        onLast: ({ chunk: chunk2 }) => chunk2
+      });
+    }));
     return {
       content: "",
-      contentStream: (0, import_utils2.injectServerDataStream)(content, ctx),
+      contentStream,
       contentType: import_utils.mime.contentType("html")
     };
   }

package/dist/cjs/libs/render/{cache/page-caches/lru.js → ssrCache/cacheMod.js}

@@ -26,41 +26,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var lru_exports = {};
-__export(lru_exports, {
-  LRUCaches: () => LRUCaches
+var cacheMod_exports = {};
+__export(cacheMod_exports, {
+  cacheMod: () => cacheMod
 });
-module.exports = __toCommonJS(lru_exports);
+module.exports = __toCommonJS(cacheMod_exports);
 var import_define_property = require("@swc/helpers/_/_define_property");
-var import_lru_cache = __toESM(require("lru-cache"));
-class LRUCaches {
-  init() {
-    return Promise.resolve();
-  }
-  keys() {
-    return this.caches.keys();
-  }
-  get(key) {
-    return Promise.resolve(this.caches.get(key) || null);
-  }
-  peek(key) {
-    return this.caches.peek(key) || null;
-  }
-  set(key, cache) {
-    this.caches.set(key, cache);
-    return Promise.resolve();
-  }
-  del(key) {
-    this.caches.del(key);
-  }
-  constructor(options) {
-    (0, import_define_property._)(this, "caches", void 0);
-    (0, import_define_property._)(this, "max", void 0);
-    this.max = options.max;
-    this.caches = new import_lru_cache.default(this.max);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+const CACHE_FILENAME = "cache";
+class ServerCacheMod {
+  loadServerCacheMod(pwd = process.cwd()) {
+    const serverCacheFilepath = import_path.default.resolve(pwd, import_utils.SERVER_DIR, CACHE_FILENAME);
+    const mod = (0, import_utils.requireExistModule)(serverCacheFilepath, {
+      interop: false
+    });
+    this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
+    this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
+  }
+  constructor() {
+    (0, import_define_property._)(this, "customContainer", void 0);
+    (0, import_define_property._)(this, "cacheOption", void 0);
   }
 }
+const cacheMod = new ServerCacheMod();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LRUCaches
+  cacheMod
 });

package/dist/cjs/libs/render/ssrCache/index.js

@@ -0,0 +1,81 @@
+"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 ssrCache_exports = {};
+__export(ssrCache_exports, {
+  ssrCache: () => ssrCache
+});
+module.exports = __toCommonJS(ssrCache_exports);
+var import_stream = require("stream");
+var import_storer = require("@modern-js/runtime-utils/storer");
+var import_cacheMod = require("./cacheMod");
+var import_manager = require("./manager");
+const cacheStorage = (0, import_storer.createMemoryStorage)("__ssr__cache");
+async function ssrCache(req, render, ssrContext) {
+  const { customContainer, cacheOption } = import_cacheMod.cacheMod;
+  const cacheControl = await matchCacheControl(req, cacheOption);
+  const cacheManager = new import_manager.CacheManager(customContainer ? customContainer : cacheStorage);
+  if (cacheControl) {
+    return cacheManager.getCacheResult(req, cacheControl, render, ssrContext);
+  } else {
+    const renderResult = await render(ssrContext);
+    if (typeof renderResult === "string") {
+      return renderResult;
+    } else {
+      const stream = new import_stream.Transform({
+        write(chunk, _, callback) {
+          this.push(chunk);
+          callback();
+        }
+      });
+      return renderResult(stream);
+    }
+  }
+}
+async function matchCacheControl(req, cacheOption) {
+  if (!cacheOption) {
+    return void 0;
+  } else if (isCacheControl(cacheOption)) {
+    return cacheOption;
+  } else if (isCacheOptionProvider(cacheOption)) {
+    return cacheOption(req);
+  } else {
+    const url = req.url;
+    const options = Object.entries(cacheOption);
+    for (const [key, option] of options) {
+      if (key === "*" || new RegExp(key).test(url)) {
+        if (typeof option === "function") {
+          return option(req);
+        } else {
+          return option;
+        }
+      }
+    }
+    return void 0;
+  }
+  function isCacheOptionProvider(option) {
+    return typeof option === "function";
+  }
+  function isCacheControl(option) {
+    return typeof option === "object" && option !== null && "maxAge" in option;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ssrCache
+});

package/dist/cjs/libs/render/ssrCache/manager.js

@@ -0,0 +1,104 @@
+"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 manager_exports = {};
+__export(manager_exports, {
+  CacheManager: () => CacheManager
+});
+module.exports = __toCommonJS(manager_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_stream = require("stream");
+class CacheManager {
+  async getCacheResult(req, cacheControl, render, ssrContext) {
+    const key = this.computedKey(req, cacheControl);
+    const value = await this.container.get(key);
+    const { maxAge, staleWhileRevalidate } = cacheControl;
+    const ttl = maxAge + staleWhileRevalidate;
+    if (value) {
+      const cache = JSON.parse(value);
+      const interval = Date.now() - cache.cursor;
+      if (interval <= maxAge) {
+        return cache.val;
+      } else if (interval <= staleWhileRevalidate + maxAge) {
+        this.processCache(key, render, ssrContext, ttl);
+        return cache.val;
+      } else {
+        return this.processCache(key, render, ssrContext, ttl);
+      }
+    } else {
+      return this.processCache(key, render, ssrContext, ttl);
+    }
+  }
+  async processCache(key, render, ssrContext, ttl) {
+    const renderResult = await render(ssrContext);
+    if (typeof renderResult === "string") {
+      const current = Date.now();
+      const cache = {
+        val: renderResult,
+        cursor: current
+      };
+      await this.container.set(key, JSON.stringify(cache), {
+        ttl
+      });
+      return renderResult;
+    } else {
+      let html;
+      const stream = new import_stream.Transform({
+        write(chunk, _, callback) {
+          html += chunk.toString();
+          this.push(chunk);
+          callback();
+        }
+      });
+      stream.on("close", () => {
+        const current = Date.now();
+        const cache = {
+          val: html,
+          cursor: current
+        };
+        this.container.set(key, JSON.stringify(cache), {
+          ttl
+        });
+      });
+      return renderResult(stream);
+    }
+  }
+  computedKey(req, cacheControl) {
+    const { url } = req;
+    const [pathname] = url.split("?");
+    const { customKey } = cacheControl;
+    const defaultKey = pathname.replace(/.+\/+$/, "");
+    if (customKey) {
+      if (typeof customKey === "string") {
+        return customKey;
+      } else {
+        return customKey(defaultKey);
+      }
+    } else {
+      return defaultKey;
+    }
+  }
+  constructor(container) {
+    (0, import_define_property._)(this, "container", void 0);
+    this.container = container;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheManager
+});

package/dist/cjs/libs/render/static.js

@@ -33,19 +33,19 @@ __export(static_exports, {
 module.exports = __toCommonJS(static_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
-var import_reader = require("./reader");
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
 async function handleDirectory(ctx, entryPath, urlPath) {
   const { path: pathname } = ctx;
   const filepath = import_path.default.join(entryPath, trimLeft(pathname, urlPath));
-  let content = await (0, import_reader.readFile)(filepath);
+  let content = await import_fileReader.fileReader.readFile(filepath);
   let contentType = import_utils.mime.contentType(import_path.default.extname(filepath) || "");
   if (!content) {
     if (pathname.endsWith("/")) {
-      content = await (0, import_reader.readFile)(`${filepath}index.html`);
+      content = await import_fileReader.fileReader.readFile(`${filepath}index.html`);
     } else if (!pathname.includes(".")) {
-      content = await (0, import_reader.readFile)(`${filepath}.html`);
+      content = await import_fileReader.fileReader.readFile(`${filepath}.html`);
       if (!content) {
-        content = await (0, import_reader.readFile)(`${filepath}/index.html`);
+        content = await import_fileReader.fileReader.readFile(`${filepath}/index.html`);
       }
     }
     if (content) {

package/dist/cjs/server/index.js

@@ -121,6 +121,8 @@ class Server {
     });
   }
   async close() {
+    var _this_server_close, _this_server;
+    await ((_this_server_close = (_this_server = this.server).close) === null || _this_server_close === void 0 ? void 0 : _this_server_close.call(_this_server));
     this.app.close();
   }
   listen(options, listener) {

package/dist/cjs/server/modernServer.js

@@ -40,11 +40,11 @@ var import_route = require("../libs/route");
 var import_render = require("../libs/render");
 var import_serveFile = require("../libs/serveFile");
 var import_utils2 = require("../utils");
-var reader = __toESM(require("../libs/render/reader"));
 var import_proxy = require("../libs/proxy");
 var import_context = require("../libs/context");
 var import_constants = require("../constants");
 var import_hook_api = require("../libs/hook-api");
+var import_cacheMod = require("../libs/render/ssrCache/cacheMod");
 const SERVER_DIR = "./server";
 class ModernServer {
   // server prepare
@@ -52,7 +52,6 @@ class ModernServer {
     var _conf_bff, _this_conf_output;
     this.runner = runner;
     const { distDir, conf } = this;
-    this.initReader();
     (0, import_utils2.debug)("final server conf", this.conf);
     if ((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy) {
       const { handlers, handleUpgrade } = (0, import_proxy.createProxyHandler)(conf.bff.proxy);
@@ -61,12 +60,10 @@ class ModernServer {
         this.addHandler(handler);
       });
     }
-    app === null || app === void 0 ? void 0 : app.on("close", () => {
-      this.reader.close();
-    });
     const usageRoutes = this.filterRoutes(this.getRoutes());
     this.router.reset(usageRoutes);
     this.warmupSSRBundle();
+    import_cacheMod.cacheMod.loadServerCacheMod(this.pwd);
     await this.prepareFrameHandler();
     await this.prepareLoaderHandler(usageRoutes, distDir);
     this.routeRenderHandler = this.getRenderHandler();
@@ -122,9 +119,6 @@ class ModernServer {
     return (0, import_http.createServer)(handler);
   }
   /* —————————————————————— function will be overwrite —————————————————————— */
-  initReader() {
-    this.reader.init();
-  }
   async onServerChange({ filepath }) {
     const { pwd } = this;
     const { api, server } = import_constants.AGGRED_DIR;
@@ -508,7 +502,6 @@ class ModernServer {
     (0, import_define_property._)(this, "logger", void 0);
     (0, import_define_property._)(this, "metrics", void 0);
     (0, import_define_property._)(this, "runMode", void 0);
-    (0, import_define_property._)(this, "reader", reader);
     (0, import_define_property._)(this, "proxyTarget", void 0);
     (0, import_define_property._)(this, "routeRenderHandler", void 0);
     (0, import_define_property._)(this, "staticGenerate", void 0);

package/dist/esm/libs/hook-api/afterRenderForStream.js

@@ -0,0 +1,33 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { Transform } from "stream";
+var afterRenderInjectableStream = function(fn) {
+  return new Transform({
+    write: function write(chunk, _, callback) {
+      return _async_to_generator(function() {
+        var _2, _1;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              _1 = (_2 = this).push;
+              return [
+                4,
+                fn(chunk.toString())
+              ];
+            case 1:
+              _1.apply(_2, [
+                _state.sent()
+              ]);
+              callback();
+              return [
+                2
+              ];
+          }
+        });
+      }).apply(this);
+    }
+  });
+};
+export {
+  afterRenderInjectableStream
+};

package/dist/esm/libs/hook-api/index.js

@@ -25,6 +25,15 @@ var createAfterRenderContext = function(context, route, content) {
     template: new TemplateAPI(content)
   });
 };
+var createAfterStreamingRenderContext = function(context, route) {
+  var baseContext = base(context);
+  return function(chunk) {
+    return _object_spread_props(_object_spread({}, baseContext), {
+      route,
+      chunk
+    });
+  };
+};
 var createMiddlewareContext = function(context) {
   var baseContext = base(context);
   baseContext.response.locals = context.res.locals || {};
@@ -41,5 +50,6 @@ export {
   base,
   createAfterMatchContext,
   createAfterRenderContext,
+  createAfterStreamingRenderContext,
   createMiddlewareContext
 };

package/dist/esm/libs/render/index.js

@@ -2,10 +2,10 @@ 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 { cutNameByHyphen, mime } from "@modern-js/utils";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
 import { ERROR_DIGEST } from "../../constants";
 import { shouldFlushServerHeader } from "../preload/shouldFlushServerHeader";
 import { handleDirectory } from "./static";
-import { readFile } from "./reader";
 import * as ssr from "./ssr";
 import { injectServerData } from "./utils";
 var calcFallback = function(metaName) {
@@ -47,7 +47,7 @@ var createRenderHandler = function(param) {
             templatePath = entry;
             return [
               4,
-              readFile(templatePath)
+              fileReader.readFile(templatePath)
             ];
           case 3:
             content = _state.sent();
@@ -97,24 +97,14 @@ var createRenderHandler = function(param) {
           case 6:
             ssrRenderOptions = {
               distDir,
-              entryName: route.entryName,
-              urlPath: route.urlPath,
-              bundle: route.bundle,
+              route,
               template: content.toString(),
               staticGenerate,
               nonce
             };
             return [
               4,
-              ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, {
-                distDir,
-                entryName: route.entryName,
-                urlPath: route.urlPath,
-                bundle: route.bundle,
-                template: content.toString(),
-                staticGenerate,
-                nonce
-              }, runner)
+              ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, ssrRenderOptions, runner)
             ];
           case 7:
             result1 = _state.sent();

package/dist/esm/libs/render/ssr.js

@@ -2,16 +2,19 @@ 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, mime, LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
-import cache from "./cache";
+import { createAfterStreamingRenderContext } from "../hook-api";
+import { afterRenderInjectableStream } from "../hook-api/afterRenderForStream";
 import { createLogger, createMetrics } from "./measure";
 import { injectServerDataStream, injectServerData } from "./utils";
+import { ssrCache } from "./ssrCache";
 var render = function() {
   var _ref = _async_to_generator(function(ctx, renderOptions, runner) {
-    var _ctx_res, urlPath, bundle, distDir, template, entryName, staticGenerate, _renderOptions_enableUnsafeCtx, enableUnsafeCtx, nonce, bundleJS, loadableUri, loadableStats, routesManifestUri, routeManifest, context, bundleJSContent, serverRender, content, _context_redirection, url, _context_redirection_status, status;
+    var _ctx_res, distDir, route, template, staticGenerate, _renderOptions_enableUnsafeCtx, enableUnsafeCtx, nonce, urlPath, bundle, entryName, bundleJS, loadableUri, loadableStats, routesManifestUri, routeManifest, context, bundleJSContent, serverRender, content, _context_redirection, url, _context_redirection_status, status, contentStream, afterStreamingRenderContext;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          urlPath = renderOptions.urlPath, bundle = renderOptions.bundle, distDir = renderOptions.distDir, template = renderOptions.template, entryName = renderOptions.entryName, staticGenerate = renderOptions.staticGenerate, _renderOptions_enableUnsafeCtx = renderOptions.enableUnsafeCtx, enableUnsafeCtx = _renderOptions_enableUnsafeCtx === void 0 ? false : _renderOptions_enableUnsafeCtx, nonce = renderOptions.nonce;
+          distDir = renderOptions.distDir, route = renderOptions.route, template = renderOptions.template, staticGenerate = renderOptions.staticGenerate, _renderOptions_enableUnsafeCtx = renderOptions.enableUnsafeCtx, enableUnsafeCtx = _renderOptions_enableUnsafeCtx === void 0 ? false : _renderOptions_enableUnsafeCtx, nonce = renderOptions.nonce;
+          urlPath = route.urlPath, bundle = route.bundle, entryName = route.entryName;
           bundleJS = path.join(distDir, bundle);
           loadableUri = path.join(distDir, LOADABLE_STATS_FILE);
           loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
@@ -63,7 +66,7 @@ var render = function() {
           serverRender = bundleJSContent[SERVER_RENDER_FUNCTION_NAME];
           return [
             4,
-            cache(serverRender, ctx)(context)
+            ssrCache(ctx.req, serverRender, context)
           ];
         case 2:
           content = _state.sent();
@@ -88,11 +91,22 @@ var render = function() {
               }
             ];
           } else {
+            contentStream = injectServerDataStream(content, ctx);
+            afterStreamingRenderContext = createAfterStreamingRenderContext(ctx, route);
+            contentStream = contentStream.pipe(afterRenderInjectableStream(function(chunk) {
+              var context2 = afterStreamingRenderContext(chunk);
+              return runner.afterStreamingRender(context2, {
+                onLast: function(param) {
+                  var _$chunk = param.chunk;
+                  return _$chunk;
+                }
+              });
+            }));
             return [
               2,
               {
                 content: "",
-                contentStream: injectServerDataStream(content, ctx),
+                contentStream,
                 contentType: mime.contentType("html")
               }
             ];