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

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

@@ -1,11 +1,9 @@
 import "node:module";
 import { matchRoutes } from "@modern-js/runtime-utils/router";
-import { getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
 import { CHUNK_CSS_PLACEHOLDER } from "../constants.mjs";
-import { createFederatedCssLinks } from "../federatedCss.mjs";
-import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
-import { buildHtml } from "../shared.mjs";
-import { checkIsNode, hasStylesheetLink, safeReplace } from "../utils.mjs";
+import { createReplaceHelemt } from "../helmet.mjs";
+import { buildHtml, replaceSSRTemplateChunk } from "../shared.mjs";
+import { checkIsNode, hasStylesheetLink } from "../utils.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
@@ -17,12 +15,11 @@ const readAsset = async (chunk)=>{
 };
 const checkIsInline = (chunk, enableInline)=>{
     if ('production' !== process.env.NODE_ENV) return false;
-    if (enableInline instanceof RegExp) return enableInline.test(chunk);
-    return Boolean(enableInline);
+    else if (enableInline instanceof RegExp) return enableInline.test(chunk);
+    else return Boolean(enableInline);
 };
 async function buildShellBeforeTemplate(beforeAppTemplate, options) {
-    const { config, runtimeContext, styledComponentsStyleTags, entryName, moduleFederationCssAssets } = options;
-    const helmetData = getHelmetData(runtimeContext);
+    const { config, runtimeContext, styledComponentsStyleTags, entryName, lifecycle, helmetData } = options;
     const callbacks = [
         createReplaceHelemt(helmetData),
         (template)=>injectCss(template, entryName, styledComponentsStyleTags)
@@ -31,41 +28,53 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
     async function injectCss(template, entryName, styledComponentsStyleTags) {
         let css = await getCssChunks();
         if (styledComponentsStyleTags) css += styledComponentsStyleTags;
-        css += createFederatedCssLinks(moduleFederationCssAssets, {
+        return replaceSSRTemplateChunk({
+            name: 'styles',
             template,
-            existingAssets: css.match(/href="([^"]+)"/g)?.map((item)=>item.replace(/^href="/, '').replace(/"$/, ''))
-        });
-        return safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
+            placeholder: CHUNK_CSS_PLACEHOLDER,
+            content: css,
+            emittedAssets: css.match(/href="([^"]+)"/g)?.map((item)=>item.replace(/^href="/, '').replace(/"$/, ''))
+        }, lifecycle);
         async function getCssChunks() {
             const { routeManifest, routerContext, routes } = runtimeContext;
             const routeAssets = routeManifest?.routeAssets;
             if (!routeAssets) return '';
             let matchedRouteManifests = [];
-            const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext);
-            if (matchedRouteIds?.length) matchedRouteManifests = matchedRouteIds.map((routeId)=>routeAssets[routeId]).filter(Boolean);
-            else if (routerContext && routes) {
+            if (routerContext && routes) {
                 const matches = matchRoutes(routes, routerContext.location, routerContext.basename);
-                matchedRouteManifests = matches?.map((match, index)=>{
-                    if (!index) return;
+                matchedRouteManifests = matches?.flatMap((match, index)=>{
                     const routeId = match.route.id;
-                    if (routeId) return routeAssets[routeId];
-                }).filter((routeManifest)=>void 0 !== routeManifest) ?? [];
+                    const manifest = 0 !== index && routeId ? routeAssets[routeId] : void 0;
+                    return void 0 === manifest ? [] : [
+                        manifest
+                    ];
+                }) ?? [];
             }
-            const asyncEntry = routeAssets[`async-${entryName}`];
-            if (asyncEntry) matchedRouteManifests.push(asyncEntry);
-            const cssChunks = matchedRouteManifests.reduce((chunks, routeManifest)=>{
-                const { referenceCssAssets = [] } = routeManifest;
-                const _cssChunks = referenceCssAssets.filter((asset)=>asset?.endsWith('.css') && !hasStylesheetLink(template, asset));
-                return [
-                    ...chunks,
-                    ..._cssChunks
-                ];
-            }, []);
+            const createAsset = (url)=>({
+                    url
+                });
+            const groups = [
+                {
+                    name: 'route',
+                    assets: matchedRouteManifests.flatMap((manifest)=>manifest.referenceCssAssets ?? []).map(createAsset)
+                },
+                {
+                    name: 'async-entry',
+                    assets: (routeAssets[`async-${entryName}`]?.referenceCssAssets ?? []).map(createAsset)
+                }
+            ];
+            const assets = lifecycle?.transformAssets(groups, {
+                kind: 'style',
+                source: 'template',
+                template,
+                createAsset
+            }) ?? groups.flatMap((group)=>group.assets);
+            const cssChunks = assets.map((asset)=>asset.url).filter((asset)=>asset.endsWith('.css') && !hasStylesheetLink(template, asset));
             const { inlineStyles } = config;
             const styles = await Promise.all(cssChunks.map(async (chunk)=>{
                 const link = `<link href="${chunk}" rel="stylesheet" />`;
                 if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
-                return link;
+                else return link;
             }));
             return `${styles.join('')}`;
         }

package/dist/esm-node/core/server/stream/beforeTemplate.worker.mjs

@@ -1,18 +1,15 @@
 import "node:module";
-import { getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
 import { CHUNK_CSS_PLACEHOLDER } from "../constants.mjs";
-import { createFederatedCssLinks } from "../federatedCss.mjs";
-import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
-import { buildHtml } from "../shared.mjs";
-import { hasStylesheetLink, safeReplace } from "../utils.mjs";
+import { createReplaceHelemt } from "../helmet.mjs";
+import { buildHtml, replaceSSRTemplateChunk } from "../shared.mjs";
+import { hasStylesheetLink } from "../utils.mjs";
 const checkIsInline = (chunk, enableInline)=>{
     if ('production' !== process.env.NODE_ENV) return false;
-    if (enableInline instanceof RegExp) return enableInline.test(chunk);
-    return Boolean(enableInline);
+    else if (enableInline instanceof RegExp) return enableInline.test(chunk);
+    else return Boolean(enableInline);
 };
 async function buildShellBeforeTemplate(beforeAppTemplate, options) {
-    const { config, runtimeContext, styledComponentsStyleTags, entryName, moduleFederationCssAssets } = options;
-    const helmetData = getHelmetData(runtimeContext);
+    const { config, runtimeContext, styledComponentsStyleTags, entryName, lifecycle, helmetData } = options;
     const callbacks = [
         createReplaceHelemt(helmetData),
         (template)=>injectCss(template, entryName, styledComponentsStyleTags)
@@ -21,28 +18,38 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
     async function injectCss(template, entryName, styledComponentsStyleTags) {
         let css = await getCssChunks();
         if (styledComponentsStyleTags) css += styledComponentsStyleTags;
-        css += createFederatedCssLinks(moduleFederationCssAssets, {
+        return replaceSSRTemplateChunk({
+            name: 'styles',
             template,
-            existingAssets: css.match(/href="([^"]+)"/g)?.map((item)=>item.replace(/^href="/, '').replace(/"$/, ''))
-        });
-        return safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
+            placeholder: CHUNK_CSS_PLACEHOLDER,
+            content: css,
+            emittedAssets: css.match(/href="([^"]+)"/g)?.map((item)=>item.replace(/^href="/, '').replace(/"$/, ''))
+        }, lifecycle);
         async function getCssChunks() {
             const { routeManifest } = runtimeContext;
             const routeAssets = routeManifest?.routeAssets;
             if (!routeAssets) return '';
-            let matchedRouteManifests = [];
-            const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext);
-            if (matchedRouteIds?.length) matchedRouteManifests = matchedRouteIds.map((routeId)=>routeAssets[routeId]).filter(Boolean);
-            const asyncEntry = routeAssets[`async-${entryName}`];
-            if (asyncEntry) matchedRouteManifests.push(asyncEntry);
-            const cssChunks = matchedRouteManifests.reduce((chunks, routeManifest)=>{
-                const { referenceCssAssets = [] } = routeManifest;
-                const _cssChunks = referenceCssAssets.filter((asset)=>asset?.endsWith('.css') && !hasStylesheetLink(template, asset));
-                return [
-                    ...chunks,
-                    ..._cssChunks
-                ];
-            }, []);
+            const matchedRouteManifests = [];
+            const createAsset = (url)=>({
+                    url
+                });
+            const groups = [
+                {
+                    name: 'route',
+                    assets: matchedRouteManifests.flatMap((manifest)=>manifest.referenceCssAssets ?? []).map(createAsset)
+                },
+                {
+                    name: 'async-entry',
+                    assets: (routeAssets[`async-${entryName}`]?.referenceCssAssets ?? []).map(createAsset)
+                }
+            ];
+            const assets = lifecycle?.transformAssets(groups, {
+                kind: 'style',
+                source: 'template',
+                template,
+                createAsset
+            }) ?? groups.flatMap((group)=>group.assets);
+            const cssChunks = assets.map((asset)=>asset.url).filter((asset)=>asset.endsWith('.css') && !hasStylesheetLink(template, asset));
             const { inlineStyles } = config;
             const styles = cssChunks.map((chunk)=>{
                 const link = `<link href="${chunk}" rel="stylesheet" />`;

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

@@ -1,148 +1,245 @@
 import "node:module";
+import { getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { storage } from "@modern-js/runtime-utils/node";
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
-import { PassThrough, Readable, Transform } from "stream";
+import { PassThrough, Readable, Transform, finished, pipeline } from "stream";
 import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common.mjs";
 import { RenderLevel } from "../../constants.mjs";
-import { getGlobalInternalRuntimeContext } from "../../context/index.mjs";
 import { getMonitors } from "../../context/monitors/index.mjs";
+import { wrapRuntimeComponentResolver } from "../../react/wrapper.mjs";
 import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
+import { createSSRRenderLifecycle, createSSRStreamErrorReporter, observeSSRStream, orderSSRStreamTransforms } from "../shared.mjs";
 import { enqueueFromEntries } from "./deferredScript.mjs";
-import { ShellChunkStatus, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
+import { SHELL_PROGRESSIVE_CHUNK_SIZE, ShellChunkStatus, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
 import { getTemplates } from "./template.mjs";
-import * as __rspack_external__modern_js_runtime_extensions_node_f016b1ee from "@modern-js/runtime-extensions/node";
-const defaultExtender = {
-    modifyRootElement: (rootElement)=>rootElement,
-    getStyleTags: ()=>'',
-    processStream: (stream)=>stream
-};
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
     const { renderToPipeableStream } = await import("react-dom/server");
-    const { runtimeContext, htmlTemplate, config, ssrConfig, entryName, moduleFederationCssAssets } = options;
-    let shellChunkStatus = ShellChunkStatus.START;
-    let renderLevel = RenderLevel.SERVER_RENDER;
+    const { runtimeContext, htmlTemplate, config, ssrConfig, entryName, resource } = options;
+    const hooks = getGlobalInternalRuntimeContext().hooks;
+    const isRsc = true === getGlobalEnableRsc();
+    const extenders = hooks.extendStreamSSR.call({
+        runtimeContext,
+        request,
+        resource,
+        config,
+        platform: 'node',
+        mode: 'stream',
+        monitors: getMonitors(),
+        isRsc,
+        terminalMarker: ESCAPED_SHELL_STREAM_END_MARK
+    }) || [];
+    const lifecycle = createSSRRenderLifecycle(extenders);
+    const reportError = createSSRStreamErrorReporter(options.onError);
     const forceStream2String = Boolean(process.env.MODERN_JS_STREAM_TO_STRING);
     const { onReady } = resolveStreamingMode(request, forceStream2String);
-    const internalRuntimeContext = getGlobalInternalRuntimeContext();
-    const hooks = internalRuntimeContext.hooks;
-    const extenders = hooks.extendStreamSSR.call() || [];
-    if (0 === extenders.length) extenders.push(defaultExtender);
-    extenders.forEach((extender)=>{
-        if (extender.init) extender.init({
-            rootElement,
-            forceStream2String
-        });
-    });
-    let processedRootElement = rootElement;
-    extenders.forEach((extender)=>{
-        if (extender.modifyRootElement) processedRootElement = extender.modifyRootElement(processedRootElement);
-    });
-    const chunkVec = [];
+    let renderLevel = RenderLevel.SERVER_RENDER;
     let hasStartedPipe = false;
-    __rspack_external__modern_js_runtime_extensions_node_f016b1ee.beginHeadRender(runtimeContext);
-    const reportError = __rspack_external__modern_js_runtime_extensions_node_f016b1ee.createOnceErrorReporter(options.onError);
-    return new Promise((resolve)=>{
-        const { pipe: reactStreamingPipe } = renderToPipeableStream(processedRootElement, {
-            nonce: config.nonce,
-            identifierPrefix: SSR_HYDRATION_ID_PREFIX,
-            [onReady] () {
-                if (hasStartedPipe) return;
-                hasStartedPipe = true;
-                let styledComponentsStyleTags = '';
-                extenders.forEach((extender)=>{
-                    if (extender.getStyleTags) styledComponentsStyleTags += extender.getStyleTags();
+    let failed = false;
+    let reactStream;
+    const ownedStreams = new Set();
+    const streamCompletions = [];
+    let teardown;
+    return new Promise((resolve, reject)=>{
+        const destroyOwnedStreams = (reason)=>{
+            if (teardown) return teardown;
+            const error = void 0 === reason ? void 0 : reason instanceof Error ? reason : new Error(String(reason));
+            for (const stream of ownedStreams){
+                const destroyable = stream;
+                destroyable.destroy?.(error);
+            }
+            teardown = Promise.all(streamCompletions).then((errors)=>{
+                const cleanupError = errors.find((value)=>void 0 !== value && value !== error && 'ERR_STREAM_PREMATURE_CLOSE' !== value.code);
+                if (cleanupError) throw cleanupError;
+            });
+            return teardown;
+        };
+        const abortReact = (reason)=>reactStream?.abort(reason);
+        const fail = (error)=>{
+            if (failed) return;
+            failed = true;
+            request.signal.removeEventListener('abort', onStartupAbort);
+            if (request.signal.aborted) lifecycle.finish({
+                status: 'cancelled',
+                reason: request.signal.reason
+            });
+            else {
+                lifecycle.finish({
+                    status: 'error',
+                    error
                 });
-                options[onReady]?.();
-                getTemplates(htmlTemplate, {
-                    request,
-                    ssrConfig,
-                    renderLevel,
-                    runtimeContext,
-                    config,
-                    entryName,
-                    moduleFederationCssAssets,
-                    styledComponentsStyleTags
-                }).then(({ shellAfter, shellBefore })=>{
-                    const pendingScripts = [];
-                    const body = new Transform({
-                        transform (chunk, _encoding, callback) {
-                            try {
-                                if (shellChunkStatus !== ShellChunkStatus.FINISH) {
-                                    chunkVec.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-                                    const concatedChunk = Buffer.concat(chunkVec).toString('utf-8');
-                                    const markerIndex = concatedChunk.indexOf(ESCAPED_SHELL_STREAM_END_MARK);
-                                    if (-1 !== markerIndex) {
-                                        const beforeMark = concatedChunk.slice(0, markerIndex);
-                                        const afterMark = concatedChunk.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
-                                        __rspack_external__modern_js_runtime_extensions_node_f016b1ee.publishHeadRender(runtimeContext);
-                                        const completedShellBefore = createReplaceHelemt(getHelmetData(runtimeContext))(shellBefore);
-                                        shellChunkStatus = ShellChunkStatus.FINISH;
-                                        this.push(`${completedShellBefore}${beforeMark}${shellAfter}`);
-                                        if (afterMark) this.push(afterMark);
-                                        if (pendingScripts.length > 0) for (const s of pendingScripts)this.push(s);
-                                    }
-                                } else this.push(chunk);
-                                callback();
-                            } catch (e) {
-                                e instanceof Error ? callback(e) : callback(new Error('Received unknown error when streaming'));
-                            }
+                reportError(error);
+            }
+            abortReact(error);
+            destroyOwnedStreams(error).then(()=>reject(error), ()=>reject(error));
+        };
+        const own = (stream)=>{
+            if (!ownedStreams.has(stream)) {
+                ownedStreams.add(stream);
+                streamCompletions.push(new Promise((done)=>{
+                    finished(stream, (error)=>done(error ?? void 0));
+                }));
+                stream.on('error', fail);
+            }
+            return stream;
+        };
+        const onStartupAbort = ()=>fail(request.signal.reason);
+        const deliver = (source)=>{
+            const stream = observeSSRStream(source, {
+                lifecycle,
+                signal: request.signal,
+                async onError (error) {
+                    failed = true;
+                    abortReact(error);
+                    await destroyOwnedStreams(error);
+                    reportError(error);
+                },
+                onCancel (reason) {
+                    failed = true;
+                    const cleanup = destroyOwnedStreams();
+                    abortReact(reason);
+                    return cleanup;
+                }
+            });
+            request.signal.removeEventListener('abort', onStartupAbort);
+            resolve(stream);
+        };
+        const templateOptions = ()=>({
+                request,
+                ssrConfig,
+                renderLevel,
+                runtimeContext,
+                config,
+                entryName,
+                lifecycle
+            });
+        const startOutput = async ()=>{
+            if (hasStartedPipe || failed) return;
+            hasStartedPipe = true;
+            const styledComponentsStyleTags = extenders.map((extender)=>extender.getStyleTags?.() ?? '').join('');
+            options[onReady]?.();
+            const { shellBefore, shellAfter } = await getTemplates(htmlTemplate, {
+                ...templateOptions(),
+                styledComponentsStyleTags
+            });
+            if (failed) return;
+            const chunks = [];
+            let bufferedLength = 0;
+            const marker = Buffer.from(ESCAPED_SHELL_STREAM_END_MARK);
+            let markerTail = Buffer.alloc(0);
+            const pendingScripts = [];
+            let shellChunkStatus = ShellChunkStatus.START;
+            const emitShell = (destination, buffered, markerIndex)=>{
+                const beforeMark = lifecycle.completedBody(buffered.subarray(0, markerIndex).toString('utf8'), 'shell');
+                const completedShellBefore = createReplaceHelemt(getHelmetData(extenders))(shellBefore);
+                shellChunkStatus = ShellChunkStatus.FINISH;
+                chunks.length = 0;
+                bufferedLength = 0;
+                destination.push(`${completedShellBefore}${beforeMark}${shellAfter}`);
+                const afterMark = buffered.subarray(markerIndex + marker.length);
+                if (afterMark.length > 0) destination.push(afterMark);
+                for (const script of pendingScripts)destination.push(script);
+                pendingScripts.length = 0;
+            };
+            const body = new Transform({
+                transform (chunk, _encoding, callback) {
+                    try {
+                        if (shellChunkStatus === ShellChunkStatus.FINISH) this.push(chunk);
+                        else {
+                            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                            const window = Buffer.concat([
+                                markerTail,
+                                bytes
+                            ]);
+                            const windowIndex = window.indexOf(marker);
+                            const windowStart = bufferedLength - markerTail.length;
+                            chunks.push(bytes);
+                            bufferedLength += bytes.length;
+                            if (-1 === windowIndex) markerTail = window.subarray(Math.max(0, window.length - marker.length + 1));
+                            else emitShell(this, Buffer.concat(chunks, bufferedLength), windowStart + windowIndex);
                         }
-                    });
-                    const passThrough = new PassThrough();
-                    const stream = Readable.toWeb(body);
-                    resolve(stream);
-                    let processedStream = passThrough;
-                    extenders.forEach((extender)=>{
-                        if (extender.processStream) processedStream = extender.processStream(processedStream);
-                    });
-                    __rspack_external__modern_js_runtime_extensions_node_f016b1ee.pipeNodeHeadStream({
-                        source: processedStream,
-                        destination: body,
-                        context: runtimeContext,
-                        terminalMarker: ESCAPED_SHELL_STREAM_END_MARK,
-                        onError: reportError
-                    });
-                    reactStreamingPipe(passThrough);
+                        callback();
+                    } catch (error) {
+                        callback(error instanceof Error ? error : new Error(String(error)));
+                    }
+                },
+                flush (callback) {
                     try {
-                        const storageContext = storage.useContext?.();
-                        const activeDeferreds = storageContext?.activeDeferreds;
-                        const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
-                        if (entries.length > 0) {
-                            const enqueueScript = (s)=>{
-                                if (shellChunkStatus === ShellChunkStatus.FINISH) body.write(s);
-                                else pendingScripts.push(s);
-                            };
-                            enqueueFromEntries(entries, config.nonce, (s)=>enqueueScript(s));
+                        if (shellChunkStatus !== ShellChunkStatus.FINISH) {
+                            const buffered = Buffer.concat(chunks);
+                            emitShell(this, buffered, buffered.length);
                         }
-                    } catch (err) {
-                        const monitors = getMonitors();
-                        monitors.error("cannot inject router data script", err);
+                        callback();
+                    } catch (error) {
+                        callback(error instanceof Error ? error : new Error(String(error)));
                     }
+                }
+            });
+            own(body);
+            const passThrough = new PassThrough();
+            let processedStream = own(passThrough);
+            for (const extender of orderSSRStreamTransforms(extenders))if (extender.processStream) processedStream = own(extender.processStream(processedStream));
+            pipeline(processedStream, body, (error)=>{
+                if (null != error && !failed) fail(error);
+            });
+            deliver(Readable.toWeb(body));
+            reactStream.pipe(passThrough);
+            try {
+                const activeDeferreds = storage.useContext?.()?.activeDeferreds;
+                const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
+                enqueueFromEntries(entries, config.nonce, (script)=>{
+                    if (failed || body.destroyed || body.writableEnded) return;
+                    if (shellChunkStatus === ShellChunkStatus.FINISH) body.write(script);
+                    else pendingScripts.push(script);
                 });
-            },
-            onShellError (error) {
-                __rspack_external__modern_js_runtime_extensions_node_f016b1ee.abortHeadRender(runtimeContext);
-                renderLevel = RenderLevel.CLIENT_RENDER;
-                getTemplates(htmlTemplate, {
-                    request,
-                    ssrConfig,
-                    renderLevel,
-                    runtimeContext,
-                    entryName,
-                    config,
-                    moduleFederationCssAssets
-                }).then(({ shellAfter, shellBefore })=>{
-                    const fallbackHtml = `${shellBefore}${shellAfter}`;
-                    const readableStream = getReadableStreamFromString(fallbackHtml);
-                    resolve(readableStream);
-                    options?.onShellError?.(error);
-                });
-            },
-            onError (error) {
-                renderLevel = RenderLevel.CLIENT_RENDER;
-                reportError(error);
+            } catch (error) {
+                getMonitors().error("cannot inject router data script", error);
             }
+        };
+        const renderFallback = async (error)=>{
+            if (failed || hasStartedPipe) return;
+            lifecycle.finish({
+                status: 'fallback',
+                error
+            });
+            renderLevel = RenderLevel.CLIENT_RENDER;
+            const { shellBefore, shellAfter } = await getTemplates(htmlTemplate, {
+                ...templateOptions(),
+                helmetData: getHelmetData(extenders)
+            });
+            if (failed) return;
+            options.onShellError?.(error);
+            deliver(getReadableStreamFromString(`${shellBefore}${shellAfter}`));
+        };
+        request.signal.addEventListener('abort', onStartupAbort, {
+            once: true
         });
+        try {
+            request.signal.throwIfAborted();
+            for (const extender of extenders)extender.init?.({
+                rootElement,
+                forceStream2String
+            });
+            let processedRootElement = isRsc && false === runtimeContext.isBrowser ? wrapRuntimeComponentResolver(rootElement, hooks) : rootElement;
+            for (const extender of extenders)processedRootElement = extender.modifyRootElement?.(processedRootElement) ?? processedRootElement;
+            lifecycle.beforeReact();
+            reactStream = renderToPipeableStream(processedRootElement, {
+                nonce: config.nonce,
+                identifierPrefix: SSR_HYDRATION_ID_PREFIX,
+                progressiveChunkSize: SHELL_PROGRESSIVE_CHUNK_SIZE,
+                [onReady] () {
+                    startOutput().catch(fail);
+                },
+                onShellError (error) {
+                    renderFallback(error).catch(fail);
+                },
+                onError (error) {
+                    renderLevel = RenderLevel.CLIENT_RENDER;
+                    if (!request.signal.aborted && !failed) reportError(error);
+                }
+            });
+        } catch (error) {
+            fail(error);
+        }
     });
 };
 export { createReadableStreamFromElement };