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

package/dist/cjs/core/server/requestHandler.js

@@ -37,29 +37,217 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createRequestHandler: ()=>createRequestHandler
+    REQUEST_END_ERROR: ()=>REQUEST_END_ERROR,
+    RESPONSE_BODY_CANCEL_ERROR: ()=>RESPONSE_BODY_CANCEL_ERROR,
+    applyRouterResult: ()=>applyRouterResult,
+    createLoaderRedirectResponse: ()=>createLoaderRedirectResponse,
+    createRequestHandler: ()=>createRequestHandler,
+    createRequestLifecycle: ()=>createRequestLifecycle,
+    finalizeRenderResponse: ()=>finalizeRenderResponse,
+    finishWithRequestLifecycle: ()=>finishWithRequestLifecycle,
+    runWithRequestLifecycleOnError: ()=>runWithRequestLifecycleOnError
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
 const request_namespaceObject = require("@modern-js/runtime-utils/universal/request");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
-const index_js_namespaceObject = require("../context/index.js");
-const runtime_js_namespaceObject = require("../context/runtime.js");
-const serverPayload_index_js_namespaceObject = require("../context/serverPayload/index.js");
+const redirect_js_namespaceObject = require("../../router/runtime/redirect.js");
+const index_js_namespaceObject = require("../context/serverPayload/index.js");
 const external_react_index_js_namespaceObject = require("../react/index.js");
 const external_constants_js_namespaceObject = require("./constants.js");
-const external_requestResponse_js_namespaceObject = require("./requestResponse.js");
-const external_routerCleanup_js_namespaceObject = require("./routerCleanup.js");
+const external_tracer_js_namespaceObject = require("./tracer.js");
 const external_utils_js_namespaceObject = require("./utils.js");
+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 (0, redirect_js_namespaceObject.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], external_tracer_js_namespaceObject.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 = (0, serverPayload_index_js_namespaceObject.getServerPayload)();
+    const serverPayload = (0, index_js_namespaceObject.getServerPayload)();
     if (void 0 !== serverPayload) return await handleRequest(request, Root, {
         ...options,
         runtimeContext: context,
         rscRoot: serverPayload
     });
-    const App = (0, index_js_namespaceObject.getGlobalRSCRoot)();
+    const App = (0, context_namespaceObject.getGlobalRSCRoot)();
     if (App) return await handleRequest(request, external_react_namespaceObject.Fragment, {
         ...options,
         runtimeContext: context,
@@ -142,19 +330,21 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
             status: -1
         };
         const activeDeferreds = new Map();
+        const deferredScriptKeys = new Map();
         return node_namespaceObject.storage.run({
             headers: headersData,
             request,
             monitors: options.monitors,
             responseProxy,
             activeDeferreds,
+            deferredScriptKeys,
             serverPayload: void 0
         }, async ()=>{
             const Root = (0, external_react_index_js_namespaceObject.createRoot)();
-            const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+            const internalRuntimeContext = (0, context_namespaceObject.getGlobalInternalRuntimeContext)();
             const hooks = internalRuntimeContext.hooks;
             const { routeManifest } = options.resource;
-            const context = (0, runtime_js_namespaceObject.getInitialContext)(false, routeManifest);
+            const context = (0, context_namespaceObject.getInitialContext)(false, routeManifest);
             const runBeforeRender = async (context)=>{
                 const result = await hooks.onBeforeRender.call(context);
                 if ("u" > typeof Response && result instanceof Response) return result;
@@ -172,33 +362,71 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
                 isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
                 basename: ssrContext.baseUrl || '/'
             };
-            const routerCleanup = (0, external_routerCleanup_js_namespaceObject.createRouterCleanup)(context, options.onError);
-            const beforeRenderResult = await (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>runBeforeRender(context));
-            await (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>{
-                (0, external_requestResponse_js_namespaceObject.applyRouterSnapshotResult)(context, options.onError);
-            });
-            if ("u" > typeof Response) {
-                const redirectResponse = await (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>(0, external_requestResponse_js_namespaceObject.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 (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>{
+            await runWithRequestLifecycleOnError(lifecycle, ()=>{
                 if (!createRequestOptions?.enableRsc) {
                     const { htmlTemplate } = options.resource;
                     options.resource.htmlTemplate = htmlTemplate.replace('</head>', `${external_constants_js_namespaceObject.CHUNK_CSS_PLACEHOLDER}</head>`);
                 }
             });
-            const response = await (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc));
-            return (0, external_routerCleanup_js_namespaceObject.finishWithRouterCleanup)(routerCleanup, ()=>(0, external_requestResponse_js_namespaceObject.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;
 };
+exports.REQUEST_END_ERROR = __webpack_exports__.REQUEST_END_ERROR;
+exports.RESPONSE_BODY_CANCEL_ERROR = __webpack_exports__.RESPONSE_BODY_CANCEL_ERROR;
+exports.applyRouterResult = __webpack_exports__.applyRouterResult;
+exports.createLoaderRedirectResponse = __webpack_exports__.createLoaderRedirectResponse;
 exports.createRequestHandler = __webpack_exports__.createRequestHandler;
+exports.createRequestLifecycle = __webpack_exports__.createRequestLifecycle;
+exports.finalizeRenderResponse = __webpack_exports__.finalizeRenderResponse;
+exports.finishWithRequestLifecycle = __webpack_exports__.finishWithRequestLifecycle;
+exports.runWithRequestLifecycleOnError = __webpack_exports__.runWithRequestLifecycleOnError;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createRequestHandler"
+    "REQUEST_END_ERROR",
+    "RESPONSE_BODY_CANCEL_ERROR",
+    "applyRouterResult",
+    "createLoaderRedirectResponse",
+    "createRequestHandler",
+    "createRequestLifecycle",
+    "finalizeRenderResponse",
+    "finishWithRequestLifecycle",
+    "runWithRequestLifecycleOnError"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -43,8 +43,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;
@@ -102,7 +102,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
             const styles = await Promise.all(cssChunks.map(async (chunk)=>{
                 const link = `<link href="${chunk}" rel="stylesheet" />`;
                 if ((0, external_utils_js_namespaceObject.checkIsNode)() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
-                return link;
+                else return link;
             }));
             return `${styles.join('')}`;
         }

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

@@ -36,8 +36,8 @@ const external_shared_js_namespaceObject = require("../shared.js");
 const external_utils_js_namespaceObject = require("../utils.js");
 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/cjs/core/server/stream/createReadableStream.js

@@ -30,24 +30,26 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createReadableStreamFromElement: ()=>createReadableStreamFromElement
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 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_string_decoder_namespaceObject = require("string_decoder");
 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 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_deferredScriptOutputCoordinator_js_namespaceObject = require("./deferredScriptOutputCoordinator.js");
 const external_shared_js_namespaceObject_1 = require("./shared.js");
 const external_template_js_namespaceObject = require("./template.js");
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
     const { renderToPipeableStream } = await import("react-dom/server");
     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 hooks = (0, context_namespaceObject.getGlobalInternalRuntimeContext)().hooks;
+    const isRsc = true === (0, context_namespaceObject.getGlobalEnableRsc)();
     const extenders = hooks.extendStreamSSR.call({
         runtimeContext,
         request,
@@ -55,6 +57,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         config,
         platform: 'node',
         mode: 'stream',
+        monitors: (0, index_js_namespaceObject.getMonitors)(),
         isRsc,
         terminalMarker: external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK
     }) || [];
@@ -153,29 +156,42 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             });
             if (failed) return;
             const chunks = [];
+            let bufferedLength = 0;
             const marker = Buffer.from(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK);
+            let markerTail = Buffer.alloc(0);
+            const decoder = new external_string_decoder_namespaceObject.StringDecoder('utf8');
             const pendingScripts = [];
+            let deferredResolversComplete = Promise.resolve();
             let shellChunkStatus = external_shared_js_namespaceObject_1.ShellChunkStatus.START;
-            const emitShell = (destination, buffered, markerIndex)=>{
+            const emitShell = (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}`);
+                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 external_stream_namespaceObject.Transform({
                 transform (chunk, _encoding, callback) {
                     try {
-                        if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) this.push(chunk);
+                        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                        if (shellChunkStatus === external_shared_js_namespaceObject_1.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) {
@@ -186,14 +202,27 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                     try {
                         if (shellChunkStatus !== external_shared_js_namespaceObject_1.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 external_deferredScriptOutputCoordinator_js_namespaceObject.DeferredScriptOutputCoordinator((content)=>{
+                body.push(content);
+            });
+            body.once('close', ()=>coordinator.abort());
             own(body);
             const passThrough = new external_stream_namespaceObject.PassThrough();
             let processedStream = own(passThrough);
@@ -204,15 +233,17 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             deliver(external_stream_namespaceObject.Readable.toWeb(body));
             reactStream.pipe(passThrough);
             try {
-                const activeDeferreds = node_namespaceObject.storage.useContext?.()?.activeDeferreds;
+                const storageContext = node_namespaceObject.storage.useContext?.();
+                const activeDeferreds = storageContext?.activeDeferreds;
+                const deferredScriptKeys = storageContext?.deferredScriptKeys;
                 const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
-                (0, external_deferredScript_js_namespaceObject.enqueueFromEntries)(entries, config.nonce, (script)=>{
+                if (entries.length > 0) deferredResolversComplete = (0, external_deferredScript_js_namespaceObject.enqueueFromEntries)(entries, deferredScriptKeys, config.nonce, (script)=>{
                     if (failed || body.destroyed || body.writableEnded) return;
-                    if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) body.write(script);
+                    if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) coordinator.enqueueResolver(script);
                     else pendingScripts.push(script);
                 });
             } catch (error) {
-                (0, monitors_index_js_namespaceObject.getMonitors)().error("cannot inject router data script", error);
+                (0, index_js_namespaceObject.getMonitors)().error("cannot inject router data script", error);
             }
         };
         const renderFallback = async (error)=>{
@@ -245,6 +276,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             reactStream = renderToPipeableStream(processedRootElement, {
                 nonce: config.nonce,
                 identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX,
+                progressiveChunkSize: external_shared_js_namespaceObject_1.SHELL_PROGRESSIVE_CHUNK_SIZE,
                 [onReady] () {
                     startOutput().catch(fail);
                 },