@bleedingdev/modern-js-render 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

package/dist/esm/client.mjs

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

package/dist/esm/rsc.mjs

@@ -1 +1,192 @@
-export { createFromReadableStream, handleAction, registerClientReference, registerServerReference, renderCSRWithRSC, renderRsc, renderToReadableStream } from "./130.mjs";
+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 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) {
+        for (const chunk of buffered){
+            let buf = decoder.decode(chunk);
+            if (closingTagsPattern.test(buf)) buf = buf.replace(closingTagsPattern, '');
+            controller.enqueue(server_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);
+            }
+            if (injectClosingTags) controller.enqueue(server_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(server_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(server_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(server_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(server_encoder.encode(cssLinks));
+            if (injectClosingTags) controller.enqueue(server_encoder.encode('</body></html>'));
+        }
+    });
+}
+const createHandleAction = ({ decodeReply, loadServerAction, renderRsc })=>async (req)=>{
+        try {
+            const serverReference = req.headers.get('x-rsc-action');
+            if (!serverReference) return new Response('Cannot find server reference', {
+                status: 404
+            });
+            const action = loadServerAction(serverReference);
+            if ('function' != typeof action) {
+                console.error('[RSC] Invalid action: server reference is not a function, serverReference:', serverReference);
+                return new Response('Invalid action', {
+                    status: 400
+                });
+            }
+            const contentType = req.headers.get('content-type');
+            let args;
+            try {
+                if (contentType?.includes('multipart/form-data')) {
+                    const formData = await req.formData();
+                    args = await decodeReply(formData);
+                } else {
+                    const text = await req.text();
+                    args = await decodeReply(text);
+                }
+            } catch (error) {
+                console.error('[RSC] Failed to decode request arguments, error:', error instanceof Error ? error.message : String(error), 'contentType:', contentType || 'unknown');
+                return new Response('Failed to decode request arguments', {
+                    status: 400
+                });
+            }
+            const result = await Promise.resolve(action.apply(null, args));
+            const stream = renderRsc({
+                element: result
+            });
+            const response = new Response(stream, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/html'
+                }
+            });
+            return response;
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : void 0;
+            console.error('[RSC] Error handling server action, error:', errorMessage, errorStack ? `\n${errorStack}` : '');
+            return new Response('Internal server error', {
+                status: 500
+            });
+        }
+    };
+const rsc_renderRsc = (options)=>{
+    const readable = renderToReadableStream(options.element);
+    return readable;
+};
+const handleAction = createHandleAction({
+    decodeReply: server_node_decodeReply,
+    loadServerAction: server_node_loadServerAction,
+    renderRsc: rsc_renderRsc
+});
+async function renderCSRWithRSC(options) {
+    const entryCssFiles = __webpack_require__.rscM?.entryCssFiles;
+    const cssFiles = entryCssFiles ? Object.values(entryCssFiles).flat() : [];
+    const rscPayloadStream = rsc_renderRsc({
+        element: options.rscRoot
+    });
+    const htmlStream = new ReadableStream({
+        start (controller) {
+            const encoder = new TextEncoder();
+            controller.enqueue(encoder.encode(options.html));
+            controller.close();
+        }
+    });
+    const stream = htmlStream.pipeThrough(injectCSS(cssFiles, {
+        injectClosingTags: false
+    })).pipeThrough(injectRSCPayload(rscPayloadStream, {
+        injectClosingTags: true
+    }));
+    return new Response(stream, {
+        status: 200,
+        headers: new Headers({
+            'content-type': 'text/html; charset=UTF-8'
+        })
+    });
+}
+export { createFromReadableStream } from "react-server-dom-rspack/client.node";
+export { handleAction, registerClientReference, registerServerReference, renderCSRWithRSC, renderToReadableStream, rsc_renderRsc as renderRsc };

package/dist/esm/rscWorker.mjs

@@ -0,0 +1,202 @@
+import { decodeReply as server_node_decodeReply, loadServerAction as server_node_loadServerAction, renderToReadableStream } from "react-server-dom-rspack/server.node";
+import { decodeReply as server_edge_decodeReply, loadServerAction as server_edge_loadServerAction, registerClientReference, registerServerReference, renderToReadableStream as server_edge_renderToReadableStream } from "react-server-dom-rspack/server.edge";
+const server_encoder = new TextEncoder();
+const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
+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) {
+        for (const chunk of buffered){
+            let buf = decoder.decode(chunk);
+            if (closingTagsPattern.test(buf)) buf = buf.replace(closingTagsPattern, '');
+            controller.enqueue(server_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);
+            }
+            if (injectClosingTags) controller.enqueue(server_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(server_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(server_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(server_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(server_encoder.encode(cssLinks));
+            if (injectClosingTags) controller.enqueue(server_encoder.encode('</body></html>'));
+        }
+    });
+}
+const createHandleAction = ({ decodeReply, loadServerAction, renderRsc })=>async (req)=>{
+        try {
+            const serverReference = req.headers.get('x-rsc-action');
+            if (!serverReference) return new Response('Cannot find server reference', {
+                status: 404
+            });
+            const action = loadServerAction(serverReference);
+            if ('function' != typeof action) {
+                console.error('[RSC] Invalid action: server reference is not a function, serverReference:', serverReference);
+                return new Response('Invalid action', {
+                    status: 400
+                });
+            }
+            const contentType = req.headers.get('content-type');
+            let args;
+            try {
+                if (contentType?.includes('multipart/form-data')) {
+                    const formData = await req.formData();
+                    args = await decodeReply(formData);
+                } else {
+                    const text = await req.text();
+                    args = await decodeReply(text);
+                }
+            } catch (error) {
+                console.error('[RSC] Failed to decode request arguments, error:', error instanceof Error ? error.message : String(error), 'contentType:', contentType || 'unknown');
+                return new Response('Failed to decode request arguments', {
+                    status: 400
+                });
+            }
+            const result = await Promise.resolve(action.apply(null, args));
+            const stream = renderRsc({
+                element: result
+            });
+            const response = new Response(stream, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/html'
+                }
+            });
+            return response;
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : void 0;
+            console.error('[RSC] Error handling server action, error:', errorMessage, errorStack ? `\n${errorStack}` : '');
+            return new Response('Internal server error', {
+                status: 500
+            });
+        }
+    };
+const rsc_renderRsc = (options)=>{
+    const readable = renderToReadableStream(options.element);
+    return readable;
+};
+createHandleAction({
+    decodeReply: server_node_decodeReply,
+    loadServerAction: server_node_loadServerAction,
+    renderRsc: rsc_renderRsc
+});
+async function renderCSRWithRSC(options) {
+    const entryCssFiles = __webpack_require__.rscM?.entryCssFiles;
+    const cssFiles = entryCssFiles ? Object.values(entryCssFiles).flat() : [];
+    const rscPayloadStream = rsc_renderRsc({
+        element: options.rscRoot
+    });
+    const htmlStream = new ReadableStream({
+        start (controller) {
+            const encoder = new TextEncoder();
+            controller.enqueue(encoder.encode(options.html));
+            controller.close();
+        }
+    });
+    const stream = htmlStream.pipeThrough(injectCSS(cssFiles, {
+        injectClosingTags: false
+    })).pipeThrough(injectRSCPayload(rscPayloadStream, {
+        injectClosingTags: true
+    }));
+    return new Response(stream, {
+        status: 200,
+        headers: new Headers({
+            'content-type': 'text/html; charset=UTF-8'
+        })
+    });
+}
+const rsc_worker_renderRsc = (options)=>{
+    const readable = server_edge_renderToReadableStream(options.element);
+    return readable;
+};
+const rsc_worker_handleAction = createHandleAction({
+    decodeReply: server_edge_decodeReply,
+    loadServerAction: server_edge_loadServerAction,
+    renderRsc: rsc_worker_renderRsc
+});
+export { createFromReadableStream } from "react-server-dom-rspack/client.edge";
+export { registerClientReference, registerServerReference, renderCSRWithRSC, rsc_worker_handleAction as handleAction, rsc_worker_renderRsc as renderRsc, server_edge_renderToReadableStream as renderToReadableStream };

package/dist/esm/ssr.mjs

@@ -1,10 +1,10 @@
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
+import react from "react";
 import { renderToReadableStream } from "react-dom/server.edge";
-import { __webpack_require__ } from "./rslib-runtime.mjs";
-import { ServerElementsProvider } from "./647.mjs";
+import { ServerElementsProvider } from "./712.mjs";
 function CSSLinks({ cssFiles }) {
     if (0 === cssFiles.length) return null;
-    return /*#__PURE__*/ React.createElement(React.Fragment, null, cssFiles.map((css)=>/*#__PURE__*/ React.createElement("link", {
+    return /*#__PURE__*/ react.createElement(react.Fragment, null, cssFiles.map((css)=>/*#__PURE__*/ react.createElement("link", {
             key: css,
             href: css,
             rel: "stylesheet"
@@ -16,20 +16,21 @@ function wrapStream(stream, originalStream) {
     return wrappedStream;
 }
 const renderSSRStream = async (children, options)=>{
-    const { rscRoot, routes } = options;
-    const clientManifest = __webpack_require__.rscM?.clientManifest;
-    const serverConsumerModuleMap = __webpack_require__.rscM?.serverConsumerModuleMap;
-    const entryCssFiles = __webpack_require__.rscM?.entryCssFiles;
+    const { rscManifest, rscRoot, routes } = 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,
         identifierPrefix: SSR_HYDRATION_ID_PREFIX
     });
     try {
+        const rscRuntime = 'edge' === process.env.MODERN_SSR_ENV ? import("@modern-js/render/rsc-worker") : import("@modern-js/render/rsc");
         const [{ renderRsc }, { createFromReadableStream }, { injectRSCPayload }] = await Promise.all([
-            import("./130.mjs").then((m)=>m.rsc_namespaceObject),
+            rscRuntime,
             import("react-server-dom-rspack/client.edge"),
-            import("./940.mjs")
+            import("./0~server.mjs")
         ]);
         const rscStream = await renderRsc({
             element: rscRoot || children
@@ -38,9 +39,9 @@ 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 htmlStream = await renderToReadableStream(/*#__PURE__*/ react.createElement(ServerElementsProvider, {
             elements: elements
-        }, /*#__PURE__*/ React.createElement(CSSLinks, {
+        }, /*#__PURE__*/ react.createElement(CSSLinks, {
             cssFiles: cssFiles
         }), children), {
             ...options,

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

@@ -0,0 +1,2 @@
+export * from './server/rsc/csr';
+export * from './server/rsc/rsc.worker';

package/dist/types/server/rsc/handle-action.d.ts

@@ -0,0 +1,9 @@
+import type { ReactElement } from 'react';
+export type RscActionRuntime = {
+    decodeReply: (body: string | FormData) => Promise<unknown[]>;
+    loadServerAction: (actionId: string) => unknown;
+    renderRsc: (options: {
+        element: ReactElement;
+    }) => ReadableStream<Uint8Array>;
+};
+export declare const createHandleAction: ({ decodeReply, loadServerAction, renderRsc }: RscActionRuntime) => (req: Request) => Promise<Response>;

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

@@ -0,0 +1,8 @@
+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 handleAction: (req: Request) => Promise<Response>;

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

@@ -1,7 +1,15 @@
+import type { ClientManifest } from '@modern-js/types/server';
+import React from 'react';
 import { renderToReadableStream } from 'react-dom/server.edge';
 type Options = {
     request: Request;
     routes?: unknown[];
+    rscManifest?: {
+        clientManifest?: ClientManifest;
+        serverConsumerModuleMap?: unknown;
+        serverManifest?: unknown;
+        entryCssFiles?: Record<string, string[]>;
+    };
 } & Parameters<typeof renderToReadableStream>[1];
 export declare const renderSSRStream: (children: React.ReactNode, options: Options & {
     rscRoot: React.ReactElement;

package/package.json

@@ -17,30 +17,30 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.2.0-ultramodern.12",
+  "version": "3.2.0-ultramodern.121",
   "files": [
     "dist",
     "hook.d.ts"
   ],
   "dependencies": {
-    "@swc/helpers": "^0.5.21",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.12",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.12"
+    "@swc/helpers": "^0.5.23",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.121",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.121"
   },
   "devDependencies": {
-    "@rslib/core": "0.21.5",
-    "@types/react": "^19.2.14",
+    "@rslib/core": "0.22.0",
+    "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
-    "@typescript/native-preview": "7.0.0-dev.20260516.1",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
+    "@typescript/native-preview": "7.0.0-dev.20260610.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
     "react-server-dom-rspack": "0.0.2",
-    "@scripts/rstest-config": "2.66.0",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.12"
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.121",
+    "@scripts/rstest-config": "2.66.0"
   },
   "peerDependencies": {
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
     "react-server-dom-rspack": "0.0.2"
   },
   "exports": {
@@ -52,6 +52,10 @@
       "types": "./dist/types/server/rsc/index.d.ts",
       "default": "./dist/esm/rsc.mjs"
     },
+    "./rsc-worker": {
+      "types": "./dist/types/rsc.worker.d.ts",
+      "default": "./dist/esm/rscWorker.mjs"
+    },
     "./client": {
       "types": "./dist/types/client/index.d.ts",
       "default": "./dist/esm/client.mjs"
@@ -65,6 +69,9 @@
       "rsc": [
         "./dist/types/server/rsc/index.d.ts"
       ],
+      "rsc-worker": [
+        "./dist/types/rsc.worker.d.ts"
+      ],
       "client": [
         "./dist/types/client/index.d.ts"
       ]

package/dist/esm/130.mjs

@@ -1,95 +0,0 @@
-import { decodeReply, loadServerAction, registerClientReference, registerServerReference, renderToReadableStream } from "react-server-dom-rspack/server.node";
-import { __webpack_require__ } from "./rslib-runtime.mjs";
-import { createFromReadableStream as createFromReadableStream_0 } from "react-server-dom-rspack/client.node";
-import { injectCSS, injectRSCPayload } from "./940.mjs";
-var rsc_namespaceObject = {};
-__webpack_require__.r(rsc_namespaceObject);
-__webpack_require__.d(rsc_namespaceObject, {
-    createFromReadableStream: ()=>createFromReadableStream_0,
-    handleAction: ()=>handleAction,
-    registerClientReference: ()=>registerClientReference,
-    registerServerReference: ()=>registerServerReference,
-    renderCSRWithRSC: ()=>renderCSRWithRSC,
-    renderRsc: ()=>renderRsc,
-    renderToReadableStream: ()=>renderToReadableStream
-});
-const renderRsc = (options)=>{
-    const readable = renderToReadableStream(options.element);
-    return readable;
-};
-const handleAction = async (req)=>{
-    try {
-        const serverReference = req.headers.get('x-rsc-action');
-        if (!serverReference) return new Response('Cannot find server reference', {
-            status: 404
-        });
-        const action = loadServerAction(serverReference);
-        if ('function' != typeof action) {
-            console.error('[RSC] Invalid action: server reference is not a function, serverReference:', serverReference);
-            return new Response('Invalid action', {
-                status: 400
-            });
-        }
-        const contentType = req.headers.get('content-type');
-        let args;
-        try {
-            if (contentType?.includes('multipart/form-data')) {
-                const formData = await req.formData();
-                args = await decodeReply(formData);
-            } else {
-                const text = await req.text();
-                args = await decodeReply(text);
-            }
-        } catch (error) {
-            console.error('[RSC] Failed to decode request arguments, error:', error instanceof Error ? error.message : String(error), 'contentType:', contentType || 'unknown');
-            return new Response('Failed to decode request arguments', {
-                status: 400
-            });
-        }
-        const result = await Promise.resolve(action.apply(null, args));
-        const stream = renderRsc({
-            element: result
-        });
-        const response = new Response(stream, {
-            status: 200,
-            headers: {
-                'Content-Type': 'text/html'
-            }
-        });
-        return response;
-    } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const errorStack = error instanceof Error ? error.stack : void 0;
-        console.error('[RSC] Error handling server action, error:', errorMessage, errorStack ? `\n${errorStack}` : '');
-        return new Response('Internal server error', {
-            status: 500
-        });
-    }
-};
-async function renderCSRWithRSC(options) {
-    const entryCssFiles = __webpack_require__.rscM?.entryCssFiles;
-    const cssFiles = entryCssFiles ? Object.values(entryCssFiles).flat() : [];
-    const rscPayloadStream = renderRsc({
-        element: options.rscRoot
-    });
-    const htmlStream = new ReadableStream({
-        start (controller) {
-            const encoder = new TextEncoder();
-            controller.enqueue(encoder.encode(options.html));
-            controller.close();
-        }
-    });
-    const stream = htmlStream.pipeThrough(injectCSS(cssFiles, {
-        injectClosingTags: false
-    })).pipeThrough(injectRSCPayload(rscPayloadStream, {
-        injectClosingTags: true
-    }));
-    return new Response(stream, {
-        status: 200,
-        headers: new Headers({
-            'content-type': 'text/html; charset=UTF-8'
-        })
-    });
-}
-export { createFromReadableStream } from "react-server-dom-rspack/client.node";
-export { handleAction, registerClientReference, registerServerReference, renderCSRWithRSC, renderRsc, renderToReadableStream, rsc_namespaceObject };

package/dist/esm/rslib-runtime.mjs

@@ -1,23 +0,0 @@
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports, '__esModule', {
-            value: true
-        });
-    };
-})();
-export { __webpack_require__ };