@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

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

@@ -0,0 +1,175 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { storage } from "@modern-js/runtime-utils/node";
+import { getPathname, parseCookie, parseHeaders, parseQuery } from "@modern-js/runtime-utils/universal/request";
+import react, { Fragment } from "react";
+import { cleanupRouterRuntimeState } from "../../router/runtime/lifecycle.mjs";
+import { handleRSCRedirect } from "../../router/runtime/rsc-router.mjs";
+import { getGlobalInternalRuntimeContext, getGlobalRSCRoot } from "../context/index.mjs";
+import { getInitialContext } from "../context/runtime.mjs";
+import { getServerPayload } from "../context/serverPayload/index.mjs";
+import { createRoot } from "../react/index.mjs";
+import { CHUNK_CSS_PLACEHOLDER } from "./constants.mjs";
+import { SSRErrors } from "./tracer.mjs";
+import { getSSRConfigByEntry, getSSRMode } from "./utils.mjs";
+async function handleRSCRequest(request, Root, context, options, handleRequest) {
+    const serverPayload = getServerPayload();
+    if (void 0 !== serverPayload) return await handleRequest(request, Root, {
+        ...options,
+        runtimeContext: context,
+        rscRoot: serverPayload
+    });
+    const App = getGlobalRSCRoot();
+    if (App) return await handleRequest(request, Fragment, {
+        ...options,
+        runtimeContext: context,
+        rscRoot: /*#__PURE__*/ jsx(App, {})
+    });
+    return await handleRequest(request, Root, {
+        ...options,
+        runtimeContext: context
+    });
+}
+const isRedirectStatus = (status)=>status >= 300 && status <= 399;
+const processRedirect = (headers, status, ctx)=>{
+    if (ctx.enableRsc && ctx.isRSCNavigation) return handleRSCRedirect(headers, ctx.basename, status);
+    return new Response(null, {
+        status,
+        headers
+    });
+};
+function createSSRContext(request, options) {
+    const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, reporter } = options;
+    const { nonce, useJsonScript } = config;
+    const { entryName, route } = resource;
+    const { headers } = request;
+    const cookie = headers.get('cookie') || '';
+    const cookieMap = parseCookie(request);
+    const pathname = getPathname(request);
+    const query = parseQuery(request);
+    const headersData = parseHeaders(request);
+    const url = new URL(request.url);
+    const host = headers.get('X-Forwarded-Host') || headers.get('host') || url.host;
+    let protocol = (headers.get('X-Forwarded-Proto') || url.protocol || 'http').split(/\s*,\s*/, 1)[0];
+    if (!protocol.endsWith(':')) protocol += ':';
+    const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
+    let ssrMode = getSSRMode(ssrConfig);
+    const isSsgRender = 'true' === headers.get('x-modern-ssg-render');
+    if (isSsgRender) {
+        const reactMajor = Number((react.version || '0').split('.')[0]);
+        ssrMode = reactMajor >= 18 ? 'stream' : 'string';
+    }
+    const loaderFailureMode = 'object' == typeof ssrConfig && ssrConfig && 'loaderFailureMode' in ssrConfig ? ssrConfig.loaderFailureMode : void 0;
+    return {
+        nonce,
+        useJsonScript,
+        loaderContext,
+        htmlModifiers: [],
+        baseUrl: route.urlPath,
+        request: {
+            url: request.url.replace(url.host, host).replace(url.protocol, protocol),
+            userAgent: headers.get('user-agent'),
+            cookie,
+            cookieMap,
+            pathname,
+            query,
+            params,
+            headers: headersData,
+            host,
+            referer: headers.get('referer'),
+            raw: request
+        },
+        response: {
+            setHeader (key, value) {
+                responseProxy.headers[key] = value;
+            },
+            status (code) {
+                responseProxy.status = code;
+            },
+            locals: locals || {}
+        },
+        reporter,
+        mode: ssrMode,
+        onError,
+        onTiming,
+        loaderFailureMode
+    };
+}
+const createRequestHandler = async (handleRequest, createRequestOptions)=>{
+    const requestHandler = async (request, options)=>{
+        const headersData = parseHeaders(request);
+        const responseProxy = {
+            headers: {},
+            status: -1
+        };
+        const activeDeferreds = new Map();
+        return storage.run({
+            headers: headersData,
+            request,
+            monitors: options.monitors,
+            responseProxy,
+            activeDeferreds,
+            serverPayload: void 0
+        }, async ()=>{
+            const Root = createRoot();
+            const internalRuntimeContext = getGlobalInternalRuntimeContext();
+            const hooks = internalRuntimeContext.hooks;
+            const { routeManifest } = options.resource;
+            const context = getInitialContext(false, routeManifest);
+            const runBeforeRender = async (context)=>{
+                const result = await hooks.onBeforeRender.call(context);
+                if ("u" > typeof Response && result instanceof Response) return result;
+            };
+            const ssrContext = createSSRContext(request, {
+                ...options,
+                responseProxy
+            });
+            Object.assign(context, {
+                ssrContext,
+                isBrowser: false
+            });
+            const redirectCtx = {
+                enableRsc: !!createRequestOptions?.enableRsc,
+                isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
+                basename: ssrContext.baseUrl || '/'
+            };
+            try {
+                const beforeRenderResult = await runBeforeRender(context);
+                const routerServerSnapshot = context.routerServerSnapshot;
+                const routerStatusCode = routerServerSnapshot?.statusCode ?? context.routerContext?.statusCode;
+                if (routerStatusCode && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
+                const errors = Object.values(routerServerSnapshot?.errors || context.routerContext?.errors || {});
+                if (errors.length > 0) options.onError(errors[0], SSRErrors.LOADER_ERROR);
+                if ("u" > typeof Response && beforeRenderResult instanceof Response && isRedirectStatus(beforeRenderResult.status)) {
+                    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
+                    const redirectUrl = beforeRenderResult.headers.get('Location') || '/';
+                    return processRedirect(new Headers({
+                        Location: redirectUrl
+                    }), beforeRenderResult.status, redirectCtx);
+                }
+                if (!createRequestOptions?.enableRsc) {
+                    const { htmlTemplate } = options.resource;
+                    options.resource.htmlTemplate = htmlTemplate.replace('</head>', `${CHUNK_CSS_PLACEHOLDER}</head>`);
+                }
+                let response;
+                response = createRequestOptions?.enableRsc ? await handleRSCRequest(request, Root, context, options, handleRequest) : await handleRequest(request, Root, {
+                    ...options,
+                    runtimeContext: context
+                });
+                if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && responseProxy.headers.Location) return processRedirect(new Headers(responseProxy.headers), responseProxy.status, redirectCtx);
+                Object.entries(responseProxy.headers).forEach(([key, value])=>{
+                    response.headers.set(key, value);
+                });
+                if (-1 !== responseProxy.status) return new Response(response.body, {
+                    status: responseProxy.status,
+                    headers: response.headers
+                });
+                return response;
+            } finally{
+                await cleanupRouterRuntimeState(context);
+            }
+        });
+    };
+    return requestHandler;
+};
+export { createRequestHandler };

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

@@ -0,0 +1,4 @@
+import "node:module";
+export { createRequestHandler } from "./requestHandler.mjs";
+export { renderStreaming } from "./stream/index.mjs";
+export { renderString } from "./string/index.mjs";

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

@@ -0,0 +1,5 @@
+import "node:module";
+function buildHtml(template, callbacks) {
+    return callbacks.reduce((promise, buildHtmlCb)=>promise.then((template)=>buildHtmlCb(template)), Promise.resolve(template));
+}
+export { buildHtml };

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

@@ -0,0 +1,70 @@
+import "node:module";
+import { serializeJson } from "@modern-js/runtime-utils/node";
+import { getRouterHydrationScripts } from "../../../router/runtime/lifecycle.mjs";
+import { SSR_DATA_JSON_ID } from "../../constants.mjs";
+import { SSR_DATA_PLACEHOLDER } from "../constants.mjs";
+import { buildHtml } from "../shared.mjs";
+import { attributesToString, safeReplace } from "../utils.mjs";
+function buildShellAfterTemplate(afterAppTemplate, options) {
+    const { request, config, ssrConfig, runtimeContext, renderLevel, entryName } = options;
+    const callbacks = [
+        createReplaceSSRData({
+            request,
+            ssrConfig,
+            nonce: config.nonce,
+            useJsonScript: config.useJsonScript,
+            runtimeContext,
+            renderLevel
+        }),
+        (template)=>injectJs(template, entryName, config.nonce)
+    ];
+    async function injectJs(template, entryName, nonce) {
+        const { routeManifest } = runtimeContext;
+        if (!routeManifest) return template;
+        const { routeAssets } = routeManifest;
+        if (!routeAssets) return template;
+        const asyncEntry = routeAssets[`async-${entryName}`];
+        if (asyncEntry) {
+            const { assets } = asyncEntry;
+            const jsChunkStr = assets?.filter((asset)=>asset.endsWith('.js'))?.map((asset)=>`<script src=${asset} nonce="${nonce}"></script>`).join(' ');
+            if (jsChunkStr) return safeReplace(template, '<!--<?- chunksMap.js ?>-->', jsChunkStr);
+        }
+        return template;
+    }
+    return buildHtml(afterAppTemplate, callbacks);
+}
+function createReplaceSSRData(options) {
+    const { runtimeContext, nonce, renderLevel, useJsonScript, ssrConfig } = options;
+    const { request, reporter } = runtimeContext.ssrContext;
+    const headers = 'object' == typeof ssrConfig && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _])=>ssrConfig.unsafeHeaders?.map((header)=>header.toLowerCase())?.includes(key.toLowerCase()))) : void 0;
+    const ssrData = {
+        data: {
+            initialData: runtimeContext.initialData,
+            i18nData: runtimeContext.__i18nData__
+        },
+        context: {
+            reporter: {
+                sessionId: reporter?.sessionId
+            },
+            request: {
+                query: request.query,
+                params: request.params,
+                pathname: request.pathname,
+                host: request.host,
+                url: request.url,
+                headers: headers
+            }
+        },
+        mode: 'stream',
+        renderLevel
+    };
+    const attrsStr = attributesToString({
+        nonce
+    });
+    const serializeSSRData = serializeJson(ssrData);
+    const ssrDataScript = useJsonScript ? `<script type="application/json" id="${SSR_DATA_JSON_ID}">${serializeSSRData}</script>` : `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>`;
+    const hydrationScripts = getRouterHydrationScripts(runtimeContext);
+    const ssrScripts = hydrationScripts.length ? `${ssrDataScript}\n${hydrationScripts.join('\n')}` : ssrDataScript;
+    return (template)=>safeReplace(template, SSR_DATA_PLACEHOLDER, ssrScripts);
+}
+export { buildShellAfterTemplate };

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

@@ -0,0 +1,71 @@
+import "node:module";
+import { matchRoutes } from "@modern-js/runtime-utils/router";
+import react_helmet from "react-helmet";
+import { getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
+import { CHUNK_CSS_PLACEHOLDER } from "../constants.mjs";
+import { createReplaceHelemt } from "../helmet.mjs";
+import { buildHtml } from "../shared.mjs";
+import { checkIsNode, safeReplace } from "../utils.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var beforeTemplate_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const readAsset = async (chunk)=>{
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const filepath = path.join(beforeTemplate_dirname, chunk);
+    return fs.readFile(filepath, 'utf-8');
+};
+const checkIsInline = (chunk, enableInline)=>{
+    if ('production' !== process.env.NODE_ENV) return false;
+    if (enableInline instanceof RegExp) return enableInline.test(chunk);
+    return Boolean(enableInline);
+};
+async function buildShellBeforeTemplate(beforeAppTemplate, options) {
+    const { config, runtimeContext, styledComponentsStyleTags, entryName } = options;
+    const helmetData = react_helmet.renderStatic();
+    const callbacks = [
+        createReplaceHelemt(helmetData),
+        (template)=>injectCss(template, entryName, styledComponentsStyleTags)
+    ];
+    return buildHtml(beforeAppTemplate, callbacks);
+    async function injectCss(template, entryName, styledComponentsStyleTags) {
+        let css = await getCssChunks();
+        if (styledComponentsStyleTags) css += styledComponentsStyleTags;
+        return safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
+        async function getCssChunks() {
+            const { routeManifest, routerContext, routes } = runtimeContext;
+            if (!routeManifest) return '';
+            const { routeAssets } = routeManifest;
+            let matchedRouteManifests;
+            const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext);
+            if (matchedRouteIds?.length) matchedRouteManifests = matchedRouteIds.map((routeId)=>routeAssets[routeId]).filter(Boolean);
+            else {
+                if (!routerContext || !routes) return '';
+                const matches = matchRoutes(routes, routerContext.location, routerContext.basename);
+                matchedRouteManifests = matches?.map((match, index)=>{
+                    if (!index) return;
+                    const routeId = match.route.id;
+                    if (routeId) return routeAssets[routeId];
+                }).filter(Boolean);
+            }
+            const asyncEntry = routeAssets[`async-${entryName}`];
+            if (asyncEntry) matchedRouteManifests?.push(asyncEntry);
+            const cssChunks = matchedRouteManifests ? matchedRouteManifests.reduce((chunks, routeManifest)=>{
+                const { referenceCssAssets = [] } = routeManifest;
+                const _cssChunks = referenceCssAssets.filter((asset)=>asset?.endsWith('.css') && !template.includes(asset));
+                return [
+                    ...chunks,
+                    ..._cssChunks
+                ];
+            }, []) : [];
+            const { inlineStyles } = config;
+            const styles = await Promise.all(cssChunks.map(async (chunk)=>{
+                const link = `<link href="${chunk}" rel="stylesheet" />`;
+                if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
+                return link;
+            }));
+            return `${styles.join('')}`;
+        }
+    }
+}
+export { buildShellBeforeTemplate };

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

@@ -0,0 +1,128 @@
+import "node:module";
+import { storage } from "@modern-js/runtime-utils/node";
+import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
+import { PassThrough, Readable, Transform } from "stream";
+import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common.mjs";
+import { RenderLevel } from "../../constants.mjs";
+import { getGlobalInternalRuntimeContext } from "../../context/index.mjs";
+import { getMonitors } from "../../context/monitors/index.mjs";
+import { enqueueFromEntries } from "./deferredScript.mjs";
+import { ShellChunkStatus, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
+import { getTemplates } from "./template.mjs";
+const defaultExtender = {
+    modifyRootElement: (rootElement)=>rootElement,
+    getStyleTags: ()=>'',
+    processStream: (stream)=>stream
+};
+const createReadableStreamFromElement = async (request, rootElement, options)=>{
+    const { renderToPipeableStream } = await import("react-dom/server");
+    const { runtimeContext, htmlTemplate, config, ssrConfig, entryName } = options;
+    let shellChunkStatus = ShellChunkStatus.START;
+    let renderLevel = RenderLevel.SERVER_RENDER;
+    const forceStream2String = Boolean(process.env.MODERN_JS_STREAM_TO_STRING);
+    const { onReady } = resolveStreamingMode(request, forceStream2String);
+    const internalRuntimeContext = getGlobalInternalRuntimeContext();
+    const hooks = internalRuntimeContext.hooks;
+    const extenders = hooks.extendStreamSSR.call() || [];
+    if (0 === extenders.length) extenders.push(defaultExtender);
+    extenders.forEach((extender)=>{
+        if (extender.init) extender.init({
+            rootElement,
+            forceStream2String
+        });
+    });
+    let processedRootElement = rootElement;
+    extenders.forEach((extender)=>{
+        if (extender.modifyRootElement) processedRootElement = extender.modifyRootElement(processedRootElement);
+    });
+    const chunkVec = [];
+    return new Promise((resolve)=>{
+        const { pipe: reactStreamingPipe } = renderToPipeableStream(processedRootElement, {
+            nonce: config.nonce,
+            identifierPrefix: SSR_HYDRATION_ID_PREFIX,
+            [onReady] () {
+                let styledComponentsStyleTags = '';
+                extenders.forEach((extender)=>{
+                    if (extender.getStyleTags) styledComponentsStyleTags += extender.getStyleTags();
+                });
+                options[onReady]?.();
+                getTemplates(htmlTemplate, {
+                    request,
+                    ssrConfig,
+                    renderLevel,
+                    runtimeContext,
+                    config,
+                    entryName,
+                    styledComponentsStyleTags
+                }).then(({ shellAfter, shellBefore })=>{
+                    const pendingScripts = [];
+                    const body = new Transform({
+                        transform (chunk, _encoding, callback) {
+                            try {
+                                if (shellChunkStatus !== ShellChunkStatus.FINISH) {
+                                    chunkVec.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                                    const chunkStr = chunk.toString('utf-8');
+                                    if (chunkStr.includes(ESCAPED_SHELL_STREAM_END_MARK)) {
+                                        let concatedChunk = Buffer.concat(chunkVec).toString('utf-8');
+                                        concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, '');
+                                        shellChunkStatus = ShellChunkStatus.FINISH;
+                                        this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
+                                        if (pendingScripts.length > 0) for (const s of pendingScripts)this.push(s);
+                                    }
+                                } else this.push(chunk);
+                                callback();
+                            } catch (e) {
+                                e instanceof Error ? callback(e) : callback(new Error('Received unknown error when streaming'));
+                            }
+                        }
+                    });
+                    const passThrough = new PassThrough();
+                    const stream = Readable.toWeb(body);
+                    resolve(stream);
+                    let processedStream = passThrough;
+                    extenders.forEach((extender)=>{
+                        if (extender.processStream) processedStream = extender.processStream(processedStream);
+                    });
+                    reactStreamingPipe(passThrough);
+                    processedStream.pipe(body);
+                    try {
+                        const storageContext = storage.useContext?.();
+                        const activeDeferreds = storageContext?.activeDeferreds;
+                        const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
+                        if (entries.length > 0) {
+                            const enqueueScript = (s)=>{
+                                if (shellChunkStatus === ShellChunkStatus.FINISH) body.write(s);
+                                else pendingScripts.push(s);
+                            };
+                            enqueueFromEntries(entries, config.nonce, (s)=>enqueueScript(s));
+                        }
+                    } catch (err) {
+                        const monitors = getMonitors();
+                        monitors.error("cannot inject router data script", err);
+                    }
+                });
+            },
+            onShellError (error) {
+                renderLevel = RenderLevel.CLIENT_RENDER;
+                getTemplates(htmlTemplate, {
+                    request,
+                    ssrConfig,
+                    renderLevel,
+                    runtimeContext,
+                    entryName,
+                    config
+                }).then(({ shellAfter, shellBefore })=>{
+                    const fallbackHtml = `${shellBefore}${shellAfter}`;
+                    const readableStream = getReadableStreamFromString(fallbackHtml);
+                    resolve(readableStream);
+                    options?.onShellError?.(error);
+                });
+            },
+            onError (error) {
+                renderLevel = RenderLevel.CLIENT_RENDER;
+                options?.onError?.(error);
+            }
+        });
+    });
+};
+export { createReadableStreamFromElement };

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

@@ -0,0 +1,108 @@
+import "node:module";
+import { renderSSRStream } from "@modern-js/render/ssr";
+import { storage } from "@modern-js/runtime-utils/node";
+import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common.mjs";
+import { RenderLevel } from "../../constants.mjs";
+import { enqueueFromEntries } from "./deferredScript.mjs";
+import { ShellChunkStatus, encodeForWebStream, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
+import { getTemplates } from "./template.mjs";
+const createReadableStreamFromElement = async (request, rootElement, options)=>{
+    let shellChunkStatus = ShellChunkStatus.START;
+    const chunkVec = [];
+    const { htmlTemplate, runtimeContext, config, ssrConfig, entryName, rscRoot } = options;
+    const { shellBefore, shellAfter } = await getTemplates(htmlTemplate, {
+        renderLevel: RenderLevel.SERVER_RENDER,
+        runtimeContext,
+        ssrConfig,
+        request,
+        config,
+        entryName
+    });
+    try {
+        const readableOriginal = await renderSSRStream(rootElement, {
+            request,
+            nonce: config.nonce,
+            rscRoot: rscRoot,
+            routes: runtimeContext.routes,
+            onError (error) {
+                options.onError?.(error);
+            }
+        });
+        options.onShellReady?.();
+        readableOriginal.allReady.then(()=>{
+            options?.onAllReady?.();
+        });
+        const forceStreamToString = Boolean("u" > typeof process && process.env?.MODERN_JS_STREAM_TO_STRING);
+        const { waitForAllReady } = resolveStreamingMode(request, forceStreamToString);
+        if (waitForAllReady) await readableOriginal.allReady;
+        const reader = readableOriginal.getReader();
+        const stream = new ReadableStream({
+            start (controller) {
+                const pendingScripts = [];
+                let isClosed = false;
+                const safeEnqueue = (chunk)=>{
+                    if (isClosed) return;
+                    try {
+                        controller.enqueue(chunk);
+                    } catch  {
+                        isClosed = true;
+                    }
+                };
+                const closeController = ()=>{
+                    if (!isClosed) {
+                        isClosed = true;
+                        try {
+                            controller.close();
+                        } catch  {}
+                    }
+                };
+                const flushPendingScripts = ()=>{
+                    for (const s of pendingScripts)safeEnqueue(encodeForWebStream(s));
+                    pendingScripts.length = 0;
+                };
+                const enqueueScript = (script)=>{
+                    if (shellChunkStatus === ShellChunkStatus.FINISH) safeEnqueue(encodeForWebStream(script));
+                    else pendingScripts.push(script);
+                };
+                const storageContext = storage.useContext?.();
+                const activeDeferreds = storageContext?.activeDeferreds;
+                const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
+                if (entries.length > 0) enqueueFromEntries(entries, config.nonce, enqueueScript);
+                async function push() {
+                    try {
+                        const { done, value } = await reader.read();
+                        if (done) return void closeController();
+                        if (isClosed) return;
+                        if (shellChunkStatus !== ShellChunkStatus.FINISH) {
+                            chunkVec.push(new TextDecoder().decode(value));
+                            const concatedChunk = chunkVec.join('');
+                            if (concatedChunk.includes(ESCAPED_SHELL_STREAM_END_MARK)) {
+                                shellChunkStatus = ShellChunkStatus.FINISH;
+                                safeEnqueue(encodeForWebStream(`${shellBefore}${concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, '')}${shellAfter}`));
+                                flushPendingScripts();
+                            }
+                        } else safeEnqueue(value);
+                        if (!isClosed) push();
+                    } catch (error) {
+                        if (!isClosed) {
+                            isClosed = true;
+                            try {
+                                controller.error(error);
+                            } catch  {}
+                        }
+                    }
+                }
+                push();
+            },
+            cancel (reason) {
+                reader.cancel(reason).catch(()=>{});
+            }
+        });
+        return stream;
+    } catch (e) {
+        const fallbackHtml = `${shellBefore}${shellAfter}`;
+        const stream = getReadableStreamFromString(fallbackHtml);
+        return stream;
+    }
+};
+export { createReadableStreamFromElement };

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

@@ -0,0 +1,63 @@
+import "node:module";
+import { runRouterDataFnStr } from "../../../router/runtime/constants.mjs";
+const HTML_ESCAPE_MAP = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;'
+};
+function escapeAttr(value) {
+    return value.replace(/[&<>"']/g, (ch)=>HTML_ESCAPE_MAP[ch]);
+}
+function isRecord(v) {
+    return 'object' == typeof v && null !== v;
+}
+function isDeferredDataLike(v) {
+    if (!isRecord(v)) return false;
+    const hasPending = 'pendingKeys' in v && Array.isArray(v.pendingKeys);
+    const hasData = 'data' in v && isRecord(v.data);
+    return hasPending && hasData;
+}
+function isPromiseLike(value) {
+    return !!value && 'function' == typeof value.then;
+}
+function toErrorInfo(error) {
+    if (error && 'object' == typeof error) {
+        const maybeMsg = error.message;
+        const maybeStack = error.stack;
+        return {
+            message: 'string' == typeof maybeMsg ? maybeMsg : String(maybeMsg ?? error),
+            stack: 'production' !== process.env.NODE_ENV ? maybeStack : void 0
+        };
+    }
+    return {
+        message: String(error)
+    };
+}
+function buildDeferredDataScript(nonce, args) {
+    const payload = JSON.stringify(args);
+    const escaped = escapeAttr(payload);
+    const nonceAttr = nonce ? ` nonce="${nonce}"` : '';
+    return `<script async${nonceAttr} data-fn-name="r" data-script-src="modern-run-router-data-fn" data-fn-args='${escaped}' suppressHydrationWarning>${runRouterDataFnStr}</script>`;
+}
+function enqueueFromEntries(entries, nonce, emit) {
+    entries.forEach(([routeId, value])=>{
+        if (!isDeferredDataLike(value)) return;
+        const pendingKeys = new Set(value.pendingKeys ?? []);
+        pendingKeys.forEach((key)=>{
+            const tracked = value.data?.[key];
+            if (isPromiseLike(tracked)) tracked.then((val)=>emit(buildDeferredDataScript(nonce, [
+                    routeId,
+                    key,
+                    val
+                ])), (err)=>emit(buildDeferredDataScript(nonce, [
+                    routeId,
+                    key,
+                    void 0,
+                    toErrorInfo(err)
+                ])));
+        });
+    });
+}
+export { buildDeferredDataScript, enqueueFromEntries, escapeAttr, isDeferredDataLike, isPromiseLike, isRecord, toErrorInfo };

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

@@ -0,0 +1,5 @@
+import "node:module";
+import { createRenderStreaming } from "./shared.mjs";
+const createReadableStreamFromElement = 'edge' === process.env.MODERN_SSR_ENV ? import("./createReadableStream.worker.mjs").then((m)=>m.createReadableStreamFromElement) : import("./createReadableStream.mjs").then((m)=>m.createReadableStreamFromElement);
+const renderStreaming = createRenderStreaming(createReadableStreamFromElement);
+export { renderStreaming };