@bleedingdev/modern-js-runtime 3.8.3-ultramodern.1 → 3.8.3-ultramodern.2

package/dist/cjs/cli/ssr/loadable-bundler-plugin.js

@@ -54,7 +54,7 @@ class LoadablePlugin {
         const chunkLoadingGlobal = this.opts.chunkLoadingGlobal ?? compiler.options.output.chunkLoadingGlobal ?? DEFAULT_CHUNK_LOADING_GLOBAL;
         compiler.options.output.chunkLoadingGlobal = chunkLoadingGlobal;
         new compiler.webpack.DefinePlugin({
-            'process.env.MODERN_CHUNK_LOADING_GLOBAL': JSON.stringify(chunkLoadingGlobal)
+            __MODERN_CHUNK_LOADING_GLOBAL__: JSON.stringify(chunkLoadingGlobal)
         }).apply(compiler);
         if (this.opts.outputAsset || this.opts.writeToDisk) compiler.hooks.make.tap(LoadablePlugin.name, (compilation)=>{
             compilation.hooks.processAssets.tap({

package/dist/cjs/core/browser/hydrate.js

@@ -38,18 +38,8 @@ const client_namespaceObject = require("react-dom/client");
 const external_constants_js_namespaceObject = require("../constants.js");
 const wrapper_js_namespaceObject = require("../react/wrapper.js");
 const external_withCallback_js_namespaceObject = require("./withCallback.js");
-const runtimeProcess = Reflect.get(globalThis, 'process');
-const runtimeEnvironment = null !== runtimeProcess && 'object' == typeof runtimeProcess ? Reflect.get(runtimeProcess, 'env') : void 0;
-const readRuntimeEnvironment = (name)=>{
-    if (null === runtimeEnvironment || 'object' != typeof runtimeEnvironment) return;
-    const value = Reflect.get(runtimeEnvironment, name);
-    return 'string' == typeof value ? value : void 0;
-};
 const loadableReadyOptions = {
-    chunkLoadingGlobal: (()=>{
-        const configured = readRuntimeEnvironment('MODERN_CHUNK_LOADING_GLOBAL');
-        return void 0 === configured || '' === configured ? '__LOADABLE_LOADED_CHUNKS__' : configured;
-    })()
+    chunkLoadingGlobal: 'string' == typeof __MODERN_CHUNK_LOADING_GLOBAL__ && '' !== __MODERN_CHUNK_LOADING_GLOBAL__ ? __MODERN_CHUNK_LOADING_GLOBAL__ : '__LOADABLE_LOADED_CHUNKS__'
 };
 function hydrateWithReact(App, rootElement) {
     return Promise.resolve((0, client_namespaceObject.hydrateRoot)(rootElement, App, {

package/dist/cjs/core/context/extensions.js

@@ -33,8 +33,13 @@ function getStore(context) {
 }
 function ensureStore(context) {
     const target = context;
-    target[EXTENSIONS_SLOT] ??= new Map();
-    return target[EXTENSIONS_SLOT];
+    const store = target[EXTENSIONS_SLOT] ?? new Map();
+    Object.defineProperty(target, EXTENSIONS_SLOT, {
+        configurable: true,
+        enumerable: true,
+        value: store
+    });
+    return store;
 }
 function stripRuntimeContextExtensions(context) {
     delete context[EXTENSIONS_SLOT];

package/dist/cjs/core/context/runtime.js

@@ -40,8 +40,19 @@ const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
 const InternalRuntimeContext = (0, external_react_namespaceObject.createContext)({});
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
-        request: {},
-        response: {}
+        request: {
+            params: {},
+            pathname: '',
+            query: {},
+            headers: {},
+            host: '',
+            url: ''
+        },
+        response: {
+            setHeader () {},
+            status () {},
+            locals: {}
+        }
     };
     return {
         isBrowser,

package/dist/cjs/core/react/wrapper.js

@@ -36,12 +36,14 @@ const index_js_namespaceObject = require("../context/index.js");
 const extensions_js_namespaceObject = require("../context/extensions.js");
 const helmetContext_js_namespaceObject = require("../context/helmetContext.js");
 function createRscSafeRequestContext(ssrContext) {
-    if (void 0 === ssrContext) return {
-        request: {},
-        response: {
-            locals: {}
-        }
-    };
+    const requestContext = (0, index_js_namespaceObject.getInitialContext)().requestContext;
+    Object.defineProperty(requestContext.response, 'setHeader', {
+        enumerable: false
+    });
+    Object.defineProperty(requestContext.response, 'status', {
+        enumerable: false
+    });
+    if (void 0 === ssrContext) return requestContext;
     const { request, response } = ssrContext;
     return {
         request: {
@@ -61,9 +63,9 @@ function createRscSafeRequestContext(ssrContext) {
             host: request.host,
             referer: request.referer
         },
-        response: {
+        response: Object.assign(requestContext.response, {
             locals: response.locals ?? {}
-        }
+        })
     };
 }
 function wrapRuntimeContextProvider(App, contextValue) {

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

@@ -30,16 +30,19 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createFederatedCssLinks: ()=>createFederatedCssLinks
 });
+const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const external_utils_js_namespaceObject = require("./utils.js");
-const escapeHtmlAttribute = (value)=>value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
 const createFederatedCssLinks = (assets, options)=>{
     if (void 0 === assets || 0 === assets.length) return '';
     const seen = new Set(options.existingAssets || []);
-    const attributes = (0, external_utils_js_namespaceObject.attributesToString)(options.attributes || {});
+    const attributes = (0, external_utils_js_namespaceObject.attributesToString)(Object.fromEntries(Object.entries(options.attributes || {}).filter(([name])=>![
+            'href',
+            'rel'
+        ].includes(name.toLowerCase()))));
     const links = [];
     for (const asset of assets){
-        const href = escapeHtmlAttribute(asset);
-        if (!('' === asset || seen.has(asset) || options.template.includes(asset) || options.template.includes(href))) {
+        const href = (0, runtime_extensions_namespaceObject.escapeHtmlAttribute)(asset);
+        if (!('' === asset || seen.has(asset) || (0, external_utils_js_namespaceObject.hasStylesheetLink)(options.template, asset) || (0, external_utils_js_namespaceObject.hasStylesheetLink)(options.template, href))) {
             seen.add(asset);
             links.push(`<link${attributes} href="${href}" rel="stylesheet" />`);
         }

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

@@ -53,6 +53,7 @@ function helmetReplace(content, helmetData) {
     const htmlAttributes = helmetData.htmlAttributes.toString();
     if (htmlAttributes) result = (0, external_utils_js_namespaceObject.safeReplace)(result, RE_HTML_ATTR, `<html ${htmlAttributes}>`);
     const base = helmetData.base.toString();
+    const priority = helmetData.priority.toString();
     const link = helmetData.link.toString();
     const meta = helmetData.meta.toString();
     const noscript = helmetData.noscript.toString();
@@ -64,6 +65,7 @@ function helmetReplace(content, helmetData) {
     if (shouldReplaceTitle) result = (0, external_utils_js_namespaceObject.safeReplace)(result, RE_TITLE, title);
     const helmetStr = [
         base,
+        priority,
         link,
         meta,
         noscript,

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

@@ -35,9 +35,15 @@ __webpack_require__.d(__webpack_exports__, {
 const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
 const redirect_js_namespaceObject = require("../../router/runtime/redirect.js");
 const external_tracer_js_namespaceObject = require("./tracer.js");
-const isRedirectStatus = (status)=>status >= 300 && status <= 399;
+const isRedirectStatus = (status)=>301 === status || 302 === status || 303 === status || 307 === status || 308 === status;
 const isNullBodyStatus = (status)=>204 === status || 205 === status || 304 === status;
+const getRedirectLocation = (headers)=>{
+    const location = headers.get('Location');
+    return location && URL.canParse(location, 'http://localhost') ? location : void 0;
+};
 const processRedirect = (headers, status, ctx)=>{
+    headers.delete('content-length');
+    headers.delete('transfer-encoding');
     if (ctx.enableRsc && ctx.isRSCNavigation) return (0, redirect_js_namespaceObject.handleRSCRedirect)(headers, ctx.basename, status);
     return new Response(null, {
         status,
@@ -54,20 +60,38 @@ const applyRouterSnapshotResult = (context, onError)=>{
 const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
     if (void 0 === 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 redirectUrl = getRedirectLocation(beforeRenderResult.headers);
+    if (!redirectUrl) return;
+    return processRedirect(new Headers(beforeRenderResult.headers), beforeRenderResult.status, redirectCtx);
 };
-const finalizeRenderResponse = (response, responseProxy, redirectCtx, routerCleanup)=>{
-    if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && void 0 !== responseProxy.headers.Location && '' !== responseProxy.headers.Location) return processRedirect(new Headers(responseProxy.headers), responseProxy.status, redirectCtx);
+const finalizeRenderResponse = async (response, responseProxy, redirectCtx, routerCleanup)=>{
+    const proxyHeaders = new Headers(responseProxy.headers);
+    if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && void 0 !== getRedirectLocation(proxyHeaders)) {
+        await routerCleanup.discardBody(response);
+        return processRedirect(proxyHeaders, responseProxy.status, redirectCtx);
+    }
+    const headers = new Headers(response.headers);
+    Object.entries(responseProxy.headers).forEach(([key, value])=>{
+        headers.set(key, value);
+    });
+    if (-1 !== responseProxy.status) {
+        if (isNullBodyStatus(responseProxy.status)) {
+            await routerCleanup.discardBody(response);
+            headers.delete('content-length');
+            headers.delete('transfer-encoding');
+            return new Response(null, {
+                status: responseProxy.status,
+                headers
+            });
+        }
+        return routerCleanup.deferUntilBodyDone(new Response(response.body, {
+            status: responseProxy.status,
+            headers
+        }));
+    }
     Object.entries(responseProxy.headers).forEach(([key, value])=>{
         response.headers.set(key, value);
     });
-    if (-1 !== responseProxy.status) return routerCleanup.deferUntilBodyDone(new Response(isNullBodyStatus(responseProxy.status) ? null : response.body, {
-        status: responseProxy.status,
-        headers: response.headers
-    }));
     return routerCleanup.deferUntilBodyDone(response);
 };
 exports.applyRouterSnapshotResult = __webpack_exports__.applyRouterSnapshotResult;

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

@@ -97,12 +97,21 @@ function createRouterCleanup(runtimeContext, onError) {
             headers: response.headers
         });
     };
+    const discardBody = async (response)=>{
+        const { body } = response;
+        if (!body) return void await run();
+        deferred = true;
+        if (body.locked) throw new TypeError('Cannot discard a locked response body before router cleanup');
+        await body.cancel('Response body discarded during finalization');
+        await run();
+    };
     return {
         get deferred () {
             return deferred;
         },
         run,
-        deferUntilBodyDone
+        deferUntilBodyDone,
+        discardBody
     };
 }
 exports.ROUTER_CLEANUP_ERROR = __webpack_exports__.ROUTER_CLEANUP_ERROR;

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

@@ -102,6 +102,7 @@ function injectBeforeHydrationEntryScript(template, scripts, entryName = 'index'
     return `${template.slice(0, target.index)}${scripts}${template.slice(target.index)}`;
 }
 function replaceChunkJsPlaceholder(template, scripts, entryName, placeholder = external_constants_js_namespaceObject.CHUNK_JS_PLACEHOLDER) {
+    if (!template.includes(placeholder)) return template;
     if ('' === scripts) return (0, external_utils_js_namespaceObject.safeReplace)(template, placeholder, '');
     const withoutPlaceholder = (0, external_utils_js_namespaceObject.safeReplace)(template, placeholder, '');
     const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, scripts, entryName);
@@ -117,8 +118,10 @@ function createRouteHydrationScriptTags(runtimeContext, entryName, options = {})
         ...getMatchedRouteAssets(runtimeContext),
         ...routeAssets[`async-${entryName}`]?.assets ?? []
     ].filter((asset)=>asset.endsWith('.js'))));
-    const nonceAttr = void 0 === nonce || '' === nonce ? '' : ` nonce="${nonce}"`;
-    return jsAssets.filter((asset)=>!existingScriptSrcs.has(asset)).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
+    return jsAssets.filter((asset)=>!existingScriptSrcs.has(asset)).map((asset)=>`<script${(0, external_utils_js_namespaceObject.attributesToString)({
+            src: asset,
+            nonce: nonce || void 0
+        })}></script>`).join(' ');
 }
 exports.createRouteHydrationScriptTags = __webpack_exports__.createRouteHydrationScriptTags;
 exports.getMatchedRouteChunks = __webpack_exports__.getMatchedRouteChunks;

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

@@ -68,7 +68,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
             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') && !(0, external_utils_js_namespaceObject.hasStylesheetLink)(template, asset));
                 return [
                     ...chunks,
                     ..._cssChunks

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

@@ -30,13 +30,15 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createReadableStreamFromElement: ()=>createReadableStreamFromElement
 });
-const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const node_namespaceObject = require("@modern-js/runtime-extensions/node");
+const runtime_utils_node_namespaceObject = require("@modern-js/runtime-utils/node");
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const external_stream_namespaceObject = require("stream");
 const external_common_js_namespaceObject = require("../../../common.js");
 const external_constants_js_namespaceObject = require("../../constants.js");
 const index_js_namespaceObject = require("../../context/index.js");
 const monitors_index_js_namespaceObject = require("../../context/monitors/index.js");
+const external_helmet_js_namespaceObject = require("../helmet.js");
 const external_deferredScript_js_namespaceObject = require("./deferredScript.js");
 const external_shared_js_namespaceObject = require("./shared.js");
 const external_template_js_namespaceObject = require("./template.js");
@@ -68,6 +70,8 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
     });
     const chunkVec = [];
     let hasStartedPipe = false;
+    node_namespaceObject.beginHeadRender(runtimeContext);
+    const reportError = node_namespaceObject.createOnceErrorReporter(options.onError);
     return new Promise((resolve)=>{
         const { pipe: reactStreamingPipe } = renderToPipeableStream(processedRootElement, {
             nonce: config.nonce,
@@ -101,8 +105,10 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                                     if (-1 !== markerIndex) {
                                         const beforeMark = concatedChunk.slice(0, markerIndex);
                                         const afterMark = concatedChunk.slice(markerIndex + external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK.length);
+                                        node_namespaceObject.publishHeadRender(runtimeContext);
+                                        const completedShellBefore = (0, external_helmet_js_namespaceObject.createReplaceHelemt)((0, external_helmet_js_namespaceObject.getHelmetData)(runtimeContext))(shellBefore);
                                         shellChunkStatus = external_shared_js_namespaceObject.ShellChunkStatus.FINISH;
-                                        this.push(`${shellBefore}${beforeMark}${shellAfter}`);
+                                        this.push(`${completedShellBefore}${beforeMark}${shellAfter}`);
                                         if (afterMark) this.push(afterMark);
                                         if (pendingScripts.length > 0) for (const s of pendingScripts)this.push(s);
                                     }
@@ -120,10 +126,16 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                     extenders.forEach((extender)=>{
                         if (extender.processStream) processedStream = extender.processStream(processedStream);
                     });
+                    node_namespaceObject.pipeNodeHeadStream({
+                        source: processedStream,
+                        destination: body,
+                        context: runtimeContext,
+                        terminalMarker: external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK,
+                        onError: reportError
+                    });
                     reactStreamingPipe(passThrough);
-                    processedStream.pipe(body);
                     try {
-                        const storageContext = node_namespaceObject.storage.useContext?.();
+                        const storageContext = runtime_utils_node_namespaceObject.storage.useContext?.();
                         const activeDeferreds = storageContext?.activeDeferreds;
                         const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
                         if (entries.length > 0) {
@@ -140,6 +152,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                 });
             },
             onShellError (error) {
+                node_namespaceObject.abortHeadRender(runtimeContext);
                 renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
                 (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
                     request,
@@ -158,7 +171,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             },
             onError (error) {
                 renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
-                options?.onError?.(error);
+                reportError(error);
             }
         });
     });

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

@@ -31,9 +31,11 @@ __webpack_require__.d(__webpack_exports__, {
     createReadableStreamFromElement: ()=>createReadableStreamFromElement
 });
 const ssr_namespaceObject = require("@modern-js/render/ssr");
+const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
 const external_common_js_namespaceObject = require("../../../common.js");
 const external_constants_js_namespaceObject = require("../../constants.js");
+const external_helmet_js_namespaceObject = require("../helmet.js");
 const external_deferredScript_js_namespaceObject = require("./deferredScript.js");
 const external_shared_js_namespaceObject = require("./shared.js");
 const external_template_js_namespaceObject = require("./template.js");
@@ -41,6 +43,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
     let shellChunkStatus = external_shared_js_namespaceObject.ShellChunkStatus.START;
     const chunkVec = [];
     const { htmlTemplate, runtimeContext, config, ssrConfig, entryName, moduleFederationCssAssets, rscManifest, rscRoot } = options;
+    runtime_extensions_namespaceObject.beginHeadRender(runtimeContext);
     const { shellBefore, shellAfter } = await (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
         renderLevel: external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER,
         runtimeContext,
@@ -68,7 +71,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         const forceStreamToString = Boolean("u" > typeof process && process.env?.MODERN_JS_STREAM_TO_STRING);
         const { waitForAllReady } = (0, external_shared_js_namespaceObject.resolveStreamingMode)(request, forceStreamToString);
         if (waitForAllReady) await readableOriginal.allReady;
-        const reader = readableOriginal.getReader();
+        const reader = runtime_extensions_namespaceObject.createConservingWebShellStream(readableOriginal, runtimeContext, external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK, options.onError).getReader();
         const stream = new ReadableStream({
             start (controller) {
                 const pendingScripts = [];
@@ -113,14 +116,17 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                             if (-1 !== markerIndex) {
                                 const beforeMark = concatedChunk.slice(0, markerIndex);
                                 const afterMark = concatedChunk.slice(markerIndex + external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK.length);
+                                runtime_extensions_namespaceObject.publishHeadRender(runtimeContext);
+                                const completedShellBefore = (0, external_helmet_js_namespaceObject.createReplaceHelemt)((0, external_helmet_js_namespaceObject.getHelmetData)(runtimeContext))(shellBefore);
                                 shellChunkStatus = external_shared_js_namespaceObject.ShellChunkStatus.FINISH;
-                                safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(`${shellBefore}${beforeMark}${shellAfter}`));
+                                safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(`${completedShellBefore}${beforeMark}${shellAfter}`));
                                 if (afterMark.length > 0) safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(afterMark));
                                 flushPendingScripts();
                             }
                         } else safeEnqueue(value);
                         if (!isClosed) push();
                     } catch (error) {
+                        runtime_extensions_namespaceObject.abortHeadRender(runtimeContext);
                         if (!isClosed) {
                             isClosed = true;
                             try {
@@ -132,11 +138,13 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                 push();
             },
             cancel (reason) {
+                runtime_extensions_namespaceObject.abortHeadRender(runtimeContext);
                 reader.cancel(reason).catch(()=>{});
             }
         });
         return stream;
     } catch (e) {
+        runtime_extensions_namespaceObject.abortHeadRender(runtimeContext);
         const fallbackHtml = `${shellBefore}${shellAfter}`;
         const stream = (0, external_shared_js_namespaceObject.getReadableStreamFromString)(fallbackHtml);
         return stream;

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

@@ -37,6 +37,7 @@ __webpack_require__.d(__webpack_exports__, {
     toErrorInfo: ()=>toErrorInfo
 });
 const constants_js_namespaceObject = require("../../../router/runtime/constants.js");
+const external_utils_js_namespaceObject = require("../utils.js");
 const HTML_ESCAPE_MAP = {
     '&': '&',
     '<': '&lt;',
@@ -60,7 +61,7 @@ function isPromiseLike(value) {
     return !!value && 'function' == typeof value.then;
 }
 function toErrorInfo(error) {
-    if ('production' === process.env.NODE_ENV) return {
+    if ((0, external_utils_js_namespaceObject.shouldRedactServerError)()) return {
         message: 'Unexpected Server Error'
     };
     if (error && 'object' == typeof error) {

package/dist/cjs/core/server/string/index.js

@@ -39,6 +39,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     renderString: ()=>renderString
 });
+const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const time_namespaceObject = require("@modern-js/runtime-utils/time");
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const server_namespaceObject = require("react-dom/server");
@@ -108,16 +109,19 @@ async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifie
     let html = '';
     let helmetData;
     const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
+    runtime_extensions_namespaceObject.beginHeadRender(runtimeContext);
     try {
         const end = (0, time_namespaceObject.time)();
         html = server_default().renderToString(finalApp, {
             identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
         });
+        html = runtime_extensions_namespaceObject.completeHeadRender(runtimeContext, html);
         chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
         helmetData = (0, external_helmet_js_namespaceObject.getHelmetData)(runtimeContext);
         const cost = end();
         onTiming(external_tracer_js_namespaceObject.SSRTimings.RENDER_HTML, cost);
     } catch (e) {
+        runtime_extensions_namespaceObject.abortHeadRender(runtimeContext);
         chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
         onError(e, external_tracer_js_namespaceObject.SSRErrors.RENDER_HTML);
     }

package/dist/cjs/core/server/string/loadable.js

@@ -60,6 +60,10 @@ const readAsset = async (chunk)=>{
     return fs.readFile(filepath, 'utf-8');
 };
 class LoadableCollector {
+    get existsAssets() {
+        const { routeManifest, entryName } = this.options;
+        return routeManifest?.routeAssets?.[entryName]?.assets;
+    }
     collect(comopnent) {
         const { stats, entryName } = this.options;
         if (!stats) return comopnent;
@@ -121,7 +125,7 @@ class LoadableCollector {
         const matchs = template.matchAll(jsScriptRegExp);
         const existedScript = [];
         for (const match of matchs)existedScript.push(match[1]);
-        const scripts = await Promise.all(chunks.filter((chunk)=>!existedScript.includes(chunk.url)).map(async (chunk)=>{
+        const scripts = await Promise.all(chunks.filter((chunk)=>!existedScript.includes(chunk.url) && !this.existsAssets?.includes(chunk.path)).map(async (chunk)=>{
             const script = `<script${attributes} src="${chunk.url}"></script>`;
             if ((0, external_utils_js_namespaceObject.checkIsNode)() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<script>${content}</script>`).catch((_)=>script);
             return script;
@@ -132,7 +136,12 @@ class LoadableCollector {
         const { template, chunkSet, config, moduleFederationCssAssets } = this.options;
         const { inlineStyles } = config;
         const atrributes = (0, external_utils_js_namespaceObject.attributesToString)(this.generateAttributes());
-        const emittedChunks = chunks.filter((chunk)=>!(0, external_utils_js_namespaceObject.hasStylesheetLink)(template, chunk.url));
+        const emittedAssetUrls = new Set();
+        const emittedChunks = chunks.filter((chunk)=>{
+            const shouldEmit = !(0, external_utils_js_namespaceObject.hasStylesheetLink)(template, chunk.url) && !this.existsAssets?.includes(chunk.path) && !emittedAssetUrls.has(chunk.url);
+            if (shouldEmit) emittedAssetUrls.add(chunk.url);
+            return shouldEmit;
+        });
         const css = await Promise.all(emittedChunks.map(async (chunk)=>{
             const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
             if ((0, external_utils_js_namespaceObject.checkIsNode)() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);

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

@@ -34,11 +34,13 @@ __webpack_require__.d(__webpack_exports__, {
     getSSRMode: ()=>getSSRMode,
     hasStylesheetLink: ()=>hasStylesheetLink,
     safeReplace: ()=>safeReplace,
-    serializeErrors: ()=>serializeErrors
+    serializeErrors: ()=>serializeErrors,
+    shouldRedactServerError: ()=>shouldRedactServerError
 });
+const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const routerHelper_js_namespaceObject = require("../../router/runtime/routerHelper.js");
 function attributesToString(attributes) {
-    return Object.entries(attributes).reduce((str, [key, value])=>void 0 === value ? str : `${str} ${key}="${value}"`, '');
+    return Object.entries(attributes).reduce((str, [key, value])=>void 0 !== value && (0, runtime_extensions_namespaceObject.isSafeHtmlAttributeName)(key) ? `${str} ${key}="${(0, runtime_extensions_namespaceObject.escapeHtmlAttribute)(value)}"` : str, '');
 }
 function safeReplace(source, searchValue, replaceValue) {
     return source.replace(searchValue, ()=>replaceValue);
@@ -76,12 +78,14 @@ function serializeRouteErrorResponse(error) {
         status: error.status,
         statusText: 'Internal Server Error',
         data: 'Unexpected Server Error',
+        internal: error.internal,
         __type: 'RouteErrorResponse'
     };
     return {
         status: error.status,
         statusText: error.statusText,
         data: error.data,
+        internal: error.internal,
         __type: 'RouteErrorResponse'
     };
 }
@@ -103,8 +107,9 @@ const getLinkAttributes = (linkTag)=>{
     let match;
     while(match = attributeRegExp.exec(linkTag)){
         const [, name, doubleQuotedValue, singleQuotedValue, unquotedValue] = match;
-        if ('link' === name.toLowerCase()) continue;
-        attributes.set(name.toLowerCase(), doubleQuotedValue ?? singleQuotedValue ?? unquotedValue ?? '');
+        const normalizedName = name.toLowerCase();
+        if ('link' === normalizedName || attributes.has(normalizedName)) continue;
+        attributes.set(normalizedName, doubleQuotedValue ?? singleQuotedValue ?? unquotedValue ?? '');
     }
     return attributes;
 };
@@ -124,6 +129,7 @@ exports.getSSRMode = __webpack_exports__.getSSRMode;
 exports.hasStylesheetLink = __webpack_exports__.hasStylesheetLink;
 exports.safeReplace = __webpack_exports__.safeReplace;
 exports.serializeErrors = __webpack_exports__.serializeErrors;
+exports.shouldRedactServerError = __webpack_exports__.shouldRedactServerError;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "attributesToString",
     "checkIsNode",
@@ -131,7 +137,8 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getSSRMode",
     "hasStylesheetLink",
     "safeReplace",
-    "serializeErrors"
+    "serializeErrors",
+    "shouldRedactServerError"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true