@bleedingdev/modern-js-render 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/dist/esm/client.mjs

@@ -1 +1 @@
-export { ElementsContext, RSCServerSlot, ResetRootContext, RscClientRoot, ServerElementsProvider, callServer, createFromFetch, createFromReadableStream, createServerReference, rscStream, setServerCallback } from "./341.mjs";
+export { ElementsContext, RSCServerSlot, ResetRootContext, RscClientRoot, ServerElementsProvider, callServer, createFromFetch, createFromReadableStream, createServerReference, rscStream, setServerCallback } from "./341~0.mjs";

package/dist/esm/rsc.mjs

@@ -1,63 +1,96 @@
-import { injectRSCPayload } from "@modern-js/runtime-extensions/rsc-html-stream";
 import { decodeReply as server_node_decodeReply, loadServerAction as server_node_loadServerAction, registerClientReference, registerServerReference, renderToReadableStream } from "react-server-dom-rspack/server.node";
 const server_encoder = new TextEncoder();
 const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
-function server_injectRSCPayload(rscStream, { injectClosingTags = true }) {
-    if (injectClosingTags) return injectRSCPayload(rscStream);
+function injectRSCPayload(rscStream, { injectClosingTags = true }) {
     const decoder = new TextDecoder();
-    let resolveFlightDataPromise;
-    const flightDataPromise = new Promise((resolve)=>resolveFlightDataPromise = resolve);
-    let startedRSC = false;
-    const buffered = [];
-    let timeout = null;
-    function flushBufferedChunks(controller) {
-        let buf = '';
-        for (const chunk of buffered)buf += decoder.decode(chunk, {
-            stream: true
-        });
-        if (closingTagsPattern.test(buf)) buf = buf.replace(closingTagsPattern, '');
-        if (buf) controller.enqueue(server_encoder.encode(buf));
-        buffered.length = 0;
-        timeout = null;
+    let pendingHtml = '';
+    let closingBody = false;
+    let closingHtml = false;
+    let closingProbe = '';
+    let flightReader;
+    let flightPromise;
+    function startFlight(controller) {
+        if (!flightPromise) {
+            flightReader = rscStream.getReader();
+            flightPromise = writeRSCStream(flightReader, controller).finally(()=>{
+                flightReader = void 0;
+            });
+            flightPromise.catch((error)=>controller.error(error));
+        }
+        return flightPromise;
     }
-    return new TransformStream({
+    async function writeHtml(value, controller) {
+        let html = pendingHtml + value;
+        pendingHtml = '';
+        if (!closingBody) {
+            const bodyIndex = html.search(/<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?$/i);
+            if (-1 !== bodyIndex) {
+                controller.enqueue(server_encoder.encode(html.slice(0, bodyIndex)));
+                await startFlight(controller);
+                closingBody = true;
+                html = html.slice(bodyIndex);
+            }
+        }
+        if (closingBody) {
+            if (!injectClosingTags) {
+                pendingHtml = html;
+                return;
+            }
+            closingHtml ||= /<\/html>/i.test(closingProbe + html);
+            closingProbe = (closingProbe + html).slice(-6);
+        } else {
+            const tagIndex = html.lastIndexOf('<');
+            if (tagIndex > html.lastIndexOf('>')) {
+                pendingHtml = html.slice(tagIndex);
+                html = html.slice(0, tagIndex);
+            }
+        }
+        if (html) {
+            controller.enqueue(server_encoder.encode(html));
+            startFlight(controller);
+        }
+    }
+    const transformer = {
         transform (chunk, controller) {
-            buffered.push(chunk);
-            if (timeout) return;
-            timeout = setTimeout(async ()=>{
-                flushBufferedChunks(controller);
-                if (!startedRSC) {
-                    startedRSC = true;
-                    writeRSCStream(rscStream, controller).catch((err)=>controller.error(err)).then(()=>resolveFlightDataPromise());
-                }
-            }, 0);
+            return writeHtml(decoder.decode(chunk, {
+                stream: true
+            }), controller);
         },
         async flush (controller) {
-            await flightDataPromise;
-            if (timeout) {
-                clearTimeout(timeout);
-                flushBufferedChunks(controller);
-            }
-            const remaining = decoder.decode();
-            if (remaining) controller.enqueue(server_encoder.encode(remaining));
-            if (injectClosingTags) controller.enqueue(server_encoder.encode('</body></html>'));
+            await writeHtml(decoder.decode(), controller);
+            await startFlight(controller);
+            const tail = injectClosingTags ? pendingHtml : pendingHtml.replace(closingTagsPattern, '');
+            if (tail) controller.enqueue(server_encoder.encode(tail));
+            if (injectClosingTags && !closingHtml) controller.enqueue(server_encoder.encode(closingBody ? '</html>' : '</body></html>'));
+        },
+        cancel (reason) {
+            return flightReader ? flightReader.cancel(reason) : rscStream.cancel(reason);
         }
-    });
+    };
+    return new TransformStream(transformer);
 }
-async function writeRSCStream(rscStream, controller) {
+async function writeRSCStream(reader, controller) {
     const decoder = new TextDecoder('utf-8', {
-        fatal: true
+        fatal: true,
+        ignoreBOM: true
     });
-    for await (const chunk of rscStream)try {
-        writeChunk(JSON.stringify(decoder.decode(chunk, {
-            stream: true
-        })), controller);
-    } catch (err) {
-        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
+    try {
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) return;
+            let chunk;
+            try {
+                chunk = JSON.stringify(decoder.decode(value));
+            } catch  {
+                let binary = '';
+                for (const byte of value)binary += String.fromCharCode(byte);
+                chunk = `Uint8Array.from(atob(${JSON.stringify(btoa(binary))}), m => m.codePointAt(0))`;
+            }
+            writeChunk(chunk, controller);
+        }
+    } finally{
+        reader.releaseLock();
     }
-    const remaining = decoder.decode();
-    if (remaining.length) writeChunk(JSON.stringify(remaining), controller);
 }
 function writeChunk(chunk, controller) {
     controller.enqueue(server_encoder.encode(`<script>${escapeScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`));
@@ -76,35 +109,34 @@ function injectCSS(cssFiles, { injectClosingTags = true } = {}) {
     });
     const decoder = new TextDecoder();
     const headTrailer = '</head>';
-    const buffered = [];
-    let timeout = null;
+    let pendingHtml = '';
     let cssInjected = false;
     const cssLinks = cssFiles.map((css)=>`<link href="${css}" rel="stylesheet" />`).join('');
-    function flushBufferedChunks(controller) {
-        for (const chunk of buffered){
-            let buf = decoder.decode(chunk);
-            if (!cssInjected && buf.includes(headTrailer)) {
-                buf = buf.replace(headTrailer, `${cssLinks}${headTrailer}`);
+    function writeHtml(value, controller, final = false) {
+        let html = pendingHtml + value;
+        pendingHtml = '';
+        if (!cssInjected) {
+            const headIndex = html.toLowerCase().indexOf(headTrailer);
+            if (-1 !== headIndex) {
+                html = html.slice(0, headIndex) + cssLinks + html.slice(headIndex);
                 cssInjected = true;
+            } else if (!final) {
+                let retain = Math.min(headTrailer.length - 1, html.length);
+                while(retain && !html.toLowerCase().endsWith(headTrailer.slice(0, retain)))retain--;
+                pendingHtml = html.slice(html.length - retain);
+                html = html.slice(0, html.length - retain);
             }
-            controller.enqueue(server_encoder.encode(buf));
         }
-        buffered.length = 0;
-        timeout = null;
+        if (html) controller.enqueue(server_encoder.encode(html));
     }
     return new TransformStream({
         transform (chunk, controller) {
-            buffered.push(chunk);
-            if (timeout) return;
-            timeout = setTimeout(()=>{
-                flushBufferedChunks(controller);
-            }, 0);
+            writeHtml(decoder.decode(chunk, {
+                stream: true
+            }), controller);
         },
-        async flush (controller) {
-            if (timeout) {
-                clearTimeout(timeout);
-                flushBufferedChunks(controller);
-            }
+        flush (controller) {
+            writeHtml(decoder.decode(), controller, true);
             if (!cssInjected) controller.enqueue(server_encoder.encode(cssLinks));
             if (injectClosingTags) controller.enqueue(server_encoder.encode('</body></html>'));
         }
@@ -125,7 +157,7 @@ const createRenderCSRWithRSC = (renderRsc)=>async (options)=>{
         });
         const stream = htmlStream.pipeThrough(injectCSS(cssFiles, {
             injectClosingTags: false
-        })).pipeThrough(server_injectRSCPayload(rscPayloadStream, {
+        })).pipeThrough(injectRSCPayload(rscPayloadStream, {
             injectClosingTags: true
         }));
         return new Response(stream, {

package/dist/esm/rscWorker.mjs

@@ -1,63 +1,96 @@
 import { decodeReply as server_edge_decodeReply, loadServerAction as server_edge_loadServerAction, registerClientReference, registerServerReference, renderToReadableStream } from "react-server-dom-rspack/server.edge";
-import { injectRSCPayload } from "@modern-js/runtime-extensions/rsc-html-stream";
 const server_encoder = new TextEncoder();
 const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
-function server_injectRSCPayload(rscStream, { injectClosingTags = true }) {
-    if (injectClosingTags) return injectRSCPayload(rscStream);
+function injectRSCPayload(rscStream, { injectClosingTags = true }) {
     const decoder = new TextDecoder();
-    let resolveFlightDataPromise;
-    const flightDataPromise = new Promise((resolve)=>resolveFlightDataPromise = resolve);
-    let startedRSC = false;
-    const buffered = [];
-    let timeout = null;
-    function flushBufferedChunks(controller) {
-        let buf = '';
-        for (const chunk of buffered)buf += decoder.decode(chunk, {
-            stream: true
-        });
-        if (closingTagsPattern.test(buf)) buf = buf.replace(closingTagsPattern, '');
-        if (buf) controller.enqueue(server_encoder.encode(buf));
-        buffered.length = 0;
-        timeout = null;
+    let pendingHtml = '';
+    let closingBody = false;
+    let closingHtml = false;
+    let closingProbe = '';
+    let flightReader;
+    let flightPromise;
+    function startFlight(controller) {
+        if (!flightPromise) {
+            flightReader = rscStream.getReader();
+            flightPromise = writeRSCStream(flightReader, controller).finally(()=>{
+                flightReader = void 0;
+            });
+            flightPromise.catch((error)=>controller.error(error));
+        }
+        return flightPromise;
     }
-    return new TransformStream({
+    async function writeHtml(value, controller) {
+        let html = pendingHtml + value;
+        pendingHtml = '';
+        if (!closingBody) {
+            const bodyIndex = html.search(/<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?$/i);
+            if (-1 !== bodyIndex) {
+                controller.enqueue(server_encoder.encode(html.slice(0, bodyIndex)));
+                await startFlight(controller);
+                closingBody = true;
+                html = html.slice(bodyIndex);
+            }
+        }
+        if (closingBody) {
+            if (!injectClosingTags) {
+                pendingHtml = html;
+                return;
+            }
+            closingHtml ||= /<\/html>/i.test(closingProbe + html);
+            closingProbe = (closingProbe + html).slice(-6);
+        } else {
+            const tagIndex = html.lastIndexOf('<');
+            if (tagIndex > html.lastIndexOf('>')) {
+                pendingHtml = html.slice(tagIndex);
+                html = html.slice(0, tagIndex);
+            }
+        }
+        if (html) {
+            controller.enqueue(server_encoder.encode(html));
+            startFlight(controller);
+        }
+    }
+    const transformer = {
         transform (chunk, controller) {
-            buffered.push(chunk);
-            if (timeout) return;
-            timeout = setTimeout(async ()=>{
-                flushBufferedChunks(controller);
-                if (!startedRSC) {
-                    startedRSC = true;
-                    writeRSCStream(rscStream, controller).catch((err)=>controller.error(err)).then(()=>resolveFlightDataPromise());
-                }
-            }, 0);
+            return writeHtml(decoder.decode(chunk, {
+                stream: true
+            }), controller);
         },
         async flush (controller) {
-            await flightDataPromise;
-            if (timeout) {
-                clearTimeout(timeout);
-                flushBufferedChunks(controller);
-            }
-            const remaining = decoder.decode();
-            if (remaining) controller.enqueue(server_encoder.encode(remaining));
-            if (injectClosingTags) controller.enqueue(server_encoder.encode('</body></html>'));
+            await writeHtml(decoder.decode(), controller);
+            await startFlight(controller);
+            const tail = injectClosingTags ? pendingHtml : pendingHtml.replace(closingTagsPattern, '');
+            if (tail) controller.enqueue(server_encoder.encode(tail));
+            if (injectClosingTags && !closingHtml) controller.enqueue(server_encoder.encode(closingBody ? '</html>' : '</body></html>'));
+        },
+        cancel (reason) {
+            return flightReader ? flightReader.cancel(reason) : rscStream.cancel(reason);
         }
-    });
+    };
+    return new TransformStream(transformer);
 }
-async function writeRSCStream(rscStream, controller) {
+async function writeRSCStream(reader, controller) {
     const decoder = new TextDecoder('utf-8', {
-        fatal: true
+        fatal: true,
+        ignoreBOM: true
     });
-    for await (const chunk of rscStream)try {
-        writeChunk(JSON.stringify(decoder.decode(chunk, {
-            stream: true
-        })), controller);
-    } catch (err) {
-        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
+    try {
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) return;
+            let chunk;
+            try {
+                chunk = JSON.stringify(decoder.decode(value));
+            } catch  {
+                let binary = '';
+                for (const byte of value)binary += String.fromCharCode(byte);
+                chunk = `Uint8Array.from(atob(${JSON.stringify(btoa(binary))}), m => m.codePointAt(0))`;
+            }
+            writeChunk(chunk, controller);
+        }
+    } finally{
+        reader.releaseLock();
     }
-    const remaining = decoder.decode();
-    if (remaining.length) writeChunk(JSON.stringify(remaining), controller);
 }
 function writeChunk(chunk, controller) {
     controller.enqueue(server_encoder.encode(`<script>${escapeScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`));
@@ -76,35 +109,34 @@ function injectCSS(cssFiles, { injectClosingTags = true } = {}) {
     });
     const decoder = new TextDecoder();
     const headTrailer = '</head>';
-    const buffered = [];
-    let timeout = null;
+    let pendingHtml = '';
     let cssInjected = false;
     const cssLinks = cssFiles.map((css)=>`<link href="${css}" rel="stylesheet" />`).join('');
-    function flushBufferedChunks(controller) {
-        for (const chunk of buffered){
-            let buf = decoder.decode(chunk);
-            if (!cssInjected && buf.includes(headTrailer)) {
-                buf = buf.replace(headTrailer, `${cssLinks}${headTrailer}`);
+    function writeHtml(value, controller, final = false) {
+        let html = pendingHtml + value;
+        pendingHtml = '';
+        if (!cssInjected) {
+            const headIndex = html.toLowerCase().indexOf(headTrailer);
+            if (-1 !== headIndex) {
+                html = html.slice(0, headIndex) + cssLinks + html.slice(headIndex);
                 cssInjected = true;
+            } else if (!final) {
+                let retain = Math.min(headTrailer.length - 1, html.length);
+                while(retain && !html.toLowerCase().endsWith(headTrailer.slice(0, retain)))retain--;
+                pendingHtml = html.slice(html.length - retain);
+                html = html.slice(0, html.length - retain);
             }
-            controller.enqueue(server_encoder.encode(buf));
         }
-        buffered.length = 0;
-        timeout = null;
+        if (html) controller.enqueue(server_encoder.encode(html));
     }
     return new TransformStream({
         transform (chunk, controller) {
-            buffered.push(chunk);
-            if (timeout) return;
-            timeout = setTimeout(()=>{
-                flushBufferedChunks(controller);
-            }, 0);
+            writeHtml(decoder.decode(chunk, {
+                stream: true
+            }), controller);
         },
-        async flush (controller) {
-            if (timeout) {
-                clearTimeout(timeout);
-                flushBufferedChunks(controller);
-            }
+        flush (controller) {
+            writeHtml(decoder.decode(), controller, true);
             if (!cssInjected) controller.enqueue(server_encoder.encode(cssLinks));
             if (injectClosingTags) controller.enqueue(server_encoder.encode('</body></html>'));
         }
@@ -125,7 +157,7 @@ const createRenderCSRWithRSC = (renderRsc)=>async (options)=>{
         });
         const stream = htmlStream.pipeThrough(injectCSS(cssFiles, {
             injectClosingTags: false
-        })).pipeThrough(server_injectRSCPayload(rscPayloadStream, {
+        })).pipeThrough(injectRSCPayload(rscPayloadStream, {
             injectClosingTags: true
         }));
         return new Response(stream, {
@@ -231,15 +263,15 @@ const createHandleAction = ({ decodeReply, loadServerAction, renderRsc })=>async
             });
         }
     };
-const rsc_worker_renderRsc = (options)=>{
+const rsc_renderRsc = (options)=>{
     const readable = renderToReadableStream(options.element);
     return readable;
 };
-const renderCSRWithRSC = createRenderCSRWithRSC(rsc_worker_renderRsc);
 const handleAction = createHandleAction({
     decodeReply: server_edge_decodeReply,
     loadServerAction: server_edge_loadServerAction,
-    renderRsc: rsc_worker_renderRsc
+    renderRsc: rsc_renderRsc
 });
+const renderCSRWithRSC = createRenderCSRWithRSC(rsc_renderRsc);
 export { createFromReadableStream } from "react-server-dom-rspack/client.edge";
-export { handleAction, registerClientReference, registerServerReference, renderCSRWithRSC, renderToReadableStream, rsc_worker_renderRsc as renderRsc };
+export { handleAction, registerClientReference, registerServerReference, renderCSRWithRSC, renderToReadableStream, rsc_renderRsc as renderRsc };

package/dist/esm/server~0.mjs

@@ -0,0 +1,100 @@
+const encoder = new TextEncoder();
+const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
+function injectRSCPayload(rscStream, { injectClosingTags = true }) {
+    const decoder = new TextDecoder();
+    let pendingHtml = '';
+    let closingBody = false;
+    let closingHtml = false;
+    let closingProbe = '';
+    let flightReader;
+    let flightPromise;
+    function startFlight(controller) {
+        if (!flightPromise) {
+            flightReader = rscStream.getReader();
+            flightPromise = writeRSCStream(flightReader, controller).finally(()=>{
+                flightReader = void 0;
+            });
+            flightPromise.catch((error)=>controller.error(error));
+        }
+        return flightPromise;
+    }
+    async function writeHtml(value, controller) {
+        let html = pendingHtml + value;
+        pendingHtml = '';
+        if (!closingBody) {
+            const bodyIndex = html.search(/<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?$/i);
+            if (-1 !== bodyIndex) {
+                controller.enqueue(encoder.encode(html.slice(0, bodyIndex)));
+                await startFlight(controller);
+                closingBody = true;
+                html = html.slice(bodyIndex);
+            }
+        }
+        if (closingBody) {
+            if (!injectClosingTags) {
+                pendingHtml = html;
+                return;
+            }
+            closingHtml ||= /<\/html>/i.test(closingProbe + html);
+            closingProbe = (closingProbe + html).slice(-6);
+        } else {
+            const tagIndex = html.lastIndexOf('<');
+            if (tagIndex > html.lastIndexOf('>')) {
+                pendingHtml = html.slice(tagIndex);
+                html = html.slice(0, tagIndex);
+            }
+        }
+        if (html) {
+            controller.enqueue(encoder.encode(html));
+            startFlight(controller);
+        }
+    }
+    const transformer = {
+        transform (chunk, controller) {
+            return writeHtml(decoder.decode(chunk, {
+                stream: true
+            }), controller);
+        },
+        async flush (controller) {
+            await writeHtml(decoder.decode(), controller);
+            await startFlight(controller);
+            const tail = injectClosingTags ? pendingHtml : pendingHtml.replace(closingTagsPattern, '');
+            if (tail) controller.enqueue(encoder.encode(tail));
+            if (injectClosingTags && !closingHtml) controller.enqueue(encoder.encode(closingBody ? '</html>' : '</body></html>'));
+        },
+        cancel (reason) {
+            return flightReader ? flightReader.cancel(reason) : rscStream.cancel(reason);
+        }
+    };
+    return new TransformStream(transformer);
+}
+async function writeRSCStream(reader, controller) {
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true,
+        ignoreBOM: true
+    });
+    try {
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) return;
+            let chunk;
+            try {
+                chunk = JSON.stringify(decoder.decode(value));
+            } catch  {
+                let binary = '';
+                for (const byte of value)binary += String.fromCharCode(byte);
+                chunk = `Uint8Array.from(atob(${JSON.stringify(btoa(binary))}), m => m.codePointAt(0))`;
+            }
+            writeChunk(chunk, controller);
+        }
+    } finally{
+        reader.releaseLock();
+    }
+}
+function writeChunk(chunk, controller) {
+    controller.enqueue(encoder.encode(`<script>${escapeScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`));
+}
+function escapeScript(script) {
+    return script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1');
+}
+export { injectRSCPayload };

package/dist/esm/ssr.mjs

@@ -1,7 +1,7 @@
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 import react from "react";
 import { renderToReadableStream } from "react-dom/server.edge";
-import { ServerElementsProvider } from "./341.mjs";
+import { ServerElementsProvider } from "./341~0.mjs";
 function CSSLinks({ cssFiles }) {
     if (0 === cssFiles.length) return null;
     return /*#__PURE__*/ react.createElement(react.Fragment, null, cssFiles.map((css)=>/*#__PURE__*/ react.createElement("link", {
@@ -16,13 +16,13 @@ function wrapStream(stream, originalStream) {
     return wrappedStream;
 }
 const renderSSRStream = async (children, options)=>{
-    const { rscManifest, rscRoot, routes } = options;
+    const { rscManifest, rscRoot, routes, wrapHtmlRoot, ...reactOptions } = options;
     const clientManifest = rscManifest?.clientManifest;
     const serverConsumerModuleMap = rscManifest?.serverConsumerModuleMap;
     const entryCssFiles = rscManifest?.entryCssFiles;
     const hasRoutes = Boolean(routes && routes.length > 0);
-    if (!clientManifest || !serverConsumerModuleMap) return renderToReadableStream(children, {
-        ...options,
+    if (!clientManifest || !serverConsumerModuleMap) return renderToReadableStream(wrapHtmlRoot ? wrapHtmlRoot(children) : children, {
+        ...reactOptions,
         identifierPrefix: SSR_HYDRATION_ID_PREFIX
     });
     try {
@@ -30,7 +30,7 @@ const renderSSRStream = async (children, options)=>{
         const [{ renderRsc }, { createFromReadableStream }, { injectRSCPayload }] = await Promise.all([
             rscRuntime,
             import("react-server-dom-rspack/client.edge"),
-            import("./0~server.mjs")
+            import("./server~0.mjs")
         ]);
         const rscStream = await renderRsc({
             element: rscRoot || children
@@ -39,12 +39,13 @@ const renderSSRStream = async (children, options)=>{
         const elements = createFromReadableStream(rscElementStream);
         let cssFiles = [];
         if (!hasRoutes && entryCssFiles) cssFiles = Object.values(entryCssFiles).flat();
-        const htmlStream = await renderToReadableStream(/*#__PURE__*/ react.createElement(ServerElementsProvider, {
+        const htmlRoot = /*#__PURE__*/ react.createElement(ServerElementsProvider, {
             elements: elements
         }, /*#__PURE__*/ react.createElement(CSSLinks, {
             cssFiles: cssFiles
-        }), children), {
-            ...options,
+        }), children);
+        const htmlStream = await renderToReadableStream(wrapHtmlRoot ? wrapHtmlRoot(htmlRoot) : htmlRoot, {
+            ...reactOptions,
             identifierPrefix: SSR_HYDRATION_ID_PREFIX
         });
         const stream = htmlStream.pipeThrough(injectRSCPayload(rscPayloadStream, {

package/dist/types/client/index.d.ts

@@ -1,7 +1,7 @@
 import React, { type ReactNode } from 'react';
 import { createFromFetch, createFromReadableStream, createServerReference, setServerCallback } from 'react-server-dom-rspack/client.browser';
-export { rscStream } from '../rsc-html-stream/client';
-export { callServer } from './callServer';
+export { rscStream } from '../rsc-html-stream/client.js';
+export { callServer } from './callServer.js';
 export { createFromFetch, createFromReadableStream, createServerReference };
 declare global {
     interface Window {

package/dist/types/client.d.ts

@@ -1 +1 @@
-export * from './client/index';
+export * from './client/index.js';

package/dist/types/rsc.d.ts

@@ -1 +1 @@
-export * from './server/rsc';
+export * from './server/rsc/index.js';

package/dist/types/rsc.worker.d.ts

@@ -1 +1 @@
-export * from './server/rsc/rsc.worker';
+export * from './server/rsc/index.js';

package/dist/types/server/rsc/index.d.ts

@@ -1,2 +1,2 @@
-export * from './csr';
-export * from './rsc';
+export * from './csr.js';
+export * from './rsc.js';

package/dist/types/server/ssr/index.d.ts

@@ -1 +1 @@
-export * from './ssr';
+export * from './ssr.js';

package/dist/types/server/ssr/ssr.d.ts

@@ -1,9 +1,11 @@
 import type { ClientManifest } from '@modern-js/types/server';
-import React from 'react';
+import React, { type ReactNode } from 'react';
 import { renderToReadableStream } from 'react-dom/server.edge';
 type Options = {
     request: Request;
     routes?: unknown[];
+    /** Wrap only the HTML render tree, never the input serialized by Flight. */
+    wrapHtmlRoot?: (root: ReactNode) => ReactNode;
     rscManifest?: {
         clientManifest?: ClientManifest;
         serverConsumerModuleMap?: unknown;

package/dist/types/ssr.d.ts

@@ -1 +1 @@
-export * from './server/ssr';
+export * from './server/ssr/index.js';

package/package.json

@@ -17,25 +17,24 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.8.3-ultramodern.6",
+  "version": "3.9.0-ultramodern.10",
   "files": [
     "dist",
     "hook.d.ts"
   ],
   "dependencies": {
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.8.3-ultramodern.6",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.8.3-ultramodern.6",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.8.3-ultramodern.6",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.10",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.10",
     "@swc/helpers": "^0.5.23"
   },
   "devDependencies": {
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.8.3-ultramodern.6",
-    "@rslib/core": "0.23.2",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.10",
+    "@rslib/core": "1.0.0",
     "@scripts/build": "2.66.0",
     "@scripts/rstest-config": "2.66.0",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.4",
+    "@types/react-dom": "^19.2.7",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",

package/dist/esm/0~server.mjs

@@ -1,112 +0,0 @@
-import { injectRSCPayload } from "@modern-js/runtime-extensions/rsc-html-stream";
-const encoder = new TextEncoder();
-const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
-function server_injectRSCPayload(rscStream, { injectClosingTags = true }) {
-    if (injectClosingTags) return injectRSCPayload(rscStream);
-    const decoder = new TextDecoder();
-    let resolveFlightDataPromise;
-    const flightDataPromise = new Promise((resolve)=>resolveFlightDataPromise = resolve);
-    let startedRSC = false;
-    const buffered = [];
-    let timeout = null;
-    function flushBufferedChunks(controller) {
-        let buf = '';
-        for (const chunk of buffered)buf += decoder.decode(chunk, {
-            stream: true
-        });
-        if (closingTagsPattern.test(buf)) buf = buf.replace(closingTagsPattern, '');
-        if (buf) controller.enqueue(encoder.encode(buf));
-        buffered.length = 0;
-        timeout = null;
-    }
-    return new TransformStream({
-        transform (chunk, controller) {
-            buffered.push(chunk);
-            if (timeout) return;
-            timeout = setTimeout(async ()=>{
-                flushBufferedChunks(controller);
-                if (!startedRSC) {
-                    startedRSC = true;
-                    writeRSCStream(rscStream, controller).catch((err)=>controller.error(err)).then(()=>resolveFlightDataPromise());
-                }
-            }, 0);
-        },
-        async flush (controller) {
-            await flightDataPromise;
-            if (timeout) {
-                clearTimeout(timeout);
-                flushBufferedChunks(controller);
-            }
-            const remaining = decoder.decode();
-            if (remaining) controller.enqueue(encoder.encode(remaining));
-            if (injectClosingTags) controller.enqueue(encoder.encode('</body></html>'));
-        }
-    });
-}
-async function writeRSCStream(rscStream, controller) {
-    const decoder = new TextDecoder('utf-8', {
-        fatal: true
-    });
-    for await (const chunk of rscStream)try {
-        writeChunk(JSON.stringify(decoder.decode(chunk, {
-            stream: true
-        })), controller);
-    } catch (err) {
-        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
-    }
-    const remaining = decoder.decode();
-    if (remaining.length) writeChunk(JSON.stringify(remaining), controller);
-}
-function writeChunk(chunk, controller) {
-    controller.enqueue(encoder.encode(`<script>${escapeScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`));
-}
-function escapeScript(script) {
-    return script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1');
-}
-function injectCSS(cssFiles, { injectClosingTags = true } = {}) {
-    if (0 === cssFiles.length) return new TransformStream({
-        transform (chunk, controller) {
-            controller.enqueue(chunk);
-        },
-        flush (controller) {
-            if (injectClosingTags) controller.enqueue(encoder.encode('</body></html>'));
-        }
-    });
-    const decoder = new TextDecoder();
-    const headTrailer = '</head>';
-    const buffered = [];
-    let timeout = null;
-    let cssInjected = false;
-    const cssLinks = cssFiles.map((css)=>`<link href="${css}" rel="stylesheet" />`).join('');
-    function flushBufferedChunks(controller) {
-        for (const chunk of buffered){
-            let buf = decoder.decode(chunk);
-            if (!cssInjected && buf.includes(headTrailer)) {
-                buf = buf.replace(headTrailer, `${cssLinks}${headTrailer}`);
-                cssInjected = true;
-            }
-            controller.enqueue(encoder.encode(buf));
-        }
-        buffered.length = 0;
-        timeout = null;
-    }
-    return new TransformStream({
-        transform (chunk, controller) {
-            buffered.push(chunk);
-            if (timeout) return;
-            timeout = setTimeout(()=>{
-                flushBufferedChunks(controller);
-            }, 0);
-        },
-        async flush (controller) {
-            if (timeout) {
-                clearTimeout(timeout);
-                flushBufferedChunks(controller);
-            }
-            if (!cssInjected) controller.enqueue(encoder.encode(cssLinks));
-            if (injectClosingTags) controller.enqueue(encoder.encode('</body></html>'));
-        }
-    });
-}
-export { injectCSS, server_injectRSCPayload as injectRSCPayload };

package/dist/types/server/rsc/rsc.worker.d.ts

@@ -1,12 +0,0 @@
-export { renderToReadableStream } from 'react-server-dom-rspack/server.edge';
-export { createFromReadableStream } from 'react-server-dom-rspack/client.edge';
-export { registerClientReference, registerServerReference, } from 'react-server-dom-rspack/server.edge';
-type RenderRscOptions = {
-    element: React.ReactElement;
-};
-export declare const renderRsc: (options: RenderRscOptions) => ReadableStream<Uint8Array<ArrayBufferLike>>;
-export declare const renderCSRWithRSC: (options: {
-    html: string;
-    rscRoot: import("react").ReactElement;
-}) => Promise<Response>;
-export declare const handleAction: (req: Request) => Promise<Response>;