@bleedingdev/modern-js-runtime 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/esm-node/core/browser/hydrate.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-import { jsx } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { loadableReady } from "@loadable/component";
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 import { hydrateRoot } from "react-dom/client";
@@ -30,18 +30,23 @@ function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
     if ('stream' === renderMode) return streamSSRHydrate();
     function streamSSRHydrate() {
         if (renderLevel !== RenderLevel.SERVER_RENDER) return ModernRender(wrapRuntimeContextProvider(App, context));
-        {
+        else {
             const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
                     callback: callback,
                     children: App
                 });
-            return ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext));
+            return ModernHydrate(/*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext),
+                    null
+                ]
+            }));
         }
     }
     return stringSSRHydrate();
     function stringSSRHydrate() {
         if (renderLevel === RenderLevel.CLIENT_RENDER) return ModernRender(wrapRuntimeContextProvider(App, context));
-        {
+        else {
             if (renderLevel === RenderLevel.SERVER_RENDER) return loadableReady(()=>void 0, loadableReadyOptions).then(()=>{
                 const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
                         callback: callback,
@@ -49,13 +54,7 @@ function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
                     });
                 return ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext));
             });
-            const runtimeConsole = Reflect.get(globalThis, 'console');
-            if (null !== runtimeConsole && 'object' == typeof runtimeConsole) {
-                const warn = Reflect.get(runtimeConsole, 'warn');
-                if ('function' == typeof warn) Reflect.apply(warn, runtimeConsole, [
-                    `unknow render level: ${renderLevel}, execute render()`
-                ]);
-            }
+            console.warn(`unknow render level: ${renderLevel}, execute render()`);
             return ModernRender(wrapRuntimeContextProvider(App, context));
         }
     }

package/dist/esm-node/core/browser/index.mjs

@@ -1,8 +1,7 @@
 import "node:module";
+import { getGlobalInternalRuntimeContext, getInitialContext } from "@modern-js/runtime/context";
 import { parseCookie } from "cookie";
 import { createRoot } from "react-dom/client";
-import { getGlobalInternalRuntimeContext } from "../context/index.mjs";
-import { getInitialContext } from "../context/runtime.mjs";
 import { wrapRuntimeContextProvider } from "../react/wrapper.mjs";
 import { hydrateRoot, hydrateWithReact } from "./hydrate.mjs";
 const IS_REACT18 = 'true' === process.env.IS_REACT18;

package/dist/esm-node/core/context/index.mjs

@@ -42,10 +42,7 @@ function getGlobalBasename() {
     return globalContext.basename;
 }
 export { DefaultNotFound } from "../../router/runtime/DefaultNotFound.mjs";
-export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "../../router/runtime/hooks.mjs";
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
-export { createRouterProviderRealm, registerRouterProvider, resolveRouterProvider, routerProviderRegistryHooks } from "../../router/runtime/provider.mjs";
-export { createRuntimeContextExtension } from "./extensions.mjs";
-export { InternalRuntimeContext, RuntimeContext, getInitialContext } from "./runtime.mjs";
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, routerProviderRegistryHooks } from "../../router/runtime/hooks.mjs";
+export { InternalRuntimeContext, ReactRuntimeContext, RuntimeComponentResolverContext, RuntimeContext, getInitialContext, useRuntimeContext } from "./runtime.mjs";
 export { getServerPayload, setServerPayload } from "./serverPayload/index.mjs";
 export { getCurrentEntryName, getGlobalApp, getGlobalBasename, getGlobalEnableRsc, getGlobalInternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRSCRoot, getGlobalRoutes, setGlobalContext, setGlobalInternalRuntimeContext };

package/dist/esm-node/core/context/public.mjs

@@ -1,6 +1,2 @@
 import "node:module";
-import { createContext, useContext } from "react";
-const RuntimeContext = createContext({});
-const ReactRuntimeContext = RuntimeContext;
-const useRuntimeContext = ()=>useContext(RuntimeContext);
-export { ReactRuntimeContext, RuntimeContext, useRuntimeContext };
+export { ReactRuntimeContext, RuntimeContext, useRuntimeContext } from "@modern-js/runtime/context";

package/dist/esm-node/core/context/runtime.mjs

@@ -1,7 +1,11 @@
 import "node:module";
-import { createContext } from "react";
+import { createContext, useContext } from "react";
 const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
 const InternalRuntimeContext = createContext({});
+const RuntimeContext = createContext({});
+const RuntimeComponentResolverContext = createContext(void 0);
+const ReactRuntimeContext = RuntimeContext;
+const useRuntimeContext = ()=>useContext(RuntimeContext);
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
         request: {
@@ -25,5 +29,4 @@ const getInitialContext = (isBrowser = true, routeManifest)=>{
         context: requestContext
     };
 };
-export { ReactRuntimeContext, RuntimeContext, useRuntimeContext } from "./public.mjs";
-export { InternalRuntimeContext, getInitialContext };
+export { InternalRuntimeContext, ReactRuntimeContext, RuntimeComponentResolverContext, RuntimeContext, getInitialContext, useRuntimeContext };

package/dist/esm-node/core/index.mjs

@@ -1,3 +1,3 @@
 import "node:module";
+export { RuntimeContext, useRuntimeContext } from "@modern-js/runtime/context";
 export { defineRuntimeConfig } from "./config.mjs";
-export { RuntimeContext, useRuntimeContext } from "./context/runtime.mjs";

package/dist/esm-node/core/plugin/index.mjs

@@ -1,10 +1,10 @@
 import "node:module";
 import { runtime } from "@modern-js/plugin/runtime";
+import { setGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { compatPlugin } from "../compat/index.mjs";
 import { handleSetupResult } from "../compat/hooks.mjs";
 import { requestContextPlugin } from "../compat/requestContext.mjs";
-import { setGlobalInternalRuntimeContext } from "../context/index.mjs";
 function registerPlugin(internalPlugins, runtimeConfig) {
     const { plugins = [] } = runtimeConfig || {};
     const { runtimeContext } = runtime.run({

package/dist/esm-node/core/react/index.mjs

@@ -1,8 +1,8 @@
 import "node:module";
+import { getGlobalApp, getGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { parsedJSONFromElement } from "@modern-js/runtime-utils/parsed";
 import { isBrowser } from "../../common.mjs";
 import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../constants.mjs";
-import { getGlobalApp, getGlobalInternalRuntimeContext } from "../context/index.mjs";
 function createRoot(UserApp) {
     const App = UserApp || getGlobalApp();
     if (isBrowser()) {

package/dist/esm-node/core/react/wrapper.mjs

@@ -1,46 +1,14 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
-import { HelmetProvider } from "react-helmet-async";
-import { InternalRuntimeContext, RuntimeContext, getGlobalEnableRsc, getInitialContext } from "../context/index.mjs";
-import { stripRuntimeContextExtensions } from "../context/extensions.mjs";
-import { ensureHelmetContext } from "../context/helmetContext.mjs";
-function createRscSafeRequestContext(ssrContext) {
-    const requestContext = getInitialContext().requestContext;
-    Object.defineProperty(requestContext.response, 'setHeader', {
-        enumerable: false
+import { InternalRuntimeContext, RuntimeComponentResolverContext, RuntimeContext, getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
+function wrapRuntimeComponentResolver(root, hooks = getGlobalInternalRuntimeContext()?.hooks) {
+    return /*#__PURE__*/ jsx(RuntimeComponentResolverContext.Provider, {
+        value: hooks?.resolveComponent?.call,
+        children: root
     });
-    Object.defineProperty(requestContext.response, 'status', {
-        enumerable: false
-    });
-    if (void 0 === ssrContext) return requestContext;
-    const { request, response } = ssrContext;
-    return {
-        request: {
-            url: request.url,
-            userAgent: request.userAgent,
-            cookie: request.cookie,
-            pathname: request.pathname,
-            query: {
-                ...request.query
-            },
-            params: {
-                ...request.params
-            },
-            headers: {
-                ...request.headers
-            },
-            host: request.host,
-            referer: request.referer
-        },
-        response: Object.assign(requestContext.response, {
-            locals: response.locals ?? {}
-        })
-    };
 }
 function wrapRuntimeContextProvider(App, contextValue) {
     const { isBrowser, initialData, routes, context, routeManifest, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, ...rest } = contextValue;
-    const internalContextValue = contextValue;
-    const helmetContext = ensureHelmetContext(internalContextValue);
     const runtimeContextValue = {
         isBrowser,
         initialData,
@@ -48,37 +16,22 @@ function wrapRuntimeContextProvider(App, contextValue) {
         context,
         ...rest
     };
-    stripRuntimeContextExtensions(runtimeContextValue);
-    if (true === getGlobalEnableRsc() && false === isBrowser) {
-        const rscSafeRequestContext = createRscSafeRequestContext(ssrContext);
-        const rscInternalContextValue = {
-            ...internalContextValue,
-            context: rscSafeRequestContext,
-            requestContext: rscSafeRequestContext
-        };
-        delete rscInternalContextValue.ssrContext;
-        const rscRuntimeContextValue = {
-            ...runtimeContextValue,
-            context: rscSafeRequestContext,
-            requestContext: rscSafeRequestContext
-        };
-        return /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
-            value: rscInternalContextValue,
-            children: /*#__PURE__*/ jsx(RuntimeContext.Provider, {
-                value: rscRuntimeContextValue,
-                children: App
-            })
-        });
-    }
-    return /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
-        value: internalContextValue,
+    const isRsc = true === getGlobalEnableRsc();
+    const projection = {
+        internalContext: contextValue,
+        publicContext: runtimeContextValue
+    };
+    const values = getGlobalInternalRuntimeContext()?.hooks.transformRuntimeContext?.call(projection, {
+        context: contextValue,
+        isRsc
+    }) ?? projection;
+    const root = /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
+        value: values.internalContext,
         children: /*#__PURE__*/ jsx(RuntimeContext.Provider, {
-            value: runtimeContextValue,
-            children: /*#__PURE__*/ jsx(HelmetProvider, {
-                context: helmetContext,
-                children: App
-            })
+            value: values.publicContext,
+            children: App
         })
     });
+    return isRsc && false === isBrowser ? root : wrapRuntimeComponentResolver(root);
 }
-export { wrapRuntimeContextProvider };
+export { wrapRuntimeComponentResolver, wrapRuntimeContextProvider };

package/dist/esm-node/core/server/helmet.mjs

@@ -1,5 +1,4 @@
 import "node:module";
-import { getHelmetContext } from "../context/helmetContext.mjs";
 import { safeReplace } from "./utils.mjs";
 const EOL = '\n';
 const RE_HTML_ATTR = /<html[^>]*>/;
@@ -7,8 +6,10 @@ const RE_BODY_ATTR = /<body[^>]*>/;
 const RE_LAST_IN_HEAD = /<\/head>/;
 const RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
 const TEST_TITLE_CONTENT = /(?<=<title[^>]*>)([\s\S\n\r]*?)([.|\S])([\s\S\n\r]*?)(?=<\/title>)/;
-function getHelmetData(runtimeContext) {
-    return getHelmetContext(runtimeContext)?.helmet ?? void 0;
+function getHelmetData(providers) {
+    let result;
+    for (const provider of providers)result = provider.getHeadData?.() ?? result;
+    return result;
 }
 function createReplaceHelemt(helmetData) {
     return helmetData ? (template)=>helmetReplace(template, helmetData) : (tempalte)=>tempalte;
@@ -20,7 +21,7 @@ function helmetReplace(content, helmetData) {
     const htmlAttributes = helmetData.htmlAttributes.toString();
     if (htmlAttributes) result = safeReplace(result, RE_HTML_ATTR, `<html ${htmlAttributes}>`);
     const base = helmetData.base.toString();
-    const priority = helmetData.priority.toString();
+    const priority = helmetData.priority?.toString() ?? '';
     const link = helmetData.link.toString();
     const meta = helmetData.meta.toString();
     const noscript = helmetData.noscript.toString();

package/dist/esm-node/core/server/requestHandler.mjs

@@ -1,10 +1,9 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
+import { getGlobalInternalRuntimeContext, getGlobalRSCRoot, getInitialContext } from "@modern-js/runtime/context";
 import { storage } from "@modern-js/runtime-utils/node";
 import { getPathname, parseCookie, parseHeaders, parseQuery } from "@modern-js/runtime-utils/universal/request";
 import react, { Fragment } from "react";
-import { getGlobalInternalRuntimeContext, getGlobalRSCRoot } from "../context/index.mjs";
-import { getInitialContext } from "../context/runtime.mjs";
 import { getServerPayload } from "../context/serverPayload/index.mjs";
 import { createRoot } from "../react/index.mjs";
 import { CHUNK_CSS_PLACEHOLDER } from "./constants.mjs";

package/dist/esm-node/core/server/requestResponse.mjs

@@ -1,12 +1,12 @@
 import "node:module";
-import { getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
+import { getRouterServerSnapshot } from "@modern-js/runtime-extensions/router-state";
 import { handleRSCRedirect } from "../../router/runtime/redirect.mjs";
 import { SSRErrors } from "./tracer.mjs";
 const isRedirectStatus = (status)=>301 === status || 302 === status || 303 === status || 307 === status || 308 === status;
 const isNullBodyStatus = (status)=>204 === status || 205 === status || 304 === status;
 const getRedirectLocation = (headers)=>{
     const location = headers.get('Location');
-    return location && URL.canParse(location, 'http://localhost') ? location : void 0;
+    return null !== location && '' !== location && URL.canParse(location, 'http://localhost') ? location : void 0;
 };
 const processRedirect = (headers, status, ctx)=>{
     headers.delete('content-length');
@@ -28,7 +28,7 @@ const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
     if (void 0 === beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
     if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
     const redirectUrl = getRedirectLocation(beforeRenderResult.headers);
-    if (!redirectUrl) return;
+    if (void 0 === redirectUrl) return;
     return processRedirect(new Headers(beforeRenderResult.headers), beforeRenderResult.status, redirectCtx);
 };
 const finalizeRenderResponse = async (response, responseProxy, redirectCtx, routerCleanup)=>{

package/dist/esm-node/core/server/routerCleanup.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-import { getRouterRuntimeState } from "../../router/runtime/lifecycle.mjs";
+import { getRouterRuntimeState } from "@modern-js/runtime-extensions/router-state";
 const ROUTER_CLEANUP_ERROR = 'An error occurs during router runtime cleanup';
 async function runWithRouterCleanupOnError(routerCleanup, callback) {
     try {

package/dist/esm-node/core/server/shared.mjs

@@ -1,5 +1,157 @@
 import "node:module";
+import { attributesToString, hasStylesheetLink, safeReplace } from "./utils.mjs";
 function buildHtml(template, callbacks) {
     return callbacks.reduce((promise, buildHtmlCb)=>promise.then((template)=>buildHtmlCb(template)), Promise.resolve(template));
 }
-export { buildHtml };
+function createSSRRenderLifecycle(observers) {
+    let terminal;
+    return {
+        transformAssets (groups, info) {
+            let assets = groups.flatMap((group)=>group.assets);
+            for (const observer of observers)assets = observer.transformAssets?.(assets, {
+                ...info,
+                groups
+            }) ?? assets;
+            return assets;
+        },
+        transformTemplateChunk (chunk) {
+            for (const observer of observers)chunk = observer.transformTemplateChunk?.(chunk, {
+                attributesToString: attributesToString,
+                hasStylesheetLink: hasStylesheetLink
+            }) ?? chunk;
+            return chunk;
+        },
+        getRouterData () {
+            let data;
+            for (const observer of observers)data = observer.getRouterData?.() ?? data;
+            return data;
+        },
+        get terminal () {
+            return terminal;
+        },
+        beforeReact () {
+            for (const observer of observers)observer.beforeReact?.();
+        },
+        completedBody (html, phase) {
+            for (const observer of observers)html = observer.completedBody?.(html, {
+                phase
+            }) ?? html;
+            return html;
+        },
+        finish (result) {
+            if (void 0 !== terminal) return;
+            terminal = result;
+            for (const observer of observers)try {
+                observer.onTerminal?.(result);
+            } catch  {}
+        }
+    };
+}
+function replaceSSRTemplateChunk(chunk, lifecycle, options = {}) {
+    const result = lifecycle?.transformTemplateChunk(chunk) ?? chunk;
+    if (true === options.preserveEmpty && '' === result.content) return result.template;
+    return safeReplace(result.template, result.placeholder, result.content);
+}
+function orderSSRStreamTransforms(extenders) {
+    return [
+        ...extenders.filter((extender)=>'body' !== extender.streamPhase),
+        ...extenders.filter((extender)=>'body' === extender.streamPhase)
+    ];
+}
+function createSSRStreamErrorReporter(onError) {
+    let reported = false;
+    return (error)=>{
+        if (reported) return;
+        reported = true;
+        try {
+            onError(error);
+        } catch  {}
+    };
+}
+function observeSSRStream(source, options) {
+    const reader = source.getReader();
+    let controller;
+    let ended = false;
+    let cancellation;
+    const cleanup = ()=>{
+        options.signal.removeEventListener('abort', onAbort);
+        reader.releaseLock();
+    };
+    const cancel = (reason)=>{
+        if (void 0 !== cancellation) return cancellation;
+        if (ended) return Promise.resolve();
+        ended = true;
+        options.lifecycle.finish({
+            status: 'cancelled',
+            reason
+        });
+        cancellation = (async ()=>{
+            try {
+                const observer = Promise.withResolvers();
+                try {
+                    observer.resolve(options.onCancel?.(reason));
+                } catch (error) {
+                    observer.reject(error);
+                }
+                const results = await Promise.allSettled([
+                    observer.promise,
+                    reader.cancel(reason)
+                ]);
+                const rejected = results.find((result)=>'rejected' === result.status);
+                if (rejected?.status === 'rejected') throw rejected.reason;
+            } finally{
+                cleanup();
+            }
+        })();
+        return cancellation;
+    };
+    const onAbort = ()=>{
+        if (ended) return;
+        const reason = options.signal.reason;
+        cancel(reason).then(()=>controller.error(reason), (error)=>{
+            controller.error(reason);
+            return options.onError(error);
+        });
+    };
+    return new ReadableStream({
+        start (value) {
+            controller = value;
+            options.signal.addEventListener('abort', onAbort, {
+                once: true
+            });
+            if (options.signal.aborted) onAbort();
+        },
+        async pull (value) {
+            if (ended) return void await cancellation;
+            try {
+                const result = await reader.read();
+                if (ended) return void await cancellation;
+                if (result.done) {
+                    await options.onComplete?.();
+                    if (ended) return void await cancellation;
+                    ended = true;
+                    options.lifecycle.finish({
+                        status: 'complete'
+                    });
+                    cleanup();
+                    value.close();
+                } else value.enqueue(result.value);
+            } catch (error) {
+                if (ended) return void await cancellation;
+                ended = true;
+                options.lifecycle.finish({
+                    status: 'error',
+                    error
+                });
+                try {
+                    await options.onError(error);
+                } finally{
+                    cleanup();
+                    value.error(error);
+                }
+            }
+        },
+        cancel
+    });
+}
+export { buildHtml, createSSRRenderLifecycle, createSSRStreamErrorReporter, observeSSRStream, orderSSRStreamTransforms, replaceSSRTemplateChunk };

package/dist/esm-node/core/server/stream/afterTemplate.mjs

@@ -1,13 +1,11 @@
 import "node:module";
 import { serializeJson } from "@modern-js/runtime-utils/node";
-import { getRouterHydrationScripts } from "../../../router/runtime/lifecycle.mjs";
 import { SSR_DATA_JSON_ID } from "../../constants.mjs";
-import { SSR_DATA_PLACEHOLDER } from "../constants.mjs";
-import { createRouteHydrationScriptTags, replaceChunkJsPlaceholder } from "../scriptOrder.mjs";
-import { buildHtml } from "../shared.mjs";
+import { CHUNK_JS_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants.mjs";
+import { buildHtml, replaceSSRTemplateChunk } from "../shared.mjs";
 import { attributesToString } from "../utils.mjs";
 function buildShellAfterTemplate(afterAppTemplate, options) {
-    const { request, config, ssrConfig, runtimeContext, renderLevel, entryName } = options;
+    const { request, config, ssrConfig, runtimeContext, renderLevel, entryName, lifecycle } = options;
     const callbacks = [
         (template)=>injectJs(template, entryName, config.nonce),
         createReplaceSSRData({
@@ -17,21 +15,28 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
             useJsonScript: config.useJsonScript,
             runtimeContext,
             renderLevel,
-            entryName
+            lifecycle
         })
     ];
     async function injectJs(template, entryName, nonce) {
-        const jsChunkStr = createRouteHydrationScriptTags(runtimeContext, entryName, {
-            nonce,
-            template
+        const assets = runtimeContext.routeManifest?.routeAssets?.[`async-${entryName}`]?.assets ?? [];
+        const jsChunkStr = assets.filter((asset)=>asset.endsWith('.js')).map((asset)=>`<script${attributesToString({
+                src: asset,
+                nonce
+            })}></script>`).join(' ');
+        return replaceSSRTemplateChunk({
+            name: "scripts",
+            template,
+            placeholder: CHUNK_JS_PLACEHOLDER,
+            content: jsChunkStr
+        }, lifecycle, {
+            preserveEmpty: true
         });
-        if (!jsChunkStr) return template;
-        return replaceChunkJsPlaceholder(template, jsChunkStr, entryName);
     }
     return buildHtml(afterAppTemplate, callbacks);
 }
 function createReplaceSSRData(options) {
-    const { runtimeContext, nonce, renderLevel, useJsonScript, ssrConfig, entryName } = options;
+    const { runtimeContext, nonce, renderLevel, useJsonScript, ssrConfig, lifecycle } = options;
     const { request, reporter } = runtimeContext.ssrContext;
     const headers = 'object' == typeof ssrConfig && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _])=>ssrConfig.unsafeHeaders?.map((header)=>header.toLowerCase())?.includes(key.toLowerCase()))) : void 0;
     const ssrData = {
@@ -60,11 +65,11 @@ function createReplaceSSRData(options) {
     });
     const serializeSSRData = serializeJson(ssrData);
     const ssrDataScript = useJsonScript ? `<script type="application/json" id="${SSR_DATA_JSON_ID}">${serializeSSRData}</script>` : `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>`;
-    const hydrationScripts = getRouterHydrationScripts(runtimeContext);
-    const ssrScripts = hydrationScripts.length ? `${ssrDataScript}\n${hydrationScripts.join('\n')}` : ssrDataScript;
-    return (template)=>{
-        if (!template.includes(SSR_DATA_PLACEHOLDER)) return template;
-        return replaceChunkJsPlaceholder(template, ssrScripts, entryName, SSR_DATA_PLACEHOLDER);
-    };
+    return (template)=>replaceSSRTemplateChunk({
+            name: 'data',
+            template,
+            placeholder: SSR_DATA_PLACEHOLDER,
+            content: ssrDataScript
+        }, lifecycle);
 }
 export { buildShellAfterTemplate };