@bleedingdev/modern-js-runtime 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

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

@@ -1,16 +1,196 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
+import { getGlobalInternalRuntimeContext, getGlobalRSCRoot, getInitialContext } from "@modern-js/runtime/context";
 import { storage } from "@modern-js/runtime-utils/node";
 import { getPathname, parseCookie, parseHeaders, parseQuery } from "@modern-js/runtime-utils/universal/request";
 import react, { Fragment } from "react";
-import { getGlobalInternalRuntimeContext, getGlobalRSCRoot } from "../context/index.mjs";
-import { getInitialContext } from "../context/runtime.mjs";
+import { handleRSCRedirect } from "../../router/runtime/redirect.mjs";
 import { getServerPayload } from "../context/serverPayload/index.mjs";
 import { createRoot } from "../react/index.mjs";
 import { CHUNK_CSS_PLACEHOLDER } from "./constants.mjs";
-import { applyRouterSnapshotResult, createLoaderRedirectResponse, finalizeRenderResponse } from "./requestResponse.mjs";
-import { createRouterCleanup, finishWithRouterCleanup, runWithRouterCleanupOnError } from "./routerCleanup.mjs";
+import { SSRErrors } from "./tracer.mjs";
 import { getSSRConfigByEntry, getSSRMode } from "./utils.mjs";
+const REQUEST_END_ERROR = 'An error occurs during request lifecycle completion';
+const RESPONSE_BODY_CANCEL_ERROR = 'An error occurs while cancelling a discarded response body';
+async function runWithRequestLifecycleOnError(lifecycle, callback) {
+    try {
+        return await callback();
+    } catch (error) {
+        await lifecycle.run({
+            status: 'error',
+            error
+        });
+        throw error;
+    }
+}
+async function finishWithRequestLifecycle(lifecycle, callback) {
+    try {
+        return await callback();
+    } catch (error) {
+        if (!lifecycle.deferred) await lifecycle.run({
+            status: 'error',
+            error
+        });
+        throw error;
+    } finally{
+        if (!lifecycle.deferred) await lifecycle.run();
+    }
+}
+function createRequestLifecycle(onEnd, onError) {
+    let deferred = false;
+    let finished;
+    const run = (terminal = {
+        status: 'complete'
+    })=>{
+        finished ??= Promise.resolve().then(()=>onEnd(terminal)).catch((error)=>{
+            onError(error, REQUEST_END_ERROR);
+        });
+        return finished;
+    };
+    const deferUntilBodyDone = (response)=>{
+        const { body } = response;
+        if (!body) return response;
+        deferred = true;
+        if (body.locked) throw new TypeError('Cannot observe a locked response body before request completion');
+        let cancelled = false;
+        const reader = body.getReader();
+        const wrappedBody = new ReadableStream({
+            async pull (controller) {
+                let result;
+                try {
+                    result = await reader.read();
+                } catch (error) {
+                    if (!cancelled) {
+                        await run({
+                            status: 'error',
+                            error
+                        });
+                        controller.error(error);
+                    }
+                    return;
+                }
+                if (cancelled) return;
+                if (result.done) {
+                    await run();
+                    if (!cancelled) controller.close();
+                    return;
+                }
+                controller.enqueue(result.value);
+            },
+            async cancel (reason) {
+                cancelled = true;
+                try {
+                    await reader.cancel(reason);
+                } catch  {}
+                await run({
+                    status: 'cancelled',
+                    reason
+                });
+            }
+        });
+        return new Response(wrappedBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+    };
+    const discardBody = async (response, terminal = {
+        status: 'discarded'
+    })=>{
+        const { body } = response;
+        if (!body) return void await run(terminal);
+        deferred = true;
+        if (body.locked) throw new TypeError('Cannot discard a locked response body before request completion');
+        try {
+            await body.cancel('Response body discarded during finalization');
+        } catch (error) {
+            await run('error' === terminal.status ? terminal : {
+                status: 'error',
+                error
+            });
+            if ('error' === terminal.status) onError(error, RESPONSE_BODY_CANCEL_ERROR);
+            throw error;
+        }
+        await run(terminal);
+    };
+    return {
+        get deferred () {
+            return deferred;
+        },
+        run,
+        deferUntilBodyDone,
+        discardBody
+    };
+}
+const isRedirectStatus = (status)=>301 === status || 302 === status || 303 === status || 307 === status || 308 === status;
+const isNullBodyStatus = (status)=>204 === status || 205 === status || 304 === status;
+const getRedirectLocation = (headers)=>{
+    const location = headers.get('Location');
+    return null !== location && '' !== location && URL.canParse(location, 'http://localhost') ? location : void 0;
+};
+const processRedirect = (headers, status, ctx)=>{
+    headers.delete('content-length');
+    headers.delete('transfer-encoding');
+    if (ctx.enableRsc && ctx.isRSCNavigation) return handleRSCRedirect(headers, ctx.basename, status);
+    return new Response(null, {
+        status,
+        headers
+    });
+};
+const applyRouterResult = (context, routerResult, onError)=>{
+    const routerStatusCode = routerResult?.statusCode;
+    if (void 0 !== routerStatusCode && 0 !== routerStatusCode && !Number.isNaN(routerStatusCode) && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
+    const errors = Object.values(routerResult?.errors || {});
+    if (errors.length > 0) onError(errors[0], SSRErrors.LOADER_ERROR);
+};
+const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
+    if (void 0 === beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
+    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
+    const redirectUrl = getRedirectLocation(beforeRenderResult.headers);
+    if (void 0 === redirectUrl) return;
+    return processRedirect(new Headers(beforeRenderResult.headers), beforeRenderResult.status, redirectCtx);
+};
+const finalizeRenderResponse = async (response, responseProxy, redirectCtx, lifecycle)=>{
+    try {
+        const proxyHeaders = new Headers(responseProxy.headers);
+        if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && void 0 !== getRedirectLocation(proxyHeaders)) {
+            await lifecycle.discardBody(response);
+            return processRedirect(proxyHeaders, responseProxy.status, redirectCtx);
+        }
+        const headers = new Headers(response.headers);
+        Object.entries(responseProxy.headers).forEach(([key, value])=>{
+            headers.set(key, value);
+        });
+        if (-1 !== responseProxy.status) {
+            if (isNullBodyStatus(responseProxy.status)) {
+                await lifecycle.discardBody(response);
+                headers.delete('content-length');
+                headers.delete('transfer-encoding');
+                return new Response(null, {
+                    status: responseProxy.status,
+                    headers
+                });
+            }
+            if (response.body?.locked) lifecycle.deferUntilBodyDone(response);
+            return lifecycle.deferUntilBodyDone(new Response(response.body, {
+                status: responseProxy.status,
+                headers
+            }));
+        }
+        Object.entries(responseProxy.headers).forEach(([key, value])=>{
+            response.headers.set(key, value);
+        });
+        return lifecycle.deferUntilBodyDone(response);
+    } catch (error) {
+        if (!lifecycle.deferred) try {
+            await lifecycle.discardBody(response, {
+                status: 'error',
+                error
+            });
+        } catch  {}
+        throw error;
+    }
+};
 async function handleRSCRequest(request, Root, context, options, handleRequest) {
     const serverPayload = getServerPayload();
     if (void 0 !== serverPayload) return await handleRequest(request, Root, {
@@ -101,12 +281,14 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
             status: -1
         };
         const activeDeferreds = new Map();
+        const deferredScriptKeys = new Map();
         return storage.run({
             headers: headersData,
             request,
             monitors: options.monitors,
             responseProxy,
             activeDeferreds,
+            deferredScriptKeys,
             serverPayload: void 0
         }, async ()=>{
             const Root = createRoot();
@@ -131,28 +313,50 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
                 isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
                 basename: ssrContext.baseUrl || '/'
             };
-            const routerCleanup = createRouterCleanup(context, options.onError);
-            const beforeRenderResult = await runWithRouterCleanupOnError(routerCleanup, ()=>runBeforeRender(context));
-            await runWithRouterCleanupOnError(routerCleanup, ()=>{
-                applyRouterSnapshotResult(context, options.onError);
-            });
-            if ("u" > typeof Response) {
-                const redirectResponse = await runWithRouterCleanupOnError(routerCleanup, ()=>createLoaderRedirectResponse(beforeRenderResult, redirectCtx));
-                if (redirectResponse) {
-                    await routerCleanup.run();
-                    return redirectResponse;
-                }
+            const lifecycle = createRequestLifecycle(async (terminal)=>{
+                await hooks.onRequestEnd?.call({
+                    runtimeContext: context,
+                    terminal
+                });
+            }, options.onError);
+            const beforeRenderResult = await runWithRequestLifecycleOnError(lifecycle, ()=>runBeforeRender(context));
+            let redirectResponse;
+            try {
+                const prepared = {
+                    runtimeContext: context,
+                    routerResult: context.routerContext
+                };
+                const result = await hooks.onRenderPrepared?.call(prepared) ?? prepared;
+                applyRouterResult(context, result.routerResult, options.onError);
+                if ("u" > typeof Response) redirectResponse = createLoaderRedirectResponse(beforeRenderResult, redirectCtx);
+            } catch (error) {
+                if (beforeRenderResult) try {
+                    await lifecycle.discardBody(beforeRenderResult, {
+                        status: 'error',
+                        error
+                    });
+                } catch  {}
+                else await lifecycle.run({
+                    status: 'error',
+                    error
+                });
+                throw error;
+            }
+            if (redirectResponse) {
+                const response = redirectResponse;
+                if (beforeRenderResult?.body && response !== beforeRenderResult) await lifecycle.discardBody(beforeRenderResult);
+                return finishWithRequestLifecycle(lifecycle, ()=>lifecycle.deferUntilBodyDone(response));
             }
-            await runWithRouterCleanupOnError(routerCleanup, ()=>{
+            await runWithRequestLifecycleOnError(lifecycle, ()=>{
                 if (!createRequestOptions?.enableRsc) {
                     const { htmlTemplate } = options.resource;
                     options.resource.htmlTemplate = htmlTemplate.replace('</head>', `${CHUNK_CSS_PLACEHOLDER}</head>`);
                 }
             });
-            const response = await runWithRouterCleanupOnError(routerCleanup, ()=>renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc));
-            return finishWithRouterCleanup(routerCleanup, ()=>finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup));
+            const response = await runWithRequestLifecycleOnError(lifecycle, ()=>renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc));
+            return finishWithRequestLifecycle(lifecycle, ()=>finalizeRenderResponse(response, responseProxy, redirectCtx, lifecycle));
         });
     };
     return requestHandler;
 };
-export { createRequestHandler };
+export { REQUEST_END_ERROR, RESPONSE_BODY_CANCEL_ERROR, applyRouterResult, createLoaderRedirectResponse, createRequestHandler, createRequestLifecycle, finalizeRenderResponse, finishWithRequestLifecycle, runWithRequestLifecycleOnError };

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

@@ -15,8 +15,8 @@ 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, lifecycle, helmetData } = options;
@@ -74,7 +74,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
             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

@@ -5,8 +5,8 @@ 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, lifecycle, helmetData } = options;

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

@@ -1,16 +1,18 @@
 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, finished, pipeline } from "stream";
+import { StringDecoder } from "string_decoder";
 import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common.mjs";
 import { RenderLevel } from "../../constants.mjs";
-import { getGlobalEnableRsc, 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 { DeferredScriptOutputCoordinator } from "./deferredScriptOutputCoordinator.mjs";
+import { SHELL_PROGRESSIVE_CHUNK_SIZE, ShellChunkStatus, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
 import { getTemplates } from "./template.mjs";
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
     const { renderToPipeableStream } = await import("react-dom/server");
@@ -24,6 +26,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         config,
         platform: 'node',
         mode: 'stream',
+        monitors: getMonitors(),
         isRsc,
         terminalMarker: ESCAPED_SHELL_STREAM_END_MARK
     }) || [];
@@ -122,29 +125,42 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             });
             if (failed) return;
             const chunks = [];
+            let bufferedLength = 0;
             const marker = Buffer.from(ESCAPED_SHELL_STREAM_END_MARK);
+            let markerTail = Buffer.alloc(0);
+            const decoder = new StringDecoder('utf8');
             const pendingScripts = [];
+            let deferredResolversComplete = Promise.resolve();
             let shellChunkStatus = ShellChunkStatus.START;
-            const emitShell = (destination, buffered, markerIndex)=>{
+            const emitShell = (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;
-                destination.push(`${completedShellBefore}${beforeMark}${shellAfter}`);
+                bufferedLength = 0;
+                coordinator.writeReact(`${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);
+                if (afterMark.length > 0) coordinator.writeReact(decoder.write(afterMark));
+                coordinator.markShellFinished();
+                for (const script of pendingScripts)coordinator.enqueueResolver(script);
                 pendingScripts.length = 0;
             };
             const body = new Transform({
                 transform (chunk, _encoding, callback) {
                     try {
-                        if (shellChunkStatus === ShellChunkStatus.FINISH) this.push(chunk);
+                        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                        if (shellChunkStatus === ShellChunkStatus.FINISH) coordinator.writeReact(decoder.write(bytes));
                         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 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(Buffer.concat(chunks, bufferedLength), windowStart + windowIndex);
                         }
                         callback();
                     } catch (error) {
@@ -155,14 +171,27 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                     try {
                         if (shellChunkStatus !== ShellChunkStatus.FINISH) {
                             const buffered = Buffer.concat(chunks);
-                            emitShell(this, buffered, buffered.length);
+                            emitShell(buffered, buffered.length);
                         }
-                        callback();
+                        const trailing = decoder.end();
+                        if (trailing) coordinator.writeReact(trailing);
+                        deferredResolversComplete.then(()=>{
+                            try {
+                                coordinator.finish();
+                                callback();
+                            } catch (error) {
+                                callback(error instanceof Error ? error : new Error(String(error)));
+                            }
+                        }, (error)=>callback(error instanceof Error ? error : new Error(String(error))));
                     } catch (error) {
                         callback(error instanceof Error ? error : new Error(String(error)));
                     }
                 }
             });
+            const coordinator = new DeferredScriptOutputCoordinator((content)=>{
+                body.push(content);
+            });
+            body.once('close', ()=>coordinator.abort());
             own(body);
             const passThrough = new PassThrough();
             let processedStream = own(passThrough);
@@ -173,11 +202,13 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             deliver(Readable.toWeb(body));
             reactStream.pipe(passThrough);
             try {
-                const activeDeferreds = storage.useContext?.()?.activeDeferreds;
+                const storageContext = storage.useContext?.();
+                const activeDeferreds = storageContext?.activeDeferreds;
+                const deferredScriptKeys = storageContext?.deferredScriptKeys;
                 const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
-                enqueueFromEntries(entries, config.nonce, (script)=>{
+                if (entries.length > 0) deferredResolversComplete = enqueueFromEntries(entries, deferredScriptKeys, config.nonce, (script)=>{
                     if (failed || body.destroyed || body.writableEnded) return;
-                    if (shellChunkStatus === ShellChunkStatus.FINISH) body.write(script);
+                    if (shellChunkStatus === ShellChunkStatus.FINISH) coordinator.enqueueResolver(script);
                     else pendingScripts.push(script);
                 });
             } catch (error) {
@@ -214,6 +245,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             reactStream = renderToPipeableStream(processedRootElement, {
                 nonce: config.nonce,
                 identifierPrefix: SSR_HYDRATION_ID_PREFIX,
+                progressiveChunkSize: SHELL_PROGRESSIVE_CHUNK_SIZE,
                 [onReady] () {
                     startOutput().catch(fail);
                 },

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

@@ -1,15 +1,17 @@
 import "node:module";
 import { renderSSRStream } from "@modern-js/render/ssr";
+import { getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { storage } from "@modern-js/runtime-utils/node";
 import react from "react";
 import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common.mjs";
 import { RenderLevel } from "../../constants.mjs";
-import { getGlobalEnableRsc, 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 { DeferredScriptOutputCoordinator } from "./deferredScriptOutputCoordinator.mjs";
+import { SHELL_PROGRESSIVE_CHUNK_SIZE, ShellChunkStatus, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
 import { getTemplates } from "./template.mjs";
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
     const { htmlTemplate, runtimeContext, config, ssrConfig, entryName, resource, rscManifest, rscRoot } = options;
@@ -22,6 +24,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         config,
         platform: 'web',
         mode: 'stream',
+        monitors: getMonitors(),
         isRsc,
         terminalMarker: ESCAPED_SHELL_STREAM_END_MARK
     }) || [];
@@ -34,6 +37,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
     let pendingSource;
     let bodyOpen = true;
     let bodyPipe;
+    let coordinator;
     const templateOptions = {
         runtimeContext,
         ssrConfig,
@@ -52,6 +56,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             request,
             signal: request.signal,
             nonce: config.nonce,
+            progressiveChunkSize: SHELL_PROGRESSIVE_CHUNK_SIZE,
             rscManifest,
             rscRoot: rscRoot,
             routes: runtimeContext.routes,
@@ -80,66 +85,87 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         const decoder = new TextDecoder();
         const encoder = new TextEncoder();
         const pendingScripts = [];
-        let buffered = '';
+        const buffered = [];
+        let bufferedLength = 0;
+        let markerTail = '';
         let shellChunkStatus = ShellChunkStatus.START;
         let bodyController;
-        const emit = (chunk, controller)=>{
+        let deferredResolversComplete = Promise.resolve();
+        coordinator = new DeferredScriptOutputCoordinator((content)=>{
+            if (!bodyOpen) return;
+            try {
+                bodyController.enqueue(encoder.encode(content));
+            } catch  {
+                bodyOpen = false;
+            }
+        });
+        const emit = (chunk)=>{
             if (shellChunkStatus === ShellChunkStatus.FINISH) {
-                if (chunk.length > 0) controller.enqueue(encoder.encode(chunk));
+                if (chunk.length > 0) coordinator?.writeReact(chunk);
+                return;
+            }
+            const window = markerTail + chunk;
+            const windowIndex = window.indexOf(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 - ESCAPED_SHELL_STREAM_END_MARK.length + 1));
                 return;
             }
-            buffered += chunk;
-            const markerIndex = buffered.indexOf(ESCAPED_SHELL_STREAM_END_MARK);
-            if (-1 === markerIndex) return;
-            const beforeMark = lifecycle.completedBody(buffered.slice(0, markerIndex), 'shell');
-            const afterMark = buffered.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
+            const shell = buffered.join('');
+            const beforeMark = lifecycle.completedBody(shell.slice(0, markerIndex), 'shell');
+            const afterMark = shell.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
             const completedShellBefore = createReplaceHelemt(getHelmetData(extenders))(shellBefore);
             shellChunkStatus = 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));
+            buffered.length = 0;
+            coordinator?.writeReact(`${completedShellBefore}${beforeMark}${shellAfter}`);
+            if (afterMark.length > 0) coordinator?.writeReact(afterMark);
+            coordinator?.markShellFinished();
+            for (const script of pendingScripts)coordinator?.enqueueResolver(script);
             pendingScripts.length = 0;
         };
         const body = new TransformStream({
             start (controller) {
                 bodyController = controller;
             },
-            transform (chunk, controller) {
+            transform (chunk) {
                 emit(decoder.decode(chunk, {
                     stream: true
-                }), controller);
+                }));
             },
-            flush (controller) {
-                bodyOpen = false;
-                emit(decoder.decode(), controller);
+            async flush () {
+                emit(decoder.decode());
                 if (shellChunkStatus !== ShellChunkStatus.FINISH) throw new Error('React SSR stream ended before the shell marker');
+                await deferredResolversComplete;
+                coordinator?.finish();
+                bodyOpen = false;
             }
         });
         bodyPipe = pendingSource.pipeTo(body.writable);
         bodyPipe.catch(()=>{});
         pendingSource = body.readable;
-        const activeDeferreds = storage.useContext?.()?.activeDeferreds;
+        const storageContext = storage.useContext?.();
+        const activeDeferreds = storageContext?.activeDeferreds;
+        const deferredScriptKeys = storageContext?.deferredScriptKeys;
         const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
-        enqueueFromEntries(entries, config.nonce, (script)=>{
+        if (entries.length > 0) deferredResolversComplete = enqueueFromEntries(entries, deferredScriptKeys, config.nonce, (script)=>{
             if (!bodyOpen) return;
-            if (shellChunkStatus === ShellChunkStatus.FINISH) try {
-                bodyController.enqueue(encoder.encode(script));
-            } catch  {
-                bodyOpen = false;
-            }
+            if (shellChunkStatus === ShellChunkStatus.FINISH) coordinator?.enqueueResolver(script);
             else pendingScripts.push(script);
         });
         return observeSSRStream(pendingSource, {
             lifecycle,
             async onError (error) {
                 bodyOpen = false;
+                coordinator?.abort();
                 await bodyPipe?.catch(()=>{});
                 reportError(error);
             },
             signal: request.signal,
             async onCancel (reason) {
                 bodyOpen = false;
+                coordinator?.abort();
                 await bodyPipe?.catch((error)=>{
                     if (error !== reason) throw error;
                 });
@@ -148,6 +174,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         });
     } catch (error) {
         bodyOpen = false;
+        coordinator?.abort();
         if (void 0 !== pendingSource) try {
             await pendingSource.cancel(error);
             await bodyPipe?.catch(()=>{});

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

@@ -45,23 +45,29 @@ function buildDeferredDataScript(nonce, args) {
     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>${runRouterDataFnStr}</script>`;
 }
-function enqueueFromEntries(entries, nonce, emit) {
+function enqueueFromEntries(entries, deferredScriptKeys, nonce, emit) {
+    const pendingResolvers = [];
     entries.forEach(([routeId, value])=>{
         if (!isDeferredDataLike(value)) return;
-        const pendingKeys = new Set(value.pendingKeys ?? []);
-        pendingKeys.forEach((key)=>{
+        const serializedKeys = void 0 !== deferredScriptKeys ? deferredScriptKeys.get(routeId) ?? [] : value.pendingKeys ?? [];
+        serializedKeys.forEach((key)=>{
             const tracked = value.data?.[key];
-            if (isPromiseLike(tracked)) tracked.then((val)=>emit(buildDeferredDataScript(nonce, [
+            if (isPromiseLike(tracked)) pendingResolvers.push(Promise.resolve(tracked).then((val)=>{
+                emit(buildDeferredDataScript(nonce, [
                     routeId,
                     key,
                     val
-                ])), (err)=>emit(buildDeferredDataScript(nonce, [
+                ]));
+            }, (err)=>{
+                emit(buildDeferredDataScript(nonce, [
                     routeId,
                     key,
                     void 0,
                     toErrorInfo(err)
-                ])));
+                ]));
+            }));
         });
     });
+    return Promise.all(pendingResolvers).then(()=>void 0);
 }
 export { buildDeferredDataScript, enqueueFromEntries, escapeAttr, isDeferredDataLike, isPromiseLike, isRecord, toErrorInfo };