@modern-js/server-core 2.69.5 → 3.0.0-alpha.0

package/dist/esm/plugins/log.mjs

@@ -0,0 +1,58 @@
+import { getPathname } from "../utils";
+const humanize = (times)=>{
+    const [delimiter, separator] = [
+        ',',
+        '.'
+    ];
+    const orderTimes = times.map((v)=>v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, `$1${delimiter}`));
+    return orderTimes.join(separator);
+};
+const time = (start)=>{
+    const delta = Date.now() - start;
+    return humanize([
+        delta < 1000 ? `${delta}ms` : `${Math.round(delta / 1000)}s`
+    ]);
+};
+const colorStatus = (status)=>{
+    const out = {
+        7: `\x1b[35m${status}\x1b[0m`,
+        5: `\x1b[31m${status}\x1b[0m`,
+        4: `\x1b[33m${status}\x1b[0m`,
+        3: `\x1b[36m${status}\x1b[0m`,
+        2: `\x1b[32m${status}\x1b[0m`,
+        1: `\x1b[32m${status}\x1b[0m`,
+        0: `\x1b[33m${status}\x1b[0m`
+    };
+    const calculateStatus = Math.floor(status / 100);
+    return out[calculateStatus];
+};
+function log(fn, prefix, method, path, status = 0, elapsed) {
+    const out = "<--" === prefix ? `  ${prefix} ${method} ${path}` : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
+    fn(out);
+}
+function logHandler() {
+    return async function(c, next) {
+        const { method } = c.req;
+        const monitors = c.get('monitors');
+        if (!monitors) return void await next();
+        const path = getPathname(c.req.raw);
+        const logFn = monitors.debug;
+        log(logFn, "<--", method, path);
+        const start = Date.now();
+        await next();
+        log(logFn, "-->", method, path, c?.env?.node?.res?.statusCode ?? c.res.status, time(start));
+    };
+}
+const logPlugin = ()=>({
+        name: '@modern-js/plugin-log',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'print_log',
+                    handler: logHandler()
+                });
+            });
+        }
+    });
+export { logPlugin };

package/dist/esm/plugins/middlewares.mjs

@@ -0,0 +1,15 @@
+const injectConfigMiddlewarePlugin = (configMiddlewares = [], configRenderMiddlewares = [])=>({
+        name: '@modern-js/plugin-inject-config-middleware',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, renderMiddlewares } = api.getServerContext();
+                configMiddlewares.forEach((m)=>{
+                    middlewares.push(m);
+                });
+                configRenderMiddlewares.forEach((m)=>{
+                    renderMiddlewares.push(m);
+                });
+            });
+        }
+    });
+export { injectConfigMiddlewarePlugin };

package/dist/esm/plugins/monitors.mjs

@@ -0,0 +1,149 @@
+import { time } from "@modern-js/runtime-utils/time";
+import { SERVER_TIMING, ServerTimings } from "../constants";
+function createMonitors() {
+    const coreMonitors = [];
+    const log = (level, message, args)=>{
+        const event = {
+            type: 'log',
+            payload: {
+                level,
+                message,
+                args
+            }
+        };
+        coreMonitors.forEach((monitor)=>monitor(event));
+    };
+    const mointors = {
+        push (monitor) {
+            coreMonitors.push(monitor);
+        },
+        error (message, ...args) {
+            log('error', message, args);
+        },
+        warn (message, ...args) {
+            log('warn', message, args);
+        },
+        debug (message, ...args) {
+            log('debug', message, args);
+        },
+        info (message, ...args) {
+            log('info', message, args);
+        },
+        trace (message, ...args) {
+            log('trace', message, args);
+        },
+        timing (name, dur, desc, tags, ...args) {
+            const event = {
+                type: 'timing',
+                payload: {
+                    name,
+                    dur,
+                    desc,
+                    tags,
+                    args
+                }
+            };
+            coreMonitors.forEach((monitor)=>monitor(event));
+        },
+        counter (name, tags, ...args) {
+            const event = {
+                type: 'counter',
+                payload: {
+                    name,
+                    args,
+                    tags
+                }
+            };
+            coreMonitors.forEach((monitor)=>monitor(event));
+        }
+    };
+    return mointors;
+}
+const initMonitorsPlugin = ()=>({
+        name: '@modern-js/init-mointor',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'init-monitor',
+                    handler: async (c, next)=>{
+                        if (!c.get('monitors')) {
+                            const monitors = createMonitors();
+                            c.set('monitors', monitors);
+                        }
+                        return next();
+                    },
+                    order: 'pre'
+                });
+            });
+        }
+    });
+const injectloggerPlugin = (inputLogger)=>({
+        name: '@modern-js/inject-logger',
+        setup (api) {
+            const logger = inputLogger;
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'inject-logger',
+                    handler: async (c, next)=>{
+                        const pathname = c.req.path;
+                        const loggerMonitor = (event)=>{
+                            if ('log' === event.type) {
+                                const { level, message, args } = event.payload;
+                                if ('trace' === level) logger.info(message, ...args || []);
+                                else logger[level](message, ...args || []);
+                            }
+                            if ('timing' === event.type) {
+                                const { name, dur, desc } = event.payload;
+                                if (desc) logger.debug(`%s Debug - ${name}, cost: %s, req.url = %s `, desc, dur, pathname);
+                                else logger.debug(`Debug - ${name}, cost: %s, req.url = %s`, dur, pathname);
+                            }
+                        };
+                        const monitors = c.get('monitors');
+                        monitors?.push(loggerMonitor);
+                        return next();
+                    }
+                });
+            });
+        }
+    });
+const injectServerTiming = ()=>({
+        name: '@modern-js/inject-server-timing',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, metaName } = api.getServerContext();
+                middlewares.push({
+                    name: 'inject-server-timing',
+                    handler: async (c, next)=>{
+                        const serverTimings = [];
+                        const timingMonitor = (event)=>{
+                            if ('timing' === event.type) serverTimings.push(event.payload);
+                        };
+                        const monitors = c.get('monitors');
+                        monitors?.push(timingMonitor);
+                        await next();
+                        serverTimings.forEach((serverTiming)=>{
+                            const { name, desc, dur } = serverTiming;
+                            const _name = `bd-${metaName}-${name}`;
+                            const value = `${_name};${desc ? `decs="${desc}";` : ''} dur=${dur}`;
+                            c.header(SERVER_TIMING, value, {
+                                append: true
+                            });
+                        });
+                    }
+                });
+            });
+        }
+    });
+function requestLatencyMiddleware() {
+    return async (c, next)=>{
+        const monitors = c.get('monitors');
+        if (!monitors) return void await next();
+        const getCost = time();
+        await next();
+        const cost = getCost();
+        monitors.timing(ServerTimings.SERVER_HANDLE_REQUEST, cost);
+    };
+}
+export { initMonitorsPlugin, injectServerTiming, injectloggerPlugin, requestLatencyMiddleware };

package/dist/esm/plugins/processedBy.mjs

@@ -0,0 +1,16 @@
+const processedByPlugin = ()=>({
+        name: '@modern-js/plugin-processed',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'processed-by',
+                    handler: async (c, next)=>{
+                        await next();
+                        c.header('X-Processed-By', 'Modern.js');
+                    }
+                });
+            });
+        }
+    });
+export { processedByPlugin };

package/dist/esm/plugins/render/csrRscRender.mjs

@@ -0,0 +1,43 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { createRequestHandlerConfig } from "./utils";
+const csrRscRender = async (req, options)=>{
+    const { routeInfo, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, monitors, onError, onTiming, staticGenerate, html } = options;
+    const serverBundle = serverManifest?.renderBundles?.[routeInfo.entryName || MAIN_ENTRY_NAME];
+    const loadableStats = serverManifest.loadableStats || {};
+    const routeManifest = serverManifest.routeManifest || {};
+    const config = createRequestHandlerConfig(options.config);
+    const requestHandlerOptions = {
+        resource: {
+            route: routeInfo,
+            loadableStats,
+            routeManifest,
+            entryName: routeInfo.entryName || MAIN_ENTRY_NAME
+        },
+        config,
+        params,
+        loaderContext,
+        html,
+        rscSSRManifest,
+        rscClientManifest,
+        rscServerManifest,
+        locals,
+        staticGenerate,
+        monitors,
+        onError,
+        onTiming,
+        reporter: reporter
+    };
+    if (!serverBundle) return new Response('Cannot find server bundle for RSC', {
+        status: 500
+    });
+    const renderRscStreamHandler = await serverBundle.renderRscStreamHandler;
+    if (!renderRscStreamHandler) return new Response('Cannot find render handler for RSC', {
+        status: 500
+    });
+    if (!rscClientManifest) return new Response('Cannot find rsc client manifest', {
+        status: 500
+    });
+    const response = await renderRscStreamHandler(req, requestHandlerOptions);
+    return response;
+};
+export { csrRscRender };

package/dist/esm/plugins/render/dataHandler.mjs

@@ -0,0 +1,19 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+const dataHandler = async (request, { routeInfo, serverRoutes, monitors, onError, onTiming, serverManifest, loaderContext })=>{
+    const serverLoaderModule = serverManifest?.loaderBundles?.[routeInfo.entryName || MAIN_ENTRY_NAME];
+    if (!serverLoaderModule) return;
+    const { routes, handleRequest } = serverLoaderModule;
+    const response = await handleRequest({
+        request,
+        serverRoutes,
+        context: {
+            monitors,
+            loaderContext
+        },
+        onTiming,
+        onError,
+        routes
+    });
+    return response;
+};
+export { dataHandler };

package/dist/esm/plugins/render/index.mjs

@@ -0,0 +1,84 @@
+import { getLoaderCtx } from "../../helper";
+import { sortRoutes } from "../../utils";
+import { requestLatencyMiddleware } from "../monitors";
+export * from "./inject";
+const DYNAMIC_ROUTE_REG = /\/:./;
+function escapeRegexSpecialChars(path) {
+    return path.replace(/[()[\]{}*+?.^$|\\]/g, '\\$&');
+}
+const renderPlugin = ()=>({
+        name: '@modern-js/plugin-render',
+        setup (api) {
+            api.onPrepare(async ()=>{
+                const { middlewares, routes, render, renderMiddlewares } = api.getServerContext();
+                if (!routes) return;
+                const pageRoutes = getPageRoutes(routes);
+                middlewares.push({
+                    name: 'page-latency',
+                    handler: requestLatencyMiddleware()
+                });
+                for (const route of pageRoutes){
+                    const { urlPath: originUrlPath } = route;
+                    const isDynamic = DYNAMIC_ROUTE_REG.test(originUrlPath);
+                    const escapedPath = isDynamic ? originUrlPath : escapeRegexSpecialChars(originUrlPath);
+                    const urlPath = escapedPath.endsWith('/') ? `${escapedPath}*` : `${escapedPath}/*`;
+                    renderMiddlewares?.forEach((m)=>{
+                        middlewares.push({
+                            name: m.name,
+                            path: urlPath,
+                            handler: m.handler
+                        });
+                    });
+                    render && middlewares.push({
+                        name: "render",
+                        path: urlPath,
+                        handler: createRenderHandler(render)
+                    });
+                }
+            });
+        }
+    });
+function getPageRoutes(routes) {
+    return routes.filter((route)=>!route.isApi).sort(sortRoutes);
+}
+function createRenderHandler(render) {
+    return async (c, _)=>{
+        const reporter = c.get('reporter');
+        const monitors = c.get('monitors');
+        const templates = c.get('templates') || {};
+        const serverManifest = c.get('serverManifest') || {};
+        const rscServerManifest = c.get('rscServerManifest');
+        const rscClientManifest = c.get('rscClientManifest');
+        const rscSSRManifest = c.get('rscSSRManifest');
+        const locals = c.get('locals');
+        c.get('metrics');
+        const matchPathname = c.get('matchPathname');
+        const matchEntryName = c.get('matchEntryName');
+        const loaderContext = getLoaderCtx(c);
+        const contextForceCSR = c.get('forceCSR');
+        const request = c.req.raw;
+        const nodeReq = c.env.node?.req;
+        const res = await render(request, {
+            nodeReq,
+            monitors,
+            templates,
+            serverManifest,
+            rscServerManifest,
+            rscClientManifest,
+            rscSSRManifest,
+            loaderContext,
+            locals,
+            matchPathname,
+            matchEntryName,
+            contextForceCSR,
+            reporter
+        });
+        const { body, status, headers } = res;
+        const headersData = {};
+        headers.forEach((v, k)=>{
+            headersData[k] = v;
+        });
+        return c.body(body, status, headersData);
+    };
+}
+export { renderPlugin };

package/dist/esm/plugins/render/inject.mjs

@@ -0,0 +1,55 @@
+import { createRender } from "./render";
+const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig })=>({
+        name: '@modern-js/plugin-inject-render',
+        setup (api) {
+            api.onPrepare(async ()=>{
+                const { distDirectory: pwd, routes, metaName } = api.getServerContext();
+                const config = api.getServerConfig();
+                const hooks = api.getHooks();
+                if (!routes) return;
+                const onFallback = async (reason, error)=>{
+                    await hooks.fallback.call({
+                        reason,
+                        error
+                    });
+                };
+                const getRenderHandlerOptions = {
+                    pwd: pwd,
+                    routes,
+                    config,
+                    metaName,
+                    cacheConfig: cacheConfig,
+                    staticGenerate,
+                    onFallback
+                };
+                const render = await getRenderHandler(getRenderHandlerOptions);
+                api.updateServerContext({
+                    render,
+                    getRenderOptions: getRenderHandlerOptions
+                });
+            });
+        }
+    });
+async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, onFallback }) {
+    const ssrConfig = config.server?.ssr;
+    const ssrByEntries = config.server?.ssrByEntries;
+    const forceCSR = 'object' == typeof ssrConfig ? ssrConfig.forceCSR : false;
+    const forceCSRMap = new Map();
+    if (ssrByEntries) Object.entries(ssrByEntries).forEach(([entryName, ssrConfig])=>{
+        forceCSRMap.set(entryName, 'object' == typeof ssrConfig ? ssrConfig.forceCSR ?? false : false);
+    });
+    const render = createRender({
+        routes,
+        pwd,
+        config,
+        staticGenerate,
+        cacheConfig,
+        forceCSR,
+        forceCSRMap,
+        nonce: config.security?.nonce,
+        metaName: metaName || 'modern-js',
+        onFallback
+    });
+    return render;
+}
+export { getRenderHandler, injectRenderHandlerPlugin };

package/dist/esm/plugins/render/render.mjs

@@ -0,0 +1,226 @@
+import * as __rspack_external__modern_js_runtime_utils_router_2aa8d96f from "@modern-js/runtime-utils/router";
+import { cutNameByHyphen } from "@modern-js/utils/universal";
+import { TrieRouter } from "hono/router/trie-router";
+import { X_MODERNJS_RENDER } from "../../constants";
+import { ErrorDigest, createErrorHtml, getPathname, getRuntimeEnv, parseHeaders, parseQuery, sortRoutes, uniqueKeyByRoute } from "../../utils";
+import { csrRscRender } from "./csrRscRender";
+import { dataHandler } from "./dataHandler";
+import { renderRscHandler } from "./renderRscHandler";
+import { serverActionHandler } from "./serverActionHandler";
+import { ssrRender } from "./ssrRender";
+var __webpack_modules__ = {
+    "@modern-js/runtime-utils/router" (module) {
+        module.exports = __rspack_external__modern_js_runtime_utils_router_2aa8d96f;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const DYNAMIC_ROUTE_REG = /\/:./;
+function getRouter(routes) {
+    const dynamicRoutes = [];
+    const normalRoutes = [];
+    routes.forEach((route)=>{
+        if (DYNAMIC_ROUTE_REG.test(route.urlPath)) dynamicRoutes.push(route);
+        else normalRoutes.push(route);
+    });
+    const finalRoutes = [
+        ...normalRoutes.sort(sortRoutes),
+        ...dynamicRoutes.sort(sortRoutes)
+    ];
+    const router = new TrieRouter();
+    for (const route of finalRoutes){
+        const { urlPath: originUrlPath } = route;
+        const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
+        router.add('*', urlPath, route);
+    }
+    return router;
+}
+function matchRoute(router, pathname, entryName) {
+    const matched = router.match('*', pathname);
+    if (entryName && matched[0].length > 1) {
+        const matches = matched[0];
+        const result = matches.find(([route])=>route.entryName === entryName);
+        return result || [];
+    }
+    {
+        const result = matched[0][0];
+        return result || [];
+    }
+}
+function getHeadersWithoutCookie(headers) {
+    const _headers = {
+        ...headers,
+        cookie: void 0
+    };
+    delete _headers.cookie;
+    return _headers;
+}
+async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, onFallback }) {
+    const router = getRouter(routes);
+    return async (req, { monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext, contextForceCSR, reporter })=>{
+        const forMatchpathname = matchPathname ?? getPathname(req);
+        const [routeInfo, params] = matchRoute(router, forMatchpathname, matchEntryName);
+        const framework = cutNameByHyphen(metaName || 'modern-js');
+        const fallbackHeader = `x-${framework}-ssr-fallback`;
+        let fallbackReason = null;
+        const fallbackWrapper = async (reason, error)=>{
+            fallbackReason = reason;
+            return onFallback?.(reason, error);
+        };
+        if (!routeInfo) return new Response(createErrorHtml(404), {
+            status: 404,
+            headers: {
+                'content-type': 'text/html; charset=UTF-8'
+            }
+        });
+        const html = templates[uniqueKeyByRoute(routeInfo)];
+        if (!html) return new Response(createErrorHtml(404), {
+            status: 404,
+            headers: {
+                'content-type': 'text/html; charset=UTF-8'
+            }
+        });
+        const finalForceCSR = routeInfo.entryName ? forceCSRMap?.get(routeInfo.entryName) ?? forceCSR : forceCSR;
+        const renderMode = await getRenderMode(req, fallbackHeader, routeInfo.isSSR, finalForceCSR, nodeReq, fallbackWrapper, contextForceCSR);
+        const headerData = parseHeaders(req);
+        const onError = (e, key)=>{
+            monitors?.error(`SSR Error - ${key || (e instanceof Error ? e.name : e)}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
+        };
+        const onTiming = (name, dur)=>{
+            monitors?.timing(name, dur, 'SSR');
+        };
+        const renderOptions = {
+            pwd,
+            html,
+            routeInfo,
+            staticGenerate: staticGenerate || false,
+            config,
+            nodeReq,
+            cacheConfig,
+            serverRoutes: routes,
+            params,
+            monitors,
+            locals,
+            rscClientManifest,
+            rscSSRManifest,
+            rscServerManifest,
+            serverManifest,
+            loaderContext: loaderContext || new Map(),
+            onError,
+            onTiming,
+            reporter
+        };
+        if (fallbackReason) renderOptions.html = injectFallbackReasonToHtml({
+            html: renderOptions.html,
+            reason: fallbackReason,
+            framework
+        });
+        let response;
+        switch(renderMode){
+            case 'data':
+                response = await dataHandler(req, renderOptions) || await renderHandler(req, renderOptions, 'ssr', fallbackWrapper, framework);
+                break;
+            case 'rsc-tree':
+                response = await renderRscHandler(req, renderOptions);
+                break;
+            case 'rsc-action':
+                response = await serverActionHandler(req, renderOptions);
+                break;
+            case 'ssr':
+            case 'csr':
+                response = await renderHandler(req, renderOptions, renderMode, fallbackWrapper, framework);
+                break;
+            default:
+                throw new Error(`Unknown render mode: ${renderMode}`);
+        }
+        if (fallbackReason) response.headers.set(fallbackHeader, `1;reason=${fallbackReason}`);
+        return response;
+    };
+}
+async function renderHandler(request, options, mode, fallbackWrapper, framework) {
+    let response = null;
+    const { serverManifest } = options;
+    const ssrByRouteIds = options.config.server?.ssrByRouteIds;
+    const runtimeEnv = getRuntimeEnv();
+    if (serverManifest.nestedRoutesJson && ssrByRouteIds && ssrByRouteIds?.length > 0 && 'node' === runtimeEnv) {
+        const { nestedRoutesJson } = serverManifest;
+        const routes = nestedRoutesJson?.[options.routeInfo.entryName];
+        if (routes) {
+            const { matchRoutes } = __webpack_require__("@modern-js/runtime-utils/router");
+            const url = new URL(request.url);
+            const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
+            if (matchedRoutes) {
+                const lastMatch = matchedRoutes[matchedRoutes.length - 1];
+                if (!lastMatch?.route?.id || !ssrByRouteIds.includes(lastMatch.route.id)) response = await csrRender(request, options);
+            } else response = await csrRender(request, options);
+        }
+    }
+    if ('ssr' !== mode || response) response = await csrRender(request, options);
+    else try {
+        response = await ssrRender(request, options);
+    } catch (e) {
+        options.onError(e, ErrorDigest.ERENDER);
+        await fallbackWrapper('error', e);
+        response = await csrRender(request, {
+            ...options,
+            html: injectFallbackReasonToHtml({
+                html: options.html,
+                reason: 'error',
+                framework
+            })
+        });
+    }
+    const { routeInfo } = options;
+    applyExtendHeaders(response, routeInfo);
+    return response;
+    function applyExtendHeaders(r, route) {
+        Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
+            r.headers.set(k, v);
+        });
+    }
+}
+async function getRenderMode(req, fallbackHeader, isSSR, forceCSR, nodeReq, onFallback, contextForceCSR) {
+    const query = parseQuery(req);
+    if (req.headers.get('x-rsc-action')) return 'rsc-action';
+    if (req.headers.get('x-rsc-tree')) return 'rsc-tree';
+    if (!isSSR) return 'csr';
+    {
+        if (query.__loader) return 'data';
+        const fallbackHeaderValue = req.headers.get(fallbackHeader) || nodeReq?.headers[fallbackHeader];
+        if (forceCSR && (query.csr || fallbackHeaderValue || contextForceCSR)) {
+            if (query.csr) await onFallback?.('query');
+            else {
+                const reason = fallbackHeaderValue?.split(';')[1]?.split('=')[1];
+                await onFallback?.(reason ? `header,${reason}` : 'header');
+            }
+            return 'csr';
+        }
+        return 'ssr';
+    }
+}
+function injectFallbackReasonToHtml({ html, reason, framework }) {
+    const tag = `<script id="__${framework}_ssr_fallback_reason__" type="application/json">${JSON.stringify({
+        reason
+    })}</script>`;
+    return html.replace(/<\/head>/, `${tag}</head>`);
+}
+async function csrRender(request, options) {
+    const { html, rscClientManifest } = options;
+    if (!rscClientManifest || process.env.MODERN_DISABLE_INJECT_RSC_DATA) return new Response(html, {
+        status: 200,
+        headers: new Headers({
+            'content-type': 'text/html; charset=UTF-8',
+            [X_MODERNJS_RENDER]: 'client'
+        })
+    });
+    return csrRscRender(request, options);
+}
+export { createRender };