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

package/dist/cjs/core/server/stream/createReadableStream.worker.js

@@ -1,5 +1,14 @@
 "use strict";
 var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
         var define = (defs, kind)=>{
@@ -31,123 +40,195 @@ __webpack_require__.d(__webpack_exports__, {
     createReadableStreamFromElement: ()=>createReadableStreamFromElement
 });
 const ssr_namespaceObject = require("@modern-js/render/ssr");
-const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
 const external_common_js_namespaceObject = require("../../../common.js");
 const external_constants_js_namespaceObject = require("../../constants.js");
+const index_js_namespaceObject = require("../../context/monitors/index.js");
+const wrapper_js_namespaceObject = require("../../react/wrapper.js");
 const external_helmet_js_namespaceObject = require("../helmet.js");
+const external_shared_js_namespaceObject = require("../shared.js");
 const external_deferredScript_js_namespaceObject = require("./deferredScript.js");
-const external_shared_js_namespaceObject = require("./shared.js");
+const external_shared_js_namespaceObject_1 = require("./shared.js");
 const external_template_js_namespaceObject = require("./template.js");
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
-    let shellChunkStatus = external_shared_js_namespaceObject.ShellChunkStatus.START;
-    const chunkVec = [];
-    const { htmlTemplate, runtimeContext, config, ssrConfig, entryName, moduleFederationCssAssets, rscManifest, rscRoot } = options;
-    runtime_extensions_namespaceObject.beginHeadRender(runtimeContext);
-    const { shellBefore, shellAfter } = await (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
-        renderLevel: external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER,
+    const { htmlTemplate, runtimeContext, config, ssrConfig, entryName, resource, rscManifest, rscRoot } = options;
+    const hooks = (0, context_namespaceObject.getGlobalInternalRuntimeContext)().hooks;
+    const isRsc = true === (0, context_namespaceObject.getGlobalEnableRsc)();
+    const extenders = hooks.extendStreamSSR.call({
+        runtimeContext,
+        request,
+        resource,
+        config,
+        platform: 'web',
+        mode: 'stream',
+        monitors: (0, index_js_namespaceObject.getMonitors)(),
+        isRsc,
+        terminalMarker: external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK
+    }) || [];
+    const lifecycle = (0, external_shared_js_namespaceObject.createSSRRenderLifecycle)(extenders);
+    const reportOnce = (0, external_shared_js_namespaceObject.createSSRStreamErrorReporter)(options.onError);
+    const reportError = (error)=>{
+        if (!request.signal.aborted && lifecycle.terminal?.status !== 'cancelled') reportOnce(error);
+    };
+    const forceStream2String = Boolean("u" > typeof process && process.env?.MODERN_JS_STREAM_TO_STRING);
+    let pendingSource;
+    let bodyOpen = true;
+    let bodyPipe;
+    const templateOptions = {
         runtimeContext,
         ssrConfig,
         request,
         config,
         entryName,
-        moduleFederationCssAssets
-    });
+        lifecycle
+    };
     try {
+        request.signal.throwIfAborted();
+        for (const extender of extenders)extender.init?.({
+            rootElement,
+            forceStream2String
+        });
         const readableOriginal = await (0, ssr_namespaceObject.renderSSRStream)(rootElement, {
             request,
+            signal: request.signal,
             nonce: config.nonce,
+            progressiveChunkSize: external_shared_js_namespaceObject_1.SHELL_PROGRESSIVE_CHUNK_SIZE,
             rscManifest,
             rscRoot: rscRoot,
             routes: runtimeContext.routes,
-            onError (error) {
-                options.onError?.(error);
+            onError: reportError,
+            wrapHtmlRoot (root) {
+                let element = external_react_default().isValidElement(root) ? root : external_react_default().createElement(external_react_default().Fragment, null, root);
+                if (isRsc && false === runtimeContext.isBrowser) element = (0, wrapper_js_namespaceObject.wrapRuntimeComponentResolver)(element, hooks);
+                for (const extender of extenders)element = extender.modifyRootElement?.(element) ?? element;
+                lifecycle.beforeReact();
+                return element;
             }
         });
+        pendingSource = readableOriginal;
         options.onShellReady?.();
-        readableOriginal.allReady.then(()=>{
-            options?.onAllReady?.();
-        });
-        const forceStreamToString = Boolean("u" > typeof process && process.env?.MODERN_JS_STREAM_TO_STRING);
-        const { waitForAllReady } = (0, external_shared_js_namespaceObject.resolveStreamingMode)(request, forceStreamToString);
+        readableOriginal.allReady.then(()=>options.onAllReady?.()).catch(reportError);
+        const { waitForAllReady } = (0, external_shared_js_namespaceObject_1.resolveStreamingMode)(request, forceStream2String);
         if (waitForAllReady) await readableOriginal.allReady;
-        const reader = runtime_extensions_namespaceObject.createConservingWebShellStream(readableOriginal, runtimeContext, external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK, options.onError).getReader();
-        const stream = new ReadableStream({
+        request.signal.throwIfAborted();
+        const styledComponentsStyleTags = extenders.map((extender)=>extender.getStyleTags?.() ?? '').join('');
+        const { shellBefore, shellAfter } = await (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
+            ...templateOptions,
+            renderLevel: external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER,
+            styledComponentsStyleTags
+        });
+        for (const extender of (0, external_shared_js_namespaceObject.orderSSRStreamTransforms)(extenders))if (void 0 !== extender.processReadableStream) pendingSource = extender.processReadableStream(pendingSource);
+        const decoder = new TextDecoder();
+        const encoder = new TextEncoder();
+        const pendingScripts = [];
+        const buffered = [];
+        let bufferedLength = 0;
+        let markerTail = '';
+        let shellChunkStatus = external_shared_js_namespaceObject_1.ShellChunkStatus.START;
+        let bodyController;
+        const emit = (chunk, controller)=>{
+            if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) {
+                if (chunk.length > 0) controller.enqueue(encoder.encode(chunk));
+                return;
+            }
+            const window = markerTail + chunk;
+            const windowIndex = window.indexOf(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK);
+            const markerIndex = bufferedLength - markerTail.length + windowIndex;
+            buffered.push(chunk);
+            bufferedLength += chunk.length;
+            if (-1 === windowIndex) {
+                markerTail = window.slice(Math.max(0, window.length - external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK.length + 1));
+                return;
+            }
+            const shell = buffered.join('');
+            const beforeMark = lifecycle.completedBody(shell.slice(0, markerIndex), 'shell');
+            const afterMark = shell.slice(markerIndex + external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK.length);
+            const completedShellBefore = (0, external_helmet_js_namespaceObject.createReplaceHelemt)((0, external_helmet_js_namespaceObject.getHelmetData)(extenders))(shellBefore);
+            shellChunkStatus = external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH;
+            buffered.length = 0;
+            controller.enqueue(encoder.encode(`${completedShellBefore}${beforeMark}${shellAfter}`));
+            if (afterMark.length > 0) controller.enqueue(encoder.encode(afterMark));
+            for (const script of pendingScripts)controller.enqueue(encoder.encode(script));
+            pendingScripts.length = 0;
+        };
+        const body = new TransformStream({
             start (controller) {
-                const pendingScripts = [];
-                let isClosed = false;
-                const safeEnqueue = (chunk)=>{
-                    if (isClosed) return;
-                    try {
-                        controller.enqueue(chunk);
-                    } catch  {
-                        isClosed = true;
-                    }
-                };
-                const closeController = ()=>{
-                    if (!isClosed) {
-                        isClosed = true;
-                        try {
-                            controller.close();
-                        } catch  {}
-                    }
-                };
-                const flushPendingScripts = ()=>{
-                    for (const s of pendingScripts)safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(s));
-                    pendingScripts.length = 0;
-                };
-                const enqueueScript = (script)=>{
-                    if (shellChunkStatus === external_shared_js_namespaceObject.ShellChunkStatus.FINISH) safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(script));
-                    else pendingScripts.push(script);
-                };
-                const storageContext = node_namespaceObject.storage.useContext?.();
-                const activeDeferreds = storageContext?.activeDeferreds;
-                const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
-                if (entries.length > 0) (0, external_deferredScript_js_namespaceObject.enqueueFromEntries)(entries, config.nonce, enqueueScript);
-                async function push() {
-                    try {
-                        const { done, value } = await reader.read();
-                        if (done) return void closeController();
-                        if (isClosed) return;
-                        if (shellChunkStatus !== external_shared_js_namespaceObject.ShellChunkStatus.FINISH) {
-                            chunkVec.push(new TextDecoder().decode(value));
-                            const concatedChunk = chunkVec.join('');
-                            const markerIndex = concatedChunk.indexOf(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK);
-                            if (-1 !== markerIndex) {
-                                const beforeMark = concatedChunk.slice(0, markerIndex);
-                                const afterMark = concatedChunk.slice(markerIndex + external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK.length);
-                                runtime_extensions_namespaceObject.publishHeadRender(runtimeContext);
-                                const completedShellBefore = (0, external_helmet_js_namespaceObject.createReplaceHelemt)((0, external_helmet_js_namespaceObject.getHelmetData)(runtimeContext))(shellBefore);
-                                shellChunkStatus = external_shared_js_namespaceObject.ShellChunkStatus.FINISH;
-                                safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(`${completedShellBefore}${beforeMark}${shellAfter}`));
-                                if (afterMark.length > 0) safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(afterMark));
-                                flushPendingScripts();
-                            }
-                        } else safeEnqueue(value);
-                        if (!isClosed) push();
-                    } catch (error) {
-                        runtime_extensions_namespaceObject.abortHeadRender(runtimeContext);
-                        if (!isClosed) {
-                            isClosed = true;
-                            try {
-                                controller.error(error);
-                            } catch  {}
-                        }
-                    }
-                }
-                push();
+                bodyController = controller;
+            },
+            transform (chunk, controller) {
+                emit(decoder.decode(chunk, {
+                    stream: true
+                }), controller);
             },
-            cancel (reason) {
-                runtime_extensions_namespaceObject.abortHeadRender(runtimeContext);
-                reader.cancel(reason).catch(()=>{});
+            flush (controller) {
+                bodyOpen = false;
+                emit(decoder.decode(), controller);
+                if (shellChunkStatus !== external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) throw new Error('React SSR stream ended before the shell marker');
             }
         });
-        return stream;
-    } catch (e) {
-        runtime_extensions_namespaceObject.abortHeadRender(runtimeContext);
-        const fallbackHtml = `${shellBefore}${shellAfter}`;
-        const stream = (0, external_shared_js_namespaceObject.getReadableStreamFromString)(fallbackHtml);
-        return stream;
+        bodyPipe = pendingSource.pipeTo(body.writable);
+        bodyPipe.catch(()=>{});
+        pendingSource = body.readable;
+        const activeDeferreds = node_namespaceObject.storage.useContext?.()?.activeDeferreds;
+        const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
+        (0, external_deferredScript_js_namespaceObject.enqueueFromEntries)(entries, config.nonce, (script)=>{
+            if (!bodyOpen) return;
+            if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) try {
+                bodyController.enqueue(encoder.encode(script));
+            } catch  {
+                bodyOpen = false;
+            }
+            else pendingScripts.push(script);
+        });
+        return (0, external_shared_js_namespaceObject.observeSSRStream)(pendingSource, {
+            lifecycle,
+            async onError (error) {
+                bodyOpen = false;
+                await bodyPipe?.catch(()=>{});
+                reportError(error);
+            },
+            signal: request.signal,
+            async onCancel (reason) {
+                bodyOpen = false;
+                await bodyPipe?.catch((error)=>{
+                    if (error !== reason) throw error;
+                });
+            },
+            onComplete: ()=>bodyPipe
+        });
+    } catch (error) {
+        bodyOpen = false;
+        if (void 0 !== pendingSource) try {
+            await pendingSource.cancel(error);
+            await bodyPipe?.catch(()=>{});
+        } catch (cancelError) {
+            if (!request.signal.aborted) reportError(cancelError);
+        }
+        if (request.signal.aborted) {
+            lifecycle.finish({
+                status: 'cancelled',
+                reason: request.signal.reason
+            });
+            throw request.signal.reason;
+        }
+        lifecycle.finish({
+            status: 'fallback',
+            error
+        });
+        reportError(error);
+        const { shellBefore, shellAfter } = await (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
+            ...templateOptions,
+            renderLevel: external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER,
+            helmetData: (0, external_helmet_js_namespaceObject.getHelmetData)(extenders)
+        });
+        return (0, external_shared_js_namespaceObject.observeSSRStream)((0, external_shared_js_namespaceObject_1.getReadableStreamFromString)(`${shellBefore}${shellAfter}`), {
+            lifecycle,
+            onError: reportError,
+            signal: request.signal
+        });
     }
 };
 exports.createReadableStreamFromElement = __webpack_exports__.createReadableStreamFromElement;

package/dist/cjs/core/server/stream/deferredScript.js

@@ -58,13 +58,13 @@ function isDeferredDataLike(v) {
     return hasPending && hasData;
 }
 function isPromiseLike(value) {
-    return !!value && 'function' == typeof value.then;
+    return Boolean(value) && 'function' == typeof value.then;
 }
 function toErrorInfo(error) {
     if ((0, external_utils_js_namespaceObject.shouldRedactServerError)()) return {
         message: 'Unexpected Server Error'
     };
-    if (error && 'object' == typeof error) {
+    if (null !== error && 'object' == typeof error) {
         const maybeMsg = error.message;
         const maybeStack = error.stack;
         return {
@@ -79,7 +79,7 @@ function toErrorInfo(error) {
 function buildDeferredDataScript(nonce, args) {
     const payload = JSON.stringify(args);
     const escaped = escapeAttr(payload);
-    const nonceAttr = nonce ? ` nonce="${nonce}"` : '';
+    const nonceAttr = void 0 !== nonce && '' !== nonce ? ` nonce="${nonce}"` : '';
     return `<script async${nonceAttr} data-fn-name="r" data-script-src="modern-run-router-data-fn" data-fn-args='${escaped}' suppressHydrationWarning>${constants_js_namespaceObject.runRouterDataFnStr}</script>`;
 }
 function enqueueFromEntries(entries, nonce, emit) {

package/dist/cjs/core/server/stream/shared.js

@@ -28,6 +28,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    SHELL_PROGRESSIVE_CHUNK_SIZE: ()=>SHELL_PROGRESSIVE_CHUNK_SIZE,
     ShellChunkStatus: ()=>shared_ShellChunkStatus,
     createRenderStreaming: ()=>createRenderStreaming,
     encodeForWebStream: ()=>encodeForWebStream,
@@ -46,6 +47,7 @@ var shared_ShellChunkStatus = /*#__PURE__*/ function(ShellChunkStatus) {
     ShellChunkStatus[ShellChunkStatus["FINISH"] = 1] = "FINISH";
     return ShellChunkStatus;
 }({});
+const SHELL_PROGRESSIVE_CHUNK_SIZE = Number.MAX_SAFE_INTEGER;
 const SHOULD_STREAM_ALL_HEADER = 'x-should-stream-all';
 function parseShouldStreamAllFlag(value) {
     if (!value) return;
@@ -99,7 +101,7 @@ function createRenderStreaming(createReadableStreamPromise) {
         const end = (0, time_namespaceObject.time)();
         const { runtimeContext, config, resource } = options;
         const { onError, onTiming } = options;
-        const { htmlTemplate, entryName, moduleFederationCssAssets } = resource;
+        const { htmlTemplate, entryName } = resource;
         const ssrConfig = (0, external_utils_js_namespaceObject.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
         const StreamServerRootWrapper = ({ children })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
                 children: [
@@ -119,7 +121,7 @@ function createRenderStreaming(createReadableStreamPromise) {
             runtimeContext,
             ssrConfig,
             entryName,
-            moduleFederationCssAssets,
+            resource,
             rscClientManifest: options.rscClientManifest,
             rscSSRManifest: options.rscSSRManifest,
             rscServerManifest: options.rscServerManifest,
@@ -143,12 +145,14 @@ function createRenderStreaming(createReadableStreamPromise) {
         return stream;
     };
 }
+exports.SHELL_PROGRESSIVE_CHUNK_SIZE = __webpack_exports__.SHELL_PROGRESSIVE_CHUNK_SIZE;
 exports.ShellChunkStatus = __webpack_exports__.ShellChunkStatus;
 exports.createRenderStreaming = __webpack_exports__.createRenderStreaming;
 exports.encodeForWebStream = __webpack_exports__.encodeForWebStream;
 exports.getReadableStreamFromString = __webpack_exports__.getReadableStreamFromString;
 exports.resolveStreamingMode = __webpack_exports__.resolveStreamingMode;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SHELL_PROGRESSIVE_CHUNK_SIZE",
     "ShellChunkStatus",
     "createRenderStreaming",
     "encodeForWebStream",

package/dist/cjs/core/server/string/index.js

@@ -39,17 +39,16 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     renderString: ()=>renderString
 });
-const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const time_namespaceObject = require("@modern-js/runtime-utils/time");
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const server_namespaceObject = require("react-dom/server");
 var server_default = /*#__PURE__*/ __webpack_require__.n(server_namespaceObject);
 const external_constants_js_namespaceObject = require("../../constants.js");
-const index_js_namespaceObject = require("../../context/index.js");
+const index_js_namespaceObject = require("../../context/monitors/index.js");
 const wrapper_js_namespaceObject = require("../../react/wrapper.js");
 const external_constants_js_namespaceObject_1 = require("../constants.js");
 const external_helmet_js_namespaceObject = require("../helmet.js");
-const external_scriptOrder_js_namespaceObject = require("../scriptOrder.js");
 const external_shared_js_namespaceObject = require("../shared.js");
 const external_tracer_js_namespaceObject = require("../tracer.js");
 const external_utils_js_namespaceObject = require("../utils.js");
@@ -62,7 +61,7 @@ const renderString = async (request, serverRoot, options)=>{
         onTiming
     };
     const routerContext = runtimeContext.routerContext;
-    const { htmlTemplate, entryName, loadableStats, routeManifest, moduleFederationCssAssets } = resource;
+    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
     const ssrConfig = (0, external_utils_js_namespaceObject.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
     const chunkSet = {
         renderLevel: external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER,
@@ -70,85 +69,124 @@ const renderString = async (request, serverRoot, options)=>{
         jsChunk: '',
         cssChunk: ''
     };
-    const collectors = [
-        new external_loadable_js_namespaceObject.LoadableCollector({
-            stats: loadableStats,
-            nonce: config.nonce,
-            routeManifest,
-            runtimeContext,
-            template: htmlTemplate,
-            entryName,
-            moduleFederationCssAssets,
-            chunkSet,
-            config
-        }),
-        new external_ssrData_js_namespaceObject.SSRDataCollector({
-            runtimeContext,
-            request,
-            ssrConfig,
-            ssrContext: runtimeContext.ssrContext,
-            chunkSet,
-            routerContext,
-            nonce: config.nonce,
-            useJsonScript: config.useJsonScript
-        })
-    ];
-    const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+    const collectors = [];
+    const lifecycle = (0, external_shared_js_namespaceObject.createSSRRenderLifecycle)(collectors);
+    const loadableCollector = new external_loadable_js_namespaceObject.LoadableCollector({
+        stats: loadableStats,
+        nonce: config.nonce,
+        routeManifest,
+        template: htmlTemplate,
+        entryName,
+        chunkSet,
+        config,
+        lifecycle
+    });
+    collectors.push(loadableCollector, new external_ssrData_js_namespaceObject.SSRDataCollector({
+        runtimeContext,
+        request,
+        ssrConfig,
+        ssrContext: runtimeContext.ssrContext,
+        chunkSet,
+        routerContext,
+        nonce: config.nonce,
+        useJsonScript: config.useJsonScript,
+        lifecycle
+    }));
+    const internalRuntimeContext = (0, context_namespaceObject.getGlobalInternalRuntimeContext)();
     const hooks = internalRuntimeContext.hooks;
     const extraCollectors = hooks.extendStringSSRCollectors.call({
-        chunkSet
+        chunkSet,
+        render: {
+            runtimeContext,
+            request,
+            resource,
+            config,
+            platform: 'node',
+            mode: 'string',
+            monitors: (0, index_js_namespaceObject.getMonitors)(),
+            isRsc: true === (0, context_namespaceObject.getGlobalEnableRsc)()
+        }
     });
     for (const c of extraCollectors)if (c) collectors.unshift(c);
-    const rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
+    let rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
         ssr: true
     }));
-    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], runtimeContext, entryName, tracer);
+    if (true === (0, context_namespaceObject.getGlobalEnableRsc)() && false === runtimeContext.isBrowser) rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeComponentResolver)(rootElement, hooks);
+    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], tracer, request.signal, lifecycle, loadableCollector.stylesheetInfo);
     return html;
 };
-async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, runtimeContext, entryName, { onError, onTiming }) {
+async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }, signal, lifecycle, stylesheetInfo) {
     let html = '';
     let helmetData;
-    const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
-    runtime_extensions_namespaceObject.beginHeadRender(runtimeContext);
     try {
-        const end = (0, time_namespaceObject.time)();
-        html = server_default().renderToString(finalApp, {
-            identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
+        signal.throwIfAborted();
+        try {
+            const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
+            lifecycle.beforeReact();
+            const end = (0, time_namespaceObject.time)();
+            html = server_default().renderToString(finalApp, {
+                identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
+            });
+            html = lifecycle.completedBody(html, 'complete');
+            chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
+            helmetData = (0, external_helmet_js_namespaceObject.getHelmetData)(collectors);
+            const cost = end();
+            onTiming(external_tracer_js_namespaceObject.SSRTimings.RENDER_HTML, cost);
+        } catch (error) {
+            lifecycle.finish({
+                status: 'fallback',
+                error
+            });
+            html = '';
+            chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+            onError(error, external_tracer_js_namespaceObject.SSRErrors.RENDER_HTML);
+        }
+        await Promise.all(collectors.map((component)=>component.effect()));
+        signal.throwIfAborted();
+        const { ssrScripts, cssChunk, jsChunk } = chunkSet;
+        const finalHtml = await (0, external_shared_js_namespaceObject.buildHtml)(htmlTemplate, [
+            createReplaceHtml(html),
+            (template)=>(0, external_shared_js_namespaceObject.replaceSSRTemplateChunk)({
+                    name: "scripts",
+                    template,
+                    placeholder: external_constants_js_namespaceObject_1.CHUNK_JS_PLACEHOLDER,
+                    content: jsChunk
+                }, lifecycle),
+            (template)=>(0, external_shared_js_namespaceObject.replaceSSRTemplateChunk)({
+                    name: 'styles',
+                    template,
+                    placeholder: external_constants_js_namespaceObject_1.CHUNK_CSS_PLACEHOLDER,
+                    content: cssChunk,
+                    ...stylesheetInfo
+                }, lifecycle),
+            (template)=>(0, external_shared_js_namespaceObject.replaceSSRTemplateChunk)({
+                    name: 'data',
+                    template,
+                    placeholder: external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER,
+                    content: ssrScripts
+                }, lifecycle),
+            (0, external_helmet_js_namespaceObject.createReplaceHelemt)(helmetData),
+            ...htmlModifiers
+        ]);
+        signal.throwIfAborted();
+        lifecycle.finish({
+            status: 'complete'
+        });
+        return finalHtml;
+    } catch (error) {
+        lifecycle.finish(signal.aborted ? {
+            status: 'cancelled',
+            reason: signal.reason
+        } : {
+            status: 'error',
+            error
         });
-        html = runtime_extensions_namespaceObject.completeHeadRender(runtimeContext, html);
-        chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
-        helmetData = (0, external_helmet_js_namespaceObject.getHelmetData)(runtimeContext);
-        const cost = end();
-        onTiming(external_tracer_js_namespaceObject.SSRTimings.RENDER_HTML, cost);
-    } catch (e) {
-        runtime_extensions_namespaceObject.abortHeadRender(runtimeContext);
-        chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
-        onError(e, external_tracer_js_namespaceObject.SSRErrors.RENDER_HTML);
+        throw error;
     }
-    await Promise.all(collectors.map((component)=>component.effect()));
-    const { ssrScripts, cssChunk, jsChunk } = chunkSet;
-    const finalHtml = await (0, external_shared_js_namespaceObject.buildHtml)(htmlTemplate, [
-        createReplaceHtml(html),
-        createReplaceChunkJs(jsChunk, entryName),
-        createReplaceChunkCss(cssChunk),
-        createReplaceSSRDataScript(ssrScripts, entryName),
-        (0, external_helmet_js_namespaceObject.createReplaceHelemt)(helmetData),
-        ...htmlModifiers
-    ]);
-    return finalHtml;
 }
 function createReplaceHtml(html) {
     return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.HTML_PLACEHOLDER, html);
 }
-function createReplaceSSRDataScript(data, entryName) {
-    return (template)=>(0, external_scriptOrder_js_namespaceObject.replaceChunkJsPlaceholder)(template, data, entryName, external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER);
-}
-function createReplaceChunkJs(js, entryName) {
-    return (template)=>(0, external_scriptOrder_js_namespaceObject.replaceChunkJsPlaceholder)(template, js, entryName);
-}
-function createReplaceChunkCss(css) {
-    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.CHUNK_CSS_PLACEHOLDER, css);
-}
 exports.renderString = __webpack_exports__.renderString;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "renderString"