@bleedingdev/modern-js-runtime 3.9.0-ultramodern.4 → 3.9.0-ultramodern.5

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

@@ -30,150 +30,235 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createReadableStreamFromElement: ()=>createReadableStreamFromElement
 });
-const node_namespaceObject = require("@modern-js/runtime-extensions/node");
-const runtime_utils_node_namespaceObject = require("@modern-js/runtime-utils/node");
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const external_stream_namespaceObject = require("stream");
 const external_common_js_namespaceObject = require("../../../common.js");
 const external_constants_js_namespaceObject = require("../../constants.js");
 const index_js_namespaceObject = require("../../context/index.js");
 const monitors_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 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 = external_shared_js_namespaceObject.ShellChunkStatus.START;
-    let renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
+    const { runtimeContext, htmlTemplate, config, ssrConfig, entryName, resource } = options;
+    const hooks = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)().hooks;
+    const isRsc = true === (0, index_js_namespaceObject.getGlobalEnableRsc)();
+    const extenders = hooks.extendStreamSSR.call({
+        runtimeContext,
+        request,
+        resource,
+        config,
+        platform: 'node',
+        mode: 'stream',
+        isRsc,
+        terminalMarker: external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK
+    }) || [];
+    const lifecycle = (0, external_shared_js_namespaceObject.createSSRRenderLifecycle)(extenders);
+    const reportError = (0, external_shared_js_namespaceObject.createSSRStreamErrorReporter)(options.onError);
     const forceStream2String = Boolean(process.env.MODERN_JS_STREAM_TO_STRING);
-    const { onReady } = (0, external_shared_js_namespaceObject.resolveStreamingMode)(request, forceStream2String);
-    const internalRuntimeContext = (0, index_js_namespaceObject.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 = [];
+    const { onReady } = (0, external_shared_js_namespaceObject_1.resolveStreamingMode)(request, forceStream2String);
+    let renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
     let hasStartedPipe = false;
-    node_namespaceObject.beginHeadRender(runtimeContext);
-    const reportError = node_namespaceObject.createOnceErrorReporter(options.onError);
-    return new Promise((resolve)=>{
-        const { pipe: reactStreamingPipe } = renderToPipeableStream(processedRootElement, {
-            nonce: config.nonce,
-            identifierPrefix: constants_namespaceObject.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]?.();
-                (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
-                    request,
-                    ssrConfig,
-                    renderLevel,
-                    runtimeContext,
-                    config,
-                    entryName,
-                    moduleFederationCssAssets,
-                    styledComponentsStyleTags
-                }).then(({ shellAfter, shellBefore })=>{
-                    const pendingScripts = [];
-                    const body = new external_stream_namespaceObject.Transform({
-                        transform (chunk, _encoding, callback) {
-                            try {
-                                if (shellChunkStatus !== external_shared_js_namespaceObject.ShellChunkStatus.FINISH) {
-                                    chunkVec.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-                                    const concatedChunk = Buffer.concat(chunkVec).toString('utf-8');
-                                    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);
-                                        node_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;
-                                        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)=>{
+                    (0, external_stream_namespaceObject.finished)(stream, (error)=>done(error ?? void 0));
+                }));
+                stream.on('error', fail);
+            }
+            return stream;
+        };
+        const onStartupAbort = ()=>fail(request.signal.reason);
+        const deliver = (source)=>{
+            const stream = (0, external_shared_js_namespaceObject.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 (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
+                ...templateOptions(),
+                styledComponentsStyleTags
+            });
+            if (failed) return;
+            const chunks = [];
+            const marker = Buffer.from(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK);
+            const pendingScripts = [];
+            let shellChunkStatus = external_shared_js_namespaceObject_1.ShellChunkStatus.START;
+            const emitShell = (destination, buffered, markerIndex)=>{
+                const beforeMark = lifecycle.completedBody(buffered.subarray(0, markerIndex).toString('utf8'), 'shell');
+                const completedShellBefore = (0, external_helmet_js_namespaceObject.createReplaceHelemt)((0, external_helmet_js_namespaceObject.getHelmetData)(extenders))(shellBefore);
+                shellChunkStatus = external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH;
+                chunks.length = 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 external_stream_namespaceObject.Transform({
+                transform (chunk, _encoding, callback) {
+                    try {
+                        if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) this.push(chunk);
+                        else {
+                            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                            const buffered = Buffer.concat(chunks);
+                            const markerIndex = buffered.indexOf(marker);
+                            if (-1 !== markerIndex) emitShell(this, buffered, markerIndex);
                         }
-                    });
-                    const passThrough = new external_stream_namespaceObject.PassThrough();
-                    const stream = external_stream_namespaceObject.Readable.toWeb(body);
-                    resolve(stream);
-                    let processedStream = passThrough;
-                    extenders.forEach((extender)=>{
-                        if (extender.processStream) processedStream = extender.processStream(processedStream);
-                    });
-                    node_namespaceObject.pipeNodeHeadStream({
-                        source: processedStream,
-                        destination: body,
-                        context: runtimeContext,
-                        terminalMarker: external_common_js_namespaceObject.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 = runtime_utils_node_namespaceObject.storage.useContext?.();
-                        const activeDeferreds = storageContext?.activeDeferreds;
-                        const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
-                        if (entries.length > 0) {
-                            const enqueueScript = (s)=>{
-                                if (shellChunkStatus === external_shared_js_namespaceObject.ShellChunkStatus.FINISH) body.write(s);
-                                else pendingScripts.push(s);
-                            };
-                            (0, external_deferredScript_js_namespaceObject.enqueueFromEntries)(entries, config.nonce, (s)=>enqueueScript(s));
+                        if (shellChunkStatus !== external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) {
+                            const buffered = Buffer.concat(chunks);
+                            emitShell(this, buffered, buffered.length);
                         }
-                    } catch (err) {
-                        const monitors = (0, monitors_index_js_namespaceObject.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 external_stream_namespaceObject.PassThrough();
+            let processedStream = own(passThrough);
+            for (const extender of (0, external_shared_js_namespaceObject.orderSSRStreamTransforms)(extenders))if (extender.processStream) processedStream = own(extender.processStream(processedStream));
+            (0, external_stream_namespaceObject.pipeline)(processedStream, body, (error)=>{
+                if (null != error && !failed) fail(error);
+            });
+            deliver(external_stream_namespaceObject.Readable.toWeb(body));
+            reactStream.pipe(passThrough);
+            try {
+                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 (failed || body.destroyed || body.writableEnded) return;
+                    if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) body.write(script);
+                    else pendingScripts.push(script);
                 });
-            },
-            onShellError (error) {
-                node_namespaceObject.abortHeadRender(runtimeContext);
-                renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
-                (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
-                    request,
-                    ssrConfig,
-                    renderLevel,
-                    runtimeContext,
-                    entryName,
-                    config,
-                    moduleFederationCssAssets
-                }).then(({ shellAfter, shellBefore })=>{
-                    const fallbackHtml = `${shellBefore}${shellAfter}`;
-                    const readableStream = (0, external_shared_js_namespaceObject.getReadableStreamFromString)(fallbackHtml);
-                    resolve(readableStream);
-                    options?.onShellError?.(error);
-                });
-            },
-            onError (error) {
-                renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
-                reportError(error);
+            } catch (error) {
+                (0, monitors_index_js_namespaceObject.getMonitors)().error("cannot inject router data script", error);
             }
+        };
+        const renderFallback = async (error)=>{
+            if (failed || hasStartedPipe) return;
+            lifecycle.finish({
+                status: 'fallback',
+                error
+            });
+            renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+            const { shellBefore, shellAfter } = await (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
+                ...templateOptions(),
+                helmetData: (0, external_helmet_js_namespaceObject.getHelmetData)(extenders)
+            });
+            if (failed) return;
+            options.onShellError?.(error);
+            deliver((0, external_shared_js_namespaceObject_1.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 ? (0, wrapper_js_namespaceObject.wrapRuntimeComponentResolver)(rootElement, hooks) : rootElement;
+            for (const extender of extenders)processedRootElement = extender.modifyRootElement?.(processedRootElement) ?? processedRootElement;
+            lifecycle.beforeReact();
+            reactStream = renderToPipeableStream(processedRootElement, {
+                nonce: config.nonce,
+                identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX,
+                [onReady] () {
+                    startOutput().catch(fail);
+                },
+                onShellError (error) {
+                    renderFallback(error).catch(fail);
+                },
+                onError (error) {
+                    renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+                    if (!request.signal.aborted && !failed) reportError(error);
+                }
+            });
+        } catch (error) {
+            fail(error);
+        }
     });
 };
 exports.createReadableStreamFromElement = __webpack_exports__.createReadableStreamFromElement;

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,183 @@ __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 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/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, index_js_namespaceObject.getGlobalInternalRuntimeContext)().hooks;
+    const isRsc = true === (0, index_js_namespaceObject.getGlobalEnableRsc)();
+    const extenders = hooks.extendStreamSSR.call({
+        runtimeContext,
+        request,
+        resource,
+        config,
+        platform: 'web',
+        mode: 'stream',
+        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,
             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 = [];
+        let buffered = '';
+        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;
+            }
+            buffered += chunk;
+            const markerIndex = buffered.indexOf(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK);
+            if (-1 === markerIndex) return;
+            const beforeMark = lifecycle.completedBody(buffered.slice(0, markerIndex), 'shell');
+            const afterMark = buffered.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 = '';
+            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;