@bleedingdev/modern-js-prod-server 3.2.0-ultramodern.0

package/dist/esm/server/modernServer.mjs

@@ -0,0 +1,419 @@
+import { time } from "@modern-js/runtime-utils/time";
+import { ROUTE_SPEC_FILE, fs, isPromise, isWebOnly, mime } from "@modern-js/utils";
+import { createServer } from "http";
+import path from "path";
+import { AGGRED_DIR, ERROR_DIGEST, ERROR_PAGE_TEXT, RUN_MODE, ServerReportTimings } from "../constants";
+import { createContext } from "../libs/context";
+import { createAfterMatchContext, createAfterRenderContext, createMiddlewareContext } from "../libs/hook-api";
+import { resolveMfAssetCacheHeaders } from "../libs/mfCache";
+import { createProxyHandler } from "../libs/proxy";
+import { createRenderHandler } from "../libs/render/index.mjs";
+import * as __rspack_external__libs_render_reader_11828727 from "../libs/render/reader";
+import { RouteMatchManager } from "../libs/route";
+import { createStaticFileHandler, faviconFallbackHandler } from "../libs/serveFile";
+import { createErrorDocument, createMiddlewareCollecter, debug, getStaticReg, isRedirect, mergeExtension, noop } from "../utils.mjs";
+import { __webpack_require__ } from "../rslib-runtime.mjs";
+import * as __rspack_external_ignore_styles_9f5737c8 from "ignore-styles";
+__webpack_require__.add({
+    "ignore-styles" (module) {
+        module.exports = __rspack_external_ignore_styles_9f5737c8;
+    }
+});
+const SERVER_DIR = './server';
+class ModernServer {
+    async onInit(runner, app) {
+        this.runner = runner;
+        const { distDir, conf } = this;
+        this.initReader();
+        debug('final server conf', this.conf);
+        if (conf.bff?.proxy) {
+            const { handlers, handleUpgrade } = createProxyHandler(conf.bff.proxy);
+            app && handleUpgrade(app);
+            handlers.forEach((handler)=>{
+                this.addHandler(handler);
+            });
+        }
+        app?.on('close', ()=>{
+            this.reader.close();
+        });
+        const usageRoutes = this.filterRoutes(this.getRoutes());
+        this.router.reset(usageRoutes);
+        this.warmupSSRBundle();
+        await this.prepareFrameHandler();
+        await this.prepareLoaderHandler(usageRoutes, distDir);
+        this.routeRenderHandler = this.getRenderHandler();
+        await this.setupBeforeProdMiddleware();
+        this.addHandler(this.setupMfAssetCacheMiddleware());
+        this.addHandler(this.setupStaticMiddleware(this.conf.output?.assetPrefix));
+        this.addHandler(faviconFallbackHandler);
+        this.addHandler(this.routeHandler.bind(this));
+        this.compose();
+    }
+    getRenderHandler() {
+        const { distDir, staticGenerate, conf, metaName } = this;
+        const ssrConfig = this.conf.server?.ssr;
+        const forceCSR = 'object' == typeof ssrConfig ? ssrConfig.forceCSR : false;
+        return createRenderHandler({
+            distDir,
+            staticGenerate,
+            forceCSR,
+            conf: this.conf,
+            nonce: conf.security?.nonce,
+            metaName
+        });
+    }
+    onRepack(_) {}
+    getRequestHandler() {
+        return this.requestHandler.bind(this);
+    }
+    async render(req, res, url) {
+        req.logger = req.logger || this.logger;
+        req.metrics = req.metrics || this.metrics;
+        const context = createContext(req, res, {
+            metaName: this.metaName
+        });
+        const matched = this.router.match(url || context.path);
+        if (!matched) return null;
+        res.statusCode = 200;
+        const route = matched.generate(context.url);
+        const result = await this.handleWeb(context, route);
+        if (!result) return null;
+        if (result.contentStream) return result.contentStream;
+        return result.content.toString();
+    }
+    async createHTTPServer(handler) {
+        return createServer(handler);
+    }
+    initReader() {
+        this.reader.init();
+    }
+    async onServerChange({ filepath }) {
+        const { pwd } = this;
+        const { api, server } = AGGRED_DIR;
+        const apiPath = path.normalize(path.join(pwd, api));
+        const serverPath = path.normalize(path.join(pwd, server));
+        const onlyApi = filepath.startsWith(apiPath);
+        const onlyWeb = filepath.startsWith(serverPath);
+        await this.prepareFrameHandler({
+            onlyWeb,
+            onlyApi
+        });
+    }
+    getRoutes() {
+        if (this.presetRoutes) return this.presetRoutes;
+        const file = path.join(this.distDir, ROUTE_SPEC_FILE);
+        if (fs.existsSync(file)) {
+            const content = fs.readJSONSync(file);
+            return content.routes;
+        }
+        return [];
+    }
+    addHandler(handler) {
+        this.handlers.push(handler);
+    }
+    render404(context) {
+        context.error(ERROR_DIGEST.ENOTF, '404 Not Found');
+        this.renderErrorPage(context, 404);
+    }
+    async prepareLoaderHandler(specs, distDir) {
+        const { runner } = this;
+        const handler = await runner.prepareLoaderHandler({
+            serverRoutes: specs,
+            distDir
+        }, {
+            onLast: ()=>null
+        });
+        this.loaderHandler = handler;
+    }
+    async prepareFrameHandler(options) {
+        const { workDir, runner } = this;
+        const { onlyApi, onlyWeb } = options || {};
+        const { getMiddlewares, ...collector } = createMiddlewareCollecter();
+        await runner.gather(collector);
+        const { api: pluginAPIExt, web: pluginWebExt } = getMiddlewares();
+        const serverDir = path.join(workDir, SERVER_DIR);
+        if (await fs.pathExists(path.join(serverDir)) && !onlyApi) {
+            const webExtension = mergeExtension(pluginWebExt);
+            this.frameWebHandler = await this.prepareWebHandler(webExtension);
+        }
+        if (!onlyWeb) {
+            const apiExtension = mergeExtension(pluginAPIExt);
+            this.frameAPIHandler = await this.prepareAPIHandler(apiExtension);
+        }
+    }
+    async prepareWebHandler(extension) {
+        const { workDir, runner } = this;
+        const handler = await runner.prepareWebServer({
+            pwd: workDir,
+            config: extension
+        }, {
+            onLast: ()=>null
+        });
+        return handler;
+    }
+    async prepareAPIHandler(extension) {
+        const { workDir, runner, conf } = this;
+        const { bff } = conf;
+        const prefix = bff?.prefix || '/api';
+        const webOnly = await isWebOnly();
+        if (webOnly && 'development' === process.env.NODE_ENV) return (req, res)=>{
+            res.setHeader('Content-Type', 'text/plain');
+            res.end(JSON.stringify(''));
+        };
+        return runner.prepareApiServer({
+            pwd: workDir,
+            config: extension,
+            prefix: Array.isArray(prefix) ? prefix[0] : prefix,
+            httpMethodDecider: bff?.httpMethodDecider,
+            render: this.render.bind(this)
+        }, {
+            onLast: ()=>null
+        });
+    }
+    filterRoutes(routes) {
+        return routes;
+    }
+    async setupBeforeProdMiddleware() {
+        const { conf, runner } = this;
+        const preMiddleware = await runner.beforeProdServer(conf);
+        preMiddleware.flat().forEach((mid)=>{
+            this.addHandler(mid);
+        });
+    }
+    setupStaticMiddleware(prefix) {
+        const staticPathRegExp = getStaticReg(this.conf.output, this.conf.html, prefix);
+        return createStaticFileHandler([
+            {
+                path: staticPathRegExp,
+                target: this.distDir
+            }
+        ], prefix);
+    }
+    setupMfAssetCacheMiddleware() {
+        return async (context, next)=>{
+            const headers = resolveMfAssetCacheHeaders(context.url, context.query);
+            if (headers) for (const [key, value] of Object.entries(headers))context.res.setHeader(key, value);
+            await next();
+        };
+    }
+    async handleAPI(context) {
+        const { req, res } = context;
+        if (!this.frameAPIHandler) throw new Error('can not found api handler');
+        await this.frameAPIHandler(req, res);
+    }
+    async handleWeb(context, route) {
+        const { res } = context;
+        if (this.loaderHandler) {
+            await this.loaderHandler(context);
+            if (this.isSend(res)) return null;
+        }
+        context.setParams(route.params);
+        context.setServerData('router', {
+            baseUrl: route.urlPath,
+            params: route.params
+        });
+        if (route.responseHeaders) Object.keys(route.responseHeaders).forEach((key)=>{
+            const value = route.responseHeaders[key];
+            if (value) context.res.setHeader(key, value);
+        });
+        const renderResult = await this.routeRenderHandler({
+            ctx: context,
+            route,
+            runner: this.runner
+        });
+        if (!renderResult) {
+            this.render404(context);
+            return null;
+        }
+        if (renderResult.redirect) {
+            this.redirect(res, renderResult.content, renderResult.statusCode);
+            return null;
+        }
+        if (this.isSend(res)) return null;
+        res.set('content-type', renderResult.contentType);
+        return renderResult;
+    }
+    async proxy() {
+        return null;
+    }
+    warmupSSRBundle() {
+        const { distDir } = this;
+        const bundles = this.router.getBundles();
+        bundles.forEach((bundle)=>{
+            const filepath = path.join(distDir, bundle);
+            if (fs.existsSync(filepath)) require(filepath);
+        });
+    }
+    createContext(req, res, options = {}) {
+        return createContext(req, res, options);
+    }
+    async routeHandler(context) {
+        const { res, reporter } = context;
+        const matched = this.router.match(context.path);
+        if (!matched) return void this.render404(context);
+        await reporter.init({
+            match: matched
+        });
+        const end = time();
+        res.on('finish', ()=>{
+            const cost = end();
+            reporter.reportTiming(ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
+        });
+        let route = matched.generate(context.url);
+        if (route.isApi) return void await this.handleAPI(context);
+        if (route.entryName && this.runMode === RUN_MODE.FULL) {
+            const afterMatchContext = createAfterMatchContext(context, route.entryName);
+            const end = time();
+            await this.runner.afterMatch(afterMatchContext, {
+                onLast: noop
+            });
+            const cost = end();
+            cost && reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost);
+            if (this.isSend(res)) return;
+            const { current, url, status } = afterMatchContext.router;
+            if (url) return void this.redirect(res, url, status);
+            if (route.entryName !== current) {
+                const matched = this.router.matchEntry(current);
+                if (!matched) return void this.render404(context);
+                route = matched.generate(context.url);
+            }
+        }
+        if (this.frameWebHandler) {
+            res.locals = res.locals || {};
+            const middlewareContext = createMiddlewareContext(context);
+            const end = time();
+            await this.frameWebHandler(middlewareContext);
+            const cost = end();
+            cost && reporter.reportTiming(ServerReportTimings.SERVER_MIDDLEWARE, cost);
+            res.locals = {
+                ...res.locals,
+                ...middlewareContext.response.locals
+            };
+            if (this.isSend(res)) return;
+        }
+        const renderResult = await this.handleWeb(context, route);
+        if (!renderResult) return;
+        const { contentStream: responseStream } = renderResult;
+        let { content: response } = renderResult;
+        if (route.entryName && responseStream) return void responseStream.pipe(res);
+        if (route.entryName && this.runMode === RUN_MODE.FULL) {
+            const afterRenderContext = createAfterRenderContext(context, response.toString());
+            const end = time();
+            await this.runner.afterRender(afterRenderContext, {
+                onLast: noop
+            });
+            const cost = end();
+            cost && reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost);
+            if (this.isSend(res)) return;
+            response = afterRenderContext.template.get();
+        }
+        res.end(response);
+    }
+    isSend(res) {
+        if (res.modernFlushedHeaders) {
+            if (res.writableFinished) return true;
+        } else if (res.headersSent) return true;
+        if (res.getHeader('Location') && isRedirect(res.statusCode)) {
+            res.end();
+            return true;
+        }
+        return false;
+    }
+    compose() {
+        const { handlers } = this;
+        if (!Array.isArray(handlers)) throw new TypeError('Middleware stack must be an array!');
+        for (const fn of handlers)if ('function' != typeof fn) throw new TypeError('Middleware must be composed of functions!');
+        this._handler = (context, next)=>{
+            let i = 0;
+            const dispatch = (error)=>{
+                if (error) return this.onError(context, error);
+                const handler = handlers[i++];
+                if (!handler) return next();
+                try {
+                    const result = handler(context, dispatch);
+                    if (isPromise(result)) return result.catch(onError);
+                } catch (e) {
+                    return onError(e);
+                }
+            };
+            const onError = (err)=>{
+                this.onError(context, err);
+            };
+            return dispatch();
+        };
+    }
+    requestHandler(req, res, next = ()=>{}) {
+        res.statusCode = 200;
+        req.logger = req.logger || this.logger;
+        req.metrics = req.metrics || this.metrics;
+        let context;
+        try {
+            context = this.createContext(req, res, {
+                metaName: this.metaName
+            });
+        } catch (e) {
+            this.logger.error(e);
+            res.statusCode = 500;
+            res.setHeader('content-type', mime.contentType('html'));
+            return res.end(createErrorDocument(500, ERROR_PAGE_TEXT["500"]));
+        }
+        try {
+            return this._handler(context, next);
+        } catch (err) {
+            return this.onError(context, err);
+        }
+    }
+    redirect(res, url, status = 302) {
+        res.set('Location', url);
+        res.statusCode = status;
+        res.end();
+    }
+    onError(context, err) {
+        context.error(ERROR_DIGEST.EINTER, err);
+        this.renderErrorPage(context, 500);
+    }
+    async renderErrorPage(context, status) {
+        const { res } = context;
+        context.status = status;
+        res.set('content-type', mime.contentType('html'));
+        const statusPage = `/${status}`;
+        const customErrorPage = "/_error";
+        const matched = this.router.match(statusPage) || this.router.match(customErrorPage);
+        if (matched) {
+            const route = matched.generate(context.url);
+            const { entryName } = route;
+            if (entryName === status.toString() || '_error' === entryName) try {
+                const file = await this.routeRenderHandler({
+                    route,
+                    ctx: context,
+                    runner: this.runner
+                });
+                if (file) return void context.res.end(file.content);
+            } catch (e) {}
+        }
+        const text = ERROR_PAGE_TEXT[status] || ERROR_PAGE_TEXT["500"];
+        context.res.end(createErrorDocument(status, text));
+    }
+    constructor({ pwd, config, routes, staticGenerate, logger, metrics, runMode, proxyTarget, appContext }){
+        this.handlers = [];
+        this.reader = __rspack_external__libs_render_reader_11828727;
+        this.loaderHandler = null;
+        this.frameWebHandler = null;
+        this.frameAPIHandler = null;
+        __webpack_require__("ignore-styles");
+        this.pwd = pwd;
+        this.distDir = path.resolve(pwd, config.output.path || 'dist');
+        this.workDir = this.distDir;
+        this.conf = config;
+        debug('server conf', this.conf);
+        this.logger = logger;
+        this.metrics = metrics;
+        this.router = new RouteMatchManager();
+        this.presetRoutes = routes;
+        this.proxyTarget = proxyTarget;
+        this.staticGenerate = staticGenerate || false;
+        this.runMode = runMode || RUN_MODE.FULL;
+        this.metaName = appContext?.metaName;
+    }
+}
+export { ModernServer };

package/dist/esm/server/modernServerSplit.mjs

@@ -0,0 +1,4 @@
+const createProdServer = ()=>{
+    throw new Error('createProdServer from modernServerSplit is not available in this source runtime.');
+};
+export { createProdServer };

package/dist/esm/utils.mjs

@@ -0,0 +1,4 @@
+const debug = (...args)=>{
+    if (process.env.MODERN_DEBUG || process.env.DEBUG) console.log('[prod-server]', ...args);
+};
+export { debug };

package/dist/esm-node/apply.mjs

@@ -0,0 +1,64 @@
+import "node:module";
+import { ErrorDigest, createDefaultPlugins, createErrorHtml, faviconPlugin, injectConfigMiddlewarePlugin, onError, renderPlugin } from "@modern-js/server-core";
+import { injectNodeSeverPlugin, injectResourcePlugin, injectRscManifestPlugin, loadCacheConfig, serverStaticPlugin } from "@modern-js/server-core/node";
+import { createLogger, isProd, logger } from "@modern-js/utils";
+function getLogger(_) {
+    if (process.env.DEBUG || 'production' === process.env.NODE_ENV) return createLogger({
+        level: process.env.MODERN_SERVER_LOG_LEVEL || 'verbose'
+    });
+    return createLogger();
+}
+async function applyPlugins(serverBase, options, nodeServer) {
+    const { pwd, appContext, config, logger: optLogger, serverConfig } = options;
+    const enableRsc = config.server?.rsc ?? serverConfig?.server?.rsc ?? false;
+    const serverErrorHandler = options.serverConfig?.onError;
+    const loadCachePwd = isProd() ? pwd : appContext.appDirectory || pwd;
+    const cacheConfig = await loadCacheConfig(loadCachePwd);
+    serverBase.notFound((c)=>{
+        const monitors = c.get('monitors');
+        onError(ErrorDigest.ENOTF, '404 not found', monitors, c.req.raw);
+        return c.html(createErrorHtml(404), 404);
+    });
+    serverBase.onError(async (err, c)=>{
+        const monitors = c.get('monitors');
+        onError(ErrorDigest.EINTER, err, monitors, c.req.raw);
+        if (serverErrorHandler) try {
+            const result = await serverErrorHandler(err, c);
+            if (result instanceof Response) return result;
+        } catch (configError) {
+            logger.error(`Error in serverConfig.onError handler: ${configError}`);
+        }
+        const bffPrefix = config.bff?.prefix || '/api';
+        const bffPrefixList = Array.isArray(bffPrefix) ? bffPrefix : [
+            bffPrefix
+        ];
+        const isApiPath = bffPrefixList.some((prefix)=>c.req.path.startsWith(prefix));
+        if (isApiPath) return c.json({
+            message: err?.message || '[BFF] Internal Server Error'
+        }, err?.status || 500);
+        return c.html(createErrorHtml(500), 500);
+    });
+    const loggerOptions = config.server.logger;
+    const { middlewares, renderMiddlewares } = options.serverConfig || {};
+    const plugins = [
+        ...nodeServer ? [
+            injectNodeSeverPlugin({
+                nodeServer
+            })
+        ] : [],
+        ...createDefaultPlugins({
+            cacheConfig,
+            staticGenerate: options.staticGenerate,
+            logger: false === loggerOptions ? false : optLogger || getLogger(loggerOptions)
+        }),
+        injectConfigMiddlewarePlugin(middlewares, renderMiddlewares),
+        ...options.plugins || [],
+        injectResourcePlugin(),
+        injectRscManifestPlugin(enableRsc),
+        serverStaticPlugin(),
+        faviconPlugin(),
+        renderPlugin()
+    ];
+    serverBase.addPlugins(plugins);
+}
+export { applyPlugins };

package/dist/esm-node/index.mjs

@@ -0,0 +1,27 @@
+import "node:module";
+import { createServerBase } from "@modern-js/server-core";
+import { createNodeServer, loadServerCliConfig, loadServerEnv, loadServerPlugins, loadServerRuntimeConfig } from "@modern-js/server-core/node";
+import { applyPlugins } from "./apply.mjs";
+const createProdServer = async (options)=>{
+    await loadServerEnv(options);
+    const serverBaseOptions = options;
+    const serverCliConfig = 'production' === process.env.NODE_ENV ? loadServerCliConfig(options.pwd, options.config) : options.config;
+    if (serverCliConfig) serverBaseOptions.config = serverCliConfig;
+    const serverRuntimeConfig = await loadServerRuntimeConfig(options.serverConfigPath);
+    if (serverRuntimeConfig) {
+        serverBaseOptions.serverConfig = serverRuntimeConfig;
+        serverBaseOptions.plugins = [
+            ...serverRuntimeConfig.plugins || [],
+            ...options.plugins || []
+        ];
+    }
+    const server = createServerBase(serverBaseOptions);
+    const nodeServer = await createNodeServer(server.handle.bind(server));
+    await applyPlugins(server, options, nodeServer);
+    await server.init();
+    return nodeServer;
+};
+const src = createProdServer;
+export { TelemetryCanaryOrchestrator, TelemetryRegistry, TelemetryStartupHealthError, createOtlpTelemetryExporter, createTelemetryAwareMetrics, createVictoriaMetricsTelemetryExporter, hasEnabledTelemetryExporters } from "./libs/telemetry.mjs";
+export default src;
+export { applyPlugins, createProdServer, loadServerPlugins };

package/dist/esm-node/libs/contractGateAutopilot.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { ContractGateAutopilot } from "@modern-js/server-core";

package/dist/esm-node/libs/loadConfig.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+import { compatibleRequire, fs, lodash } from "@modern-js/utils";
+import { parse } from "flatted";
+import path from "path";
+const getServerConfigPath = (distDirectory, serverConfigFile)=>{
+    const fileName = serverConfigFile || 'server.js';
+    return path.join(distDirectory, fileName);
+};
+const requireConfig = (serverConfigPath)=>{
+    if (fs.pathExistsSync(serverConfigPath)) return compatibleRequire(serverConfigPath) || {};
+    return {};
+};
+const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath })=>{
+    let outputConfig = {};
+    if (fs.pathExistsSync(resolvedConfigPath)) try {
+        const content = fs.readFileSync(resolvedConfigPath, 'utf8');
+        outputConfig = parse(content) || {};
+    } catch (_error) {
+        outputConfig = {};
+    }
+    return lodash.merge({}, outputConfig, serverConfig || {}, cliConfig || {});
+};
+export { getServerConfigPath, loadConfig, requireConfig };

package/dist/esm-node/libs/metrics.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+const noop = ()=>{};
+const metrics = {
+    emitCounter: noop,
+    emitTimer: noop,
+    gauges: noop
+};
+export { metrics };

package/dist/esm-node/libs/render/index.mjs

@@ -0,0 +1,82 @@
+import "node:module";
+import { cutNameByHyphen, mime } from "@modern-js/utils";
+import path from "path";
+import { ERROR_DIGEST } from "../../constants";
+import { shouldFlushServerHeader } from "../preload/shouldFlushServerHeader";
+import { readFile } from "./reader";
+import { handleDirectory } from "./static";
+import { injectServerData } from "./utils.mjs";
+import * as __rspack_external__ssr_mjs_81ad94dd from "./ssr.mjs";
+const calcFallback = (metaName)=>`x-${cutNameByHyphen(metaName)}-ssr-fallback`;
+const readUnsafeHeaders = (ssrConfig)=>{
+    if (!ssrConfig || 'object' != typeof ssrConfig) return;
+    const unsafeHeaders = ssrConfig.unsafeHeaders;
+    if (!Array.isArray(unsafeHeaders)) return;
+    return unsafeHeaders.filter((header)=>'string' == typeof header && header.trim().length > 0);
+};
+const resolveUnsafeHeaders = (conf, entryName)=>{
+    if (!entryName) return readUnsafeHeaders(conf.server?.ssr);
+    const entrySSRConfig = conf.server?.ssrByEntries?.[entryName];
+    return readUnsafeHeaders(entrySSRConfig) ?? readUnsafeHeaders(conf.server?.ssr);
+};
+const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, ssrRender, metaName = 'modern-js' })=>async function({ ctx, route, runner }) {
+        if (ctx.resHasHandled()) return null;
+        const { entryPath, urlPath } = route;
+        const unsafeHeaders = resolveUnsafeHeaders(conf, route.entryName);
+        const entry = path.join(distDir, entryPath);
+        if (!route.isSPA) {
+            const result = await handleDirectory(ctx, entry, urlPath);
+            return result;
+        }
+        const templatePath = entry;
+        const content = await readFile(templatePath);
+        if (!content) return null;
+        const useCSR = forceCSR && (ctx.query.csr || ctx.headers[calcFallback(metaName)]);
+        if (route.isSSR && !useCSR) try {
+            const userAgent = ctx.getReqHeader('User-Agent');
+            const disablePreload = Boolean(ctx.headers[`x-${cutNameByHyphen(metaName)}-disable-preload`]);
+            if (shouldFlushServerHeader(conf.server, userAgent, disablePreload)) {
+                const { flushServerHeader } = await import("../preload");
+                flushServerHeader({
+                    serverConf: conf.server,
+                    ctx,
+                    distDir,
+                    template: content.toString(),
+                    headers: {
+                        'Content-Type': mime.contentType(path.extname(templatePath))
+                    }
+                });
+            }
+            const ssrRenderOptions = {
+                distDir,
+                entryName: route.entryName,
+                urlPath: route.urlPath,
+                bundle: route.bundle,
+                template: content.toString(),
+                staticGenerate,
+                unsafeHeaders,
+                nonce
+            };
+            const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : __rspack_external__ssr_mjs_81ad94dd.render(ctx, {
+                distDir,
+                entryName: route.entryName,
+                urlPath: route.urlPath,
+                bundle: route.bundle,
+                template: content.toString(),
+                staticGenerate,
+                unsafeHeaders,
+                nonce
+            }, runner));
+            return result;
+        } catch (err) {
+            ctx.error(ERROR_DIGEST.ERENDER, err.stack || err.message);
+            ctx.res.set(calcFallback(metaName), '1');
+        }
+        return {
+            content: route.entryName ? injectServerData(content.toString(), ctx, {
+                unsafeHeaders
+            }) : content,
+            contentType: mime.contentType(path.extname(templatePath))
+        };
+    };
+export { createRenderHandler };