@bleedingdev/modern-js-runtime 3.2.0-ultramodern.99 → 3.4.0-ultramodern.0

package/dist/cjs/rsc/client.js

@@ -24,11 +24,15 @@ function __webpack_require__(moduleId) {
     };
 })();
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -47,9 +51,6 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        isRedirectResponse: ()=>isRedirectResponse
-    });
     var _modern_js_render_client__rspack_import_0 = __webpack_require__("@modern-js/render/client");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _modern_js_render_client__rspack_import_0)if ([
@@ -58,6 +59,9 @@ var __webpack_exports__ = {};
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_render_client__rspack_import_0[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     const isRedirectResponse = (res)=>null != res.headers.get('X-Modernjs-Redirect');
+    __webpack_require__.d(__webpack_exports__, {}, {
+        isRedirectResponse: isRedirectResponse
+    });
 })();
 exports.isRedirectResponse = __webpack_exports__.isRedirectResponse;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/rsc/server.js

@@ -24,11 +24,15 @@ function __webpack_require__(moduleId) {
     };
 })();
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{

package/dist/cjs/rsc/server.worker.js

@@ -24,11 +24,15 @@ function __webpack_require__(moduleId) {
     };
 })();
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{

package/dist/esm/boundary-debugger/index.mjs

@@ -50,7 +50,7 @@ const readQueryEnabledOverride = ()=>{
 const detectLanguage = ()=>{
     if ("u" < typeof document) return 'en';
     const htmlLanguage = document.documentElement.lang;
-    if (htmlLanguage) return htmlLanguage.split('-')[0] || 'en';
+    if ('' !== htmlLanguage) return htmlLanguage.split('-')[0] || 'en';
     if ("u" < typeof window) return 'en';
     return window.location.pathname.split('/').filter(Boolean)[0] || 'en';
 };
@@ -69,7 +69,7 @@ const getBoundaryId = (element)=>element.dataset.modernBoundaryId ?? element.dat
 const collectBoundaryElements = (legacySelector)=>{
     const elements = new Set();
     for (const element of document.querySelectorAll(boundarySelector))elements.add(element);
-    if (!legacySelector) return Array.from(elements);
+    if (void 0 === legacySelector || '' === legacySelector) return Array.from(elements);
     try {
         for (const element of document.querySelectorAll(legacySelector))elements.add(element);
     } catch  {}
@@ -113,7 +113,7 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
             const seenBoxes = new Set();
             const nextBoxes = collectBoundaryElements(legacySelector).map((element)=>{
                 const boundaryId = getBoundaryId(element);
-                if (!boundaryId) return;
+                if (void 0 === boundaryId || '' === boundaryId) return;
                 const rect = element.getBoundingClientRect();
                 if (rect.width <= 0 || rect.height <= 0) return;
                 const rectKey = formatRectKey(rect);
@@ -124,7 +124,7 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
                 const color = boundary?.color ?? palette[hashBoundaryId(boundaryId) % palette.length];
                 const label = boundary?.label ?? boundary?.appId ?? boundaryId;
                 const expose = element.dataset.modernMfExpose;
-                const detail = expose && expose !== label && expose !== boundaryId ? expose : void 0;
+                const detail = void 0 !== expose && '' !== expose && expose !== label && expose !== boundaryId ? expose : void 0;
                 const box = {
                     color,
                     height: rect.height,
@@ -134,7 +134,7 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
                     top: rect.top,
                     width: rect.width
                 };
-                if (detail) box.detail = detail;
+                if (void 0 !== detail) box.detail = detail;
                 return box;
             }).filter((box)=>void 0 !== box);
             setBoxes(nextBoxes);
@@ -196,9 +196,13 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
             enabled ? /*#__PURE__*/ jsx("div", {
                 "aria-hidden": "true",
                 children: boxes.map((box)=>/*#__PURE__*/ jsx("div", {
+                        "data-modern-boundary-overlay": "",
+                        "data-modern-boundary-overlay-id": box.id,
+                        "data-modern-boundary-overlay-label": box.label,
                         style: {
                             border: `2px solid ${box.color}`,
                             borderRadius: 8,
+                            boxSizing: 'border-box',
                             boxShadow: `0 0 0 1px rgba(255,255,255,.72), 0 6px 20px color-mix(in srgb, ${box.color} 20%, transparent)`,
                             height: box.height,
                             left: box.left,
@@ -227,7 +231,7 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
                                 /*#__PURE__*/ jsx("span", {
                                     children: box.label
                                 }),
-                                box.detail ? /*#__PURE__*/ jsx("span", {
+                                void 0 !== box.detail && '' !== box.detail ? /*#__PURE__*/ jsx("span", {
                                     style: {
                                         font: '700 10px/1.1 system-ui, sans-serif',
                                         opacity: 0.82,

package/dist/esm/cli/index.mjs

@@ -1,7 +1,7 @@
 import { cleanRequireCache, isReact18 as utils_isReact18 } from "@modern-js/utils";
 import path_0 from "path";
 import { documentPlugin } from "../document/cli/index.mjs";
-import { getEntrypointRoutesDir, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, routerPlugin } from "../router/cli/index.mjs";
+import { getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, routerPlugin } from "../router/cli/index.mjs";
 import { builderPluginAlias } from "./alias.mjs";
 import { generateCode } from "./code.mjs";
 import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME } from "./constants.mjs";
@@ -89,5 +89,7 @@ const runtimePlugin = (params)=>({
         }
     });
 const cli = runtimePlugin;
+export { makeLegalIdentifier } from "../router/cli/code/makeLegalIdentifier.mjs";
+export { getPathWithoutExt } from "../router/cli/code/utils.mjs";
 export default cli;
-export { documentPlugin, getEntrypointRoutesDir, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, isRuntimeEntry, routerPlugin, runtimePlugin, ssrPlugin };
+export { documentPlugin, getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, isRuntimeEntry, routerPlugin, runtimePlugin, ssrPlugin };

package/dist/esm/core/context/extensions.mjs

@@ -0,0 +1,28 @@
+const EXTENSIONS_SLOT = Symbol.for('@modern-js/runtime:context-extensions');
+function getStore(context) {
+    return context[EXTENSIONS_SLOT];
+}
+function ensureStore(context) {
+    const target = context;
+    target[EXTENSIONS_SLOT] ??= new Map();
+    return target[EXTENSIONS_SLOT];
+}
+function stripRuntimeContextExtensions(context) {
+    delete context[EXTENSIONS_SLOT];
+}
+function createRuntimeContextExtension(id) {
+    const key = Symbol.for(`@modern-js/runtime:context-extension:${id}`);
+    return {
+        key,
+        get (context) {
+            return getStore(context)?.get(key);
+        },
+        set (context, value) {
+            ensureStore(context).set(key, value);
+        },
+        remove (context) {
+            getStore(context)?.delete(key);
+        }
+    };
+}
+export { createRuntimeContextExtension, stripRuntimeContextExtensions };

package/dist/esm/core/context/helmetContext.mjs

@@ -0,0 +1,13 @@
+import { createRuntimeContextExtension } from "./extensions.mjs";
+const helmetContextExtension = createRuntimeContextExtension('@modern-js/runtime:helmet-context');
+function getHelmetContext(context) {
+    return helmetContextExtension.get(context);
+}
+function ensureHelmetContext(context) {
+    const existing = helmetContextExtension.get(context);
+    if (void 0 !== existing) return existing;
+    const created = {};
+    helmetContextExtension.set(context, created);
+    return created;
+}
+export { ensureHelmetContext, getHelmetContext };

package/dist/esm/core/context/index.mjs

@@ -40,6 +40,11 @@ function getGlobalLayoutApp() {
 function getGlobalBasename() {
     return globalContext.basename;
 }
+export { DefaultNotFound } from "../../router/runtime/DefaultNotFound.mjs";
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "../../router/runtime/hooks.mjs";
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
+export { registerRouterProvider, resolveRouterProvider, routerProviderRegistryHooks } from "../../router/runtime/provider.mjs";
+export { createRuntimeContextExtension } from "./extensions.mjs";
 export { InternalRuntimeContext, RuntimeContext, getInitialContext } from "./runtime.mjs";
 export { getServerPayload, setServerPayload } from "./serverPayload/index.mjs";
 export { getCurrentEntryName, getGlobalApp, getGlobalBasename, getGlobalEnableRsc, getGlobalInternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRSCRoot, getGlobalRoutes, setGlobalContext, setGlobalInternalRuntimeContext };

package/dist/esm/core/react/wrapper.mjs

@@ -1,24 +1,26 @@
 import { jsx } from "react/jsx-runtime";
 import { HelmetProvider } from "react-helmet-async";
 import { InternalRuntimeContext, RuntimeContext } from "../context/index.mjs";
+import { stripRuntimeContextExtensions } from "../context/extensions.mjs";
+import { ensureHelmetContext } from "../context/helmetContext.mjs";
 function wrapRuntimeContextProvider(App, contextValue) {
-    const { isBrowser, initialData, routes, routerFramework, context, routeManifest, routerRuntime, routerInstance, routerHydrationScript, routerMatchedRouteIds, routerServerSnapshot, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, _helmetContext, ...rest } = contextValue;
+    const { isBrowser, initialData, routes, context, routeManifest, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, ...rest } = contextValue;
     const internalContextValue = contextValue;
-    internalContextValue._helmetContext ??= {};
+    const helmetContext = ensureHelmetContext(internalContextValue);
     const runtimeContextValue = {
         isBrowser,
         initialData,
         routes,
-        routerFramework,
         context,
         ...rest
     };
+    stripRuntimeContextExtensions(runtimeContextValue);
     return /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
         value: internalContextValue,
         children: /*#__PURE__*/ jsx(RuntimeContext.Provider, {
             value: runtimeContextValue,
             children: /*#__PURE__*/ jsx(HelmetProvider, {
-                context: internalContextValue._helmetContext,
+                context: helmetContext,
                 children: App
             })
         })

package/dist/esm/core/server/federatedCss.mjs

@@ -1,10 +1,10 @@
 import { attributesToString } from "./utils.mjs";
 const createFederatedCssLinks = (assets, options)=>{
-    if (!assets?.length) return '';
+    if (void 0 === assets || 0 === assets.length) return '';
     const seen = new Set(options.existingAssets || []);
     const attributes = attributesToString(options.attributes || {});
     const links = [];
-    for (const asset of assets)if (!(!asset || seen.has(asset) || options.template.includes(asset))) {
+    for (const asset of assets)if (!('' === asset || seen.has(asset) || options.template.includes(asset))) {
         seen.add(asset);
         links.push(`<link${attributes} href="${asset}" rel="stylesheet" />`);
     }

package/dist/esm/core/server/helmet.mjs

@@ -1,3 +1,4 @@
+import { getHelmetContext } from "../context/helmetContext.mjs";
 import { safeReplace } from "./utils.mjs";
 const EOL = '\n';
 const RE_HTML_ATTR = /<html[^>]*>/;
@@ -6,7 +7,7 @@ const RE_LAST_IN_HEAD = /<\/head>/;
 const RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
 const TEST_TITLE_CONTENT = /(?<=<title[^>]*>)([\s\S\n\r]*?)([.|\S])([\s\S\n\r]*?)(?=<\/title>)/;
 function getHelmetData(runtimeContext) {
-    return runtimeContext._helmetContext?.helmet ?? void 0;
+    return getHelmetContext(runtimeContext)?.helmet ?? void 0;
 }
 function createReplaceHelemt(helmetData) {
     return helmetData ? (template)=>helmetReplace(template, helmetData) : (tempalte)=>tempalte;

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

@@ -2,13 +2,14 @@ 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 { getRouterServerSnapshot } 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 { withRouterCleanup } from "./routerCleanup.mjs";
 import { SSRErrors } from "./tracer.mjs";
 import { getSSRConfigByEntry, getSSRMode } from "./utils.mjs";
 async function handleRSCRequest(request, Root, context, options, handleRequest) {
@@ -37,6 +38,39 @@ const processRedirect = (headers, status, ctx)=>{
         headers
     });
 };
+const applyRouterSnapshotResult = (context, onError)=>{
+    const routerServerSnapshot = getRouterServerSnapshot(context);
+    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) onError(errors[0], SSRErrors.LOADER_ERROR);
+};
+const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
+    if (!beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
+    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
+    const redirectUrl = beforeRenderResult.headers.get('Location') || '/';
+    return processRedirect(new Headers({
+        Location: redirectUrl
+    }), beforeRenderResult.status, redirectCtx);
+};
+const renderRequest = async (request, Root, context, options, handleRequest, enableRsc)=>{
+    if (enableRsc) return handleRSCRequest(request, Root, context, options, handleRequest);
+    return handleRequest(request, Root, {
+        ...options,
+        runtimeContext: context
+    });
+};
+const finalizeRenderResponse = (response, responseProxy, redirectCtx, routerCleanup)=>{
+    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 routerCleanup.deferUntilBodyDone(new Response(response.body, {
+        status: responseProxy.status,
+        headers: response.headers
+    }));
+    return routerCleanup.deferUntilBodyDone(response);
+};
 function createSSRContext(request, options) {
     const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, reporter } = options;
     const { nonce, useJsonScript } = config;
@@ -132,41 +166,20 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
                 isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
                 basename: ssrContext.baseUrl || '/'
             };
-            try {
+            return withRouterCleanup(context, options.onError, async (routerCleanup)=>{
                 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);
+                applyRouterSnapshotResult(context, options.onError);
+                if ("u" > typeof Response) {
+                    const redirectResponse = createLoaderRedirectResponse(beforeRenderResult, redirectCtx);
+                    if (redirectResponse) return redirectResponse;
                 }
                 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);
-            }
+                const response = await renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc);
+                return finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup);
+            });
         });
     };
     return requestHandler;

package/dist/esm/core/server/routerCleanup.mjs

@@ -0,0 +1,66 @@
+import { getRouterRuntimeState } from "../../router/runtime/lifecycle.mjs";
+const ROUTER_CLEANUP_ERROR = 'An error occurs during router runtime cleanup';
+async function withRouterCleanup(runtimeContext, onError, callback) {
+    const routerCleanup = createRouterCleanup(runtimeContext, onError);
+    try {
+        return await callback(routerCleanup);
+    } finally{
+        if (!routerCleanup.deferred) await routerCleanup.run();
+    }
+}
+function createRouterCleanup(runtimeContext, onError) {
+    let deferred = false;
+    let finished = false;
+    const run = async ()=>{
+        if (finished) return;
+        finished = true;
+        try {
+            await getRouterRuntimeState(runtimeContext)?.cleanup?.();
+        } catch (error) {
+            onError(error, ROUTER_CLEANUP_ERROR);
+        }
+    };
+    const deferUntilBodyDone = (response)=>{
+        const { body } = response;
+        if (!body || body.locked) return response;
+        deferred = true;
+        const reader = body.getReader();
+        const wrappedBody = new ReadableStream({
+            async pull (controller) {
+                let result;
+                try {
+                    result = await reader.read();
+                } catch (error) {
+                    controller.error(error);
+                    await run();
+                    return;
+                }
+                if (result.done) {
+                    controller.close();
+                    await run();
+                    return;
+                }
+                controller.enqueue(result.value);
+            },
+            async cancel (reason) {
+                try {
+                    await reader.cancel(reason);
+                } catch  {}
+                await run();
+            }
+        });
+        return new Response(wrappedBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+    };
+    return {
+        get deferred () {
+            return deferred;
+        },
+        run,
+        deferUntilBodyDone
+    };
+}
+export { ROUTER_CLEANUP_ERROR, createRouterCleanup, withRouterCleanup };

package/dist/esm/core/server/scriptOrder.mjs

@@ -1,3 +1,6 @@
+import { getRouterMatchedRouteIds } from "../../router/runtime/lifecycle.mjs";
+import { CHUNK_JS_PLACEHOLDER } from "./constants.mjs";
+import { safeReplace } from "./utils.mjs";
 function getScriptTags(template) {
     const scriptRegExp = /<script\b[^>]*\bsrc=(["'])(.*?)\1[^>]*><\/script>/g;
     return Array.from(template.matchAll(scriptRegExp)).map((match)=>({
@@ -15,11 +18,67 @@ function isEntryScript(src, entryName, asyncEntry) {
     const prefix = asyncEntry ? `async-${entryName}` : entryName;
     return basename === `${prefix}.js` || basename.startsWith(`${prefix}.`) || basename.startsWith(`${prefix}-`);
 }
+const dedupeByUrl = (chunks)=>{
+    const seen = new Set();
+    return chunks.filter((chunk)=>{
+        if (void 0 === chunk.url || '' === chunk.url || seen.has(chunk.url)) return false;
+        seen.add(chunk.url);
+        return true;
+    });
+};
+const isAsyncEntryScriptChunk = (chunk, entryName)=>{
+    if (void 0 === chunk.url || !chunk.url.endsWith('.js')) return false;
+    const asyncEntryName = `async-${entryName}`;
+    const filename = chunk.filename ?? chunk.url;
+    const basename = filename.split('/').pop() ?? filename;
+    return basename === `${asyncEntryName}.js` || basename.startsWith(`${asyncEntryName}.`) || basename.startsWith(`${asyncEntryName}-`);
+};
+function getRouteAssets(runtimeContext, routeManifest = runtimeContext.routeManifest) {
+    return routeManifest?.routeAssets;
+}
+function getMatchedRouteAssets(runtimeContext, routeManifest) {
+    const routeAssets = getRouteAssets(runtimeContext, routeManifest);
+    if (void 0 === routeAssets) return [];
+    const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
+    return matchedRouteIds.flatMap((routeId)=>routeAssets[routeId]?.assets ?? []);
+}
+const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{
+    const asyncEntryScriptChunks = [];
+    const asyncEntryDependencyChunks = [];
+    for (const chunk of asyncEntryChunks)if (isAsyncEntryScriptChunk(chunk, entryName)) asyncEntryScriptChunks.push(chunk);
+    else asyncEntryDependencyChunks.push(chunk);
+    return dedupeByUrl([
+        ...asyncEntryDependencyChunks,
+        ...collectedChunks,
+        ...matchedRouteChunks,
+        ...asyncEntryScriptChunks
+    ]);
+};
 function injectBeforeHydrationEntryScript(template, scripts, entryName = 'index') {
-    if (!scripts) return template;
+    if ('' === scripts) return template;
     const scriptTags = getScriptTags(template);
     const target = scriptTags.find((match)=>isEntryScript(match.src, entryName, false)) ?? scriptTags.find((match)=>isEntryScript(match.src, entryName, true));
-    if (!target) return template;
+    if (void 0 === target) return template;
     return `${template.slice(0, target.index)}${scripts}${template.slice(target.index)}`;
 }
-export { injectBeforeHydrationEntryScript };
+function replaceChunkJsPlaceholder(template, scripts, entryName, placeholder = CHUNK_JS_PLACEHOLDER) {
+    if ('' === scripts) return safeReplace(template, placeholder, '');
+    const withoutPlaceholder = safeReplace(template, placeholder, '');
+    const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, scripts, entryName);
+    if (withEarlyScripts !== withoutPlaceholder) return withEarlyScripts;
+    return safeReplace(template, placeholder, scripts);
+}
+function createRouteHydrationScriptTags(runtimeContext, entryName, options = {}) {
+    const { nonce, template } = options;
+    const routeAssets = getRouteAssets(runtimeContext);
+    if (void 0 === routeAssets) return '';
+    const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
+    const assetEntries = [
+        ...matchedRouteIds.map((routeId)=>routeAssets[routeId]),
+        routeAssets[`async-${entryName}`]
+    ].filter((entry)=>void 0 !== entry);
+    const jsAssets = Array.from(new Set(assetEntries.flatMap((entry)=>(entry.assets ?? []).filter((asset)=>asset.endsWith('.js')))));
+    const nonceAttr = void 0 === nonce || '' === nonce ? '' : ` nonce="${nonce}"`;
+    return jsAssets.filter((asset)=>template?.includes(asset) !== true).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
+}
+export { createRouteHydrationScriptTags, getMatchedRouteAssets, injectBeforeHydrationEntryScript, orderHydrationScriptChunks, replaceChunkJsPlaceholder };

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

@@ -1,8 +1,8 @@
 import { serializeJson } from "@modern-js/runtime-utils/node";
-import { getRouterHydrationScripts, getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
+import { getRouterHydrationScripts } from "../../../router/runtime/lifecycle.mjs";
 import { SSR_DATA_JSON_ID } from "../../constants.mjs";
 import { SSR_DATA_PLACEHOLDER } from "../constants.mjs";
-import { injectBeforeHydrationEntryScript } from "../scriptOrder.mjs";
+import { createRouteHydrationScriptTags, replaceChunkJsPlaceholder } from "../scriptOrder.mjs";
 import { buildHtml } from "../shared.mjs";
 import { attributesToString, safeReplace } from "../utils.mjs";
 function buildShellAfterTemplate(afterAppTemplate, options) {
@@ -19,24 +19,12 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
         (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 matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
-        const assetEntries = [
-            ...matchedRouteIds.map((routeId)=>routeAssets[routeId]),
-            routeAssets[`async-${entryName}`]
-        ].filter(Boolean);
-        const jsAssets = Array.from(new Set(assetEntries.flatMap((entry)=>(entry.assets ?? []).filter((asset)=>asset.endsWith('.js')))));
-        const nonceAttr = nonce ? ` nonce="${nonce}"` : '';
-        const jsChunkStr = jsAssets.filter((asset)=>!template.includes(asset)).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
-        if (jsChunkStr) {
-            const withoutPlaceholder = safeReplace(template, '<!--<?- chunksMap.js ?>-->', '');
-            const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, jsChunkStr, entryName);
-            return withEarlyScripts !== withoutPlaceholder ? withEarlyScripts : safeReplace(template, '<!--<?- chunksMap.js ?>-->', jsChunkStr);
-        }
-        return template;
+        const jsChunkStr = createRouteHydrationScriptTags(runtimeContext, entryName, {
+            nonce,
+            template
+        });
+        if (!jsChunkStr) return template;
+        return replaceChunkJsPlaceholder(template, jsChunkStr, entryName);
     }
     return buildHtml(afterAppTemplate, callbacks);
 }

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

@@ -4,7 +4,7 @@ import { CHUNK_CSS_PLACEHOLDER } from "../constants.mjs";
 import { createFederatedCssLinks } from "../federatedCss.mjs";
 import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
 import { buildHtml } from "../shared.mjs";
-import { checkIsNode, safeReplace } from "../utils.mjs";
+import { checkIsNode, hasStylesheetLink, safeReplace } from "../utils.mjs";
 const readAsset = async (chunk)=>{
     const fs = await import("fs/promises");
     const path = await import("path");
@@ -45,13 +45,13 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
                     if (!index) return;
                     const routeId = match.route.id;
                     if (routeId) return routeAssets[routeId];
-                }).filter(Boolean) ?? [];
+                }).filter((routeManifest)=>void 0 !== routeManifest) ?? [];
             }
             const asyncEntry = routeAssets[`async-${entryName}`];
             if (asyncEntry) matchedRouteManifests.push(asyncEntry);
             const cssChunks = matchedRouteManifests.reduce((chunks, routeManifest)=>{
                 const { referenceCssAssets = [] } = routeManifest;
-                const _cssChunks = referenceCssAssets.filter((asset)=>asset?.endsWith('.css') && !template.includes(asset));
+                const _cssChunks = referenceCssAssets.filter((asset)=>asset?.endsWith('.css') && !hasStylesheetLink(template, asset));
                 return [
                     ...chunks,
                     ..._cssChunks

package/dist/esm/core/server/stream/beforeTemplate.worker.mjs

@@ -39,7 +39,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
                     if (!index) return;
                     const routeId = match.route.id;
                     if (routeId) return routeAssets[routeId];
-                }).filter(Boolean) ?? [];
+                }).filter((routeManifest)=>void 0 !== routeManifest) ?? [];
             }
             const asyncEntry = routeAssets[`async-${entryName}`];
             if (asyncEntry) matchedRouteManifests.push(asyncEntry);

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

@@ -64,12 +64,14 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                             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, '');
+                                    const concatedChunk = Buffer.concat(chunkVec).toString('utf-8');
+                                    const markerIndex = concatedChunk.indexOf(ESCAPED_SHELL_STREAM_END_MARK);
+                                    if (-1 !== markerIndex) {
+                                        const beforeMark = concatedChunk.slice(0, markerIndex);
+                                        const afterMark = concatedChunk.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
                                         shellChunkStatus = ShellChunkStatus.FINISH;
-                                        this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
+                                        this.push(`${shellBefore}${beforeMark}${shellAfter}`);
+                                        if (afterMark) this.push(afterMark);
                                         if (pendingScripts.length > 0) for (const s of pendingScripts)this.push(s);
                                     }
                                 } else this.push(chunk);