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

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

@@ -1,15 +1,17 @@
 import { jsx } from "react/jsx-runtime";
 import { HelmetProvider } from "react-helmet-async";
-import { InternalRuntimeContext, RuntimeContext, getGlobalEnableRsc } from "../context/index.mjs";
+import { InternalRuntimeContext, RuntimeContext, getGlobalEnableRsc, getInitialContext } from "../context/index.mjs";
 import { stripRuntimeContextExtensions } from "../context/extensions.mjs";
 import { ensureHelmetContext } from "../context/helmetContext.mjs";
 function createRscSafeRequestContext(ssrContext) {
-    if (void 0 === ssrContext) return {
-        request: {},
-        response: {
-            locals: {}
-        }
-    };
+    const requestContext = 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: {
@@ -29,9 +31,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/esm/core/server/federatedCss.mjs

@@ -1,13 +1,16 @@
-import { attributesToString } from "./utils.mjs";
-const escapeHtmlAttribute = (value)=>value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+import { escapeHtmlAttribute } from "@modern-js/runtime-extensions";
+import { attributesToString, hasStylesheetLink } from "./utils.mjs";
 const createFederatedCssLinks = (assets, options)=>{
     if (void 0 === assets || 0 === assets.length) return '';
     const seen = new Set(options.existingAssets || []);
-    const attributes = attributesToString(options.attributes || {});
+    const attributes = 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))) {
+        if (!('' === asset || seen.has(asset) || hasStylesheetLink(options.template, asset) || hasStylesheetLink(options.template, href))) {
             seen.add(asset);
             links.push(`<link${attributes} href="${href}" rel="stylesheet" />`);
         }

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

@@ -19,6 +19,7 @@ function helmetReplace(content, helmetData) {
     const htmlAttributes = helmetData.htmlAttributes.toString();
     if (htmlAttributes) result = 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();
@@ -30,6 +31,7 @@ function helmetReplace(content, helmetData) {
     if (shouldReplaceTitle) result = safeReplace(result, RE_TITLE, title);
     const helmetStr = [
         base,
+        priority,
         link,
         meta,
         noscript,

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

@@ -1,9 +1,15 @@
 import { getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
 import { handleRSCRedirect } from "../../router/runtime/redirect.mjs";
 import { SSRErrors } from "./tracer.mjs";
-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 handleRSCRedirect(headers, ctx.basename, status);
     return new Response(null, {
         status,
@@ -20,20 +26,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);
 };
 export { applyRouterSnapshotResult, createLoaderRedirectResponse, finalizeRenderResponse };

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

@@ -62,12 +62,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
     };
 }
 export { ROUTER_CLEANUP_ERROR, createRouterCleanup, finishWithRouterCleanup, runWithRouterCleanupOnError };

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

@@ -1,6 +1,6 @@
 import { getRouterMatchedRouteIds } from "../../router/runtime/lifecycle.mjs";
 import { CHUNK_JS_PLACEHOLDER } from "./constants.mjs";
-import { safeReplace } from "./utils.mjs";
+import { attributesToString, safeReplace } from "./utils.mjs";
 function getScriptTags(template) {
     const scriptRegExp = /<script\b[^>]*\bsrc=(["'])(.*?)\1[^>]*><\/script>/g;
     return Array.from(template.matchAll(scriptRegExp)).map((match)=>({
@@ -66,6 +66,7 @@ function injectBeforeHydrationEntryScript(template, scripts, entryName = 'index'
     return `${template.slice(0, target.index)}${scripts}${template.slice(target.index)}`;
 }
 function replaceChunkJsPlaceholder(template, scripts, entryName, placeholder = CHUNK_JS_PLACEHOLDER) {
+    if (!template.includes(placeholder)) return template;
     if ('' === scripts) return safeReplace(template, placeholder, '');
     const withoutPlaceholder = safeReplace(template, placeholder, '');
     const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, scripts, entryName);
@@ -81,7 +82,9 @@ 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${attributesToString({
+            src: asset,
+            nonce: nonce || void 0
+        })}></script>`).join(' ');
 }
 export { createRouteHydrationScriptTags, getMatchedRouteChunks, injectBeforeHydrationEntryScript, orderHydrationScriptChunks, replaceChunkJsPlaceholder };

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

@@ -3,7 +3,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 { safeReplace } from "../utils.mjs";
+import { hasStylesheetLink, safeReplace } from "../utils.mjs";
 const checkIsInline = (chunk, enableInline)=>{
     if ('production' !== process.env.NODE_ENV) return false;
     if (enableInline instanceof RegExp) return enableInline.test(chunk);
@@ -36,7 +36,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') && !hasStylesheetLink(template, asset));
                 return [
                     ...chunks,
                     ..._cssChunks

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

@@ -5,9 +5,11 @@ 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 { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
 import { enqueueFromEntries } from "./deferredScript.mjs";
 import { ShellChunkStatus, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
 import { getTemplates } from "./template.mjs";
+import * as __rspack_external__modern_js_runtime_extensions_node_f016b1ee from "@modern-js/runtime-extensions/node";
 const defaultExtender = {
     modifyRootElement: (rootElement)=>rootElement,
     getStyleTags: ()=>'',
@@ -36,6 +38,8 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
     });
     const chunkVec = [];
     let hasStartedPipe = false;
+    __rspack_external__modern_js_runtime_extensions_node_f016b1ee.beginHeadRender(runtimeContext);
+    const reportError = __rspack_external__modern_js_runtime_extensions_node_f016b1ee.createOnceErrorReporter(options.onError);
     return new Promise((resolve)=>{
         const { pipe: reactStreamingPipe } = renderToPipeableStream(processedRootElement, {
             nonce: config.nonce,
@@ -69,8 +73,10 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                                     if (-1 !== markerIndex) {
                                         const beforeMark = concatedChunk.slice(0, markerIndex);
                                         const afterMark = concatedChunk.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
+                                        __rspack_external__modern_js_runtime_extensions_node_f016b1ee.publishHeadRender(runtimeContext);
+                                        const completedShellBefore = createReplaceHelemt(getHelmetData(runtimeContext))(shellBefore);
                                         shellChunkStatus = 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);
                                     }
@@ -88,8 +94,14 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                     extenders.forEach((extender)=>{
                         if (extender.processStream) processedStream = extender.processStream(processedStream);
                     });
+                    __rspack_external__modern_js_runtime_extensions_node_f016b1ee.pipeNodeHeadStream({
+                        source: processedStream,
+                        destination: body,
+                        context: runtimeContext,
+                        terminalMarker: ESCAPED_SHELL_STREAM_END_MARK,
+                        onError: reportError
+                    });
                     reactStreamingPipe(passThrough);
-                    processedStream.pipe(body);
                     try {
                         const storageContext = storage.useContext?.();
                         const activeDeferreds = storageContext?.activeDeferreds;
@@ -108,6 +120,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                 });
             },
             onShellError (error) {
+                __rspack_external__modern_js_runtime_extensions_node_f016b1ee.abortHeadRender(runtimeContext);
                 renderLevel = RenderLevel.CLIENT_RENDER;
                 getTemplates(htmlTemplate, {
                     request,
@@ -126,7 +139,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             },
             onError (error) {
                 renderLevel = RenderLevel.CLIENT_RENDER;
-                options?.onError?.(error);
+                reportError(error);
             }
         });
     });

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

@@ -2,13 +2,16 @@ 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 { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
 import { enqueueFromEntries } from "./deferredScript.mjs";
 import { ShellChunkStatus, encodeForWebStream, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
 import { getTemplates } from "./template.mjs";
+import * as __rspack_external__modern_js_runtime_extensions_ce611631 from "@modern-js/runtime-extensions";
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
     let shellChunkStatus = ShellChunkStatus.START;
     const chunkVec = [];
     const { htmlTemplate, runtimeContext, config, ssrConfig, entryName, moduleFederationCssAssets, rscManifest, rscRoot } = options;
+    __rspack_external__modern_js_runtime_extensions_ce611631.beginHeadRender(runtimeContext);
     const { shellBefore, shellAfter } = await getTemplates(htmlTemplate, {
         renderLevel: RenderLevel.SERVER_RENDER,
         runtimeContext,
@@ -36,7 +39,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         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 reader = __rspack_external__modern_js_runtime_extensions_ce611631.createConservingWebShellStream(readableOriginal, runtimeContext, ESCAPED_SHELL_STREAM_END_MARK, options.onError).getReader();
         const stream = new ReadableStream({
             start (controller) {
                 const pendingScripts = [];
@@ -81,14 +84,17 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                             if (-1 !== markerIndex) {
                                 const beforeMark = concatedChunk.slice(0, markerIndex);
                                 const afterMark = concatedChunk.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
+                                __rspack_external__modern_js_runtime_extensions_ce611631.publishHeadRender(runtimeContext);
+                                const completedShellBefore = createReplaceHelemt(getHelmetData(runtimeContext))(shellBefore);
                                 shellChunkStatus = ShellChunkStatus.FINISH;
-                                safeEnqueue(encodeForWebStream(`${shellBefore}${beforeMark}${shellAfter}`));
+                                safeEnqueue(encodeForWebStream(`${completedShellBefore}${beforeMark}${shellAfter}`));
                                 if (afterMark.length > 0) safeEnqueue(encodeForWebStream(afterMark));
                                 flushPendingScripts();
                             }
                         } else safeEnqueue(value);
                         if (!isClosed) push();
                     } catch (error) {
+                        __rspack_external__modern_js_runtime_extensions_ce611631.abortHeadRender(runtimeContext);
                         if (!isClosed) {
                             isClosed = true;
                             try {
@@ -100,11 +106,13 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                 push();
             },
             cancel (reason) {
+                __rspack_external__modern_js_runtime_extensions_ce611631.abortHeadRender(runtimeContext);
                 reader.cancel(reason).catch(()=>{});
             }
         });
         return stream;
     } catch (e) {
+        __rspack_external__modern_js_runtime_extensions_ce611631.abortHeadRender(runtimeContext);
         const fallbackHtml = `${shellBefore}${shellAfter}`;
         const stream = getReadableStreamFromString(fallbackHtml);
         return stream;

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

@@ -1,4 +1,5 @@
 import { runRouterDataFnStr } from "../../../router/runtime/constants.mjs";
+import { shouldRedactServerError } from "../utils.mjs";
 const HTML_ESCAPE_MAP = {
     '&': '&',
     '<': '&lt;',
@@ -22,7 +23,7 @@ function isPromiseLike(value) {
     return !!value && 'function' == typeof value.then;
 }
 function toErrorInfo(error) {
-    if ('production' === process.env.NODE_ENV) return {
+    if (shouldRedactServerError()) return {
         message: 'Unexpected Server Error'
     };
     if (error && 'object' == typeof error) {

package/dist/esm/core/server/string/index.mjs

@@ -12,6 +12,7 @@ import { SSRErrors, SSRTimings } from "../tracer.mjs";
 import { getSSRConfigByEntry, safeReplace } from "../utils.mjs";
 import { LoadableCollector } from "./loadable.mjs";
 import { SSRDataCollector } from "./ssrData.mjs";
+import * as __rspack_external__modern_js_runtime_extensions_ce611631 from "@modern-js/runtime-extensions";
 const renderString = async (request, serverRoot, options)=>{
     const { resource, runtimeContext, config, onError, onTiming } = options;
     const tracer = {
@@ -66,16 +67,19 @@ async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifie
     let html = '';
     let helmetData;
     const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
+    __rspack_external__modern_js_runtime_extensions_ce611631.beginHeadRender(runtimeContext);
     try {
         const end = time();
         html = server.renderToString(finalApp, {
             identifierPrefix: SSR_HYDRATION_ID_PREFIX
         });
+        html = __rspack_external__modern_js_runtime_extensions_ce611631.completeHeadRender(runtimeContext, html);
         chunkSet.renderLevel = RenderLevel.SERVER_RENDER;
         helmetData = getHelmetData(runtimeContext);
         const cost = end();
         onTiming(SSRTimings.RENDER_HTML, cost);
     } catch (e) {
+        __rspack_external__modern_js_runtime_extensions_ce611631.abortHeadRender(runtimeContext);
         chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
         onError(e, SSRErrors.RENDER_HTML);
     }

package/dist/esm/core/server/string/loadable.mjs

@@ -28,6 +28,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;
@@ -89,7 +93,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 (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<script>${content}</script>`).catch((_)=>script);
             return script;
@@ -100,7 +104,12 @@ class LoadableCollector {
         const { template, chunkSet, config, moduleFederationCssAssets } = this.options;
         const { inlineStyles } = config;
         const atrributes = attributesToString(this.generateAttributes());
-        const emittedChunks = chunks.filter((chunk)=>!hasStylesheetLink(template, chunk.url));
+        const emittedAssetUrls = new Set();
+        const emittedChunks = chunks.filter((chunk)=>{
+            const shouldEmit = !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 (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);

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

@@ -1,6 +1,7 @@
+import { escapeHtmlAttribute, isSafeHtmlAttributeName } from "@modern-js/runtime-extensions";
 import { isRouteErrorResponse } from "../../router/runtime/routerHelper.mjs";
 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 && isSafeHtmlAttributeName(key) ? `${str} ${key}="${escapeHtmlAttribute(value)}"` : str, '');
 }
 function safeReplace(source, searchValue, replaceValue) {
     return source.replace(searchValue, ()=>replaceValue);
@@ -38,12 +39,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'
     };
 }
@@ -65,8 +68,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;
 };
@@ -79,4 +83,4 @@ const hasStylesheetLink = (template, href)=>{
         return linkHref === href && rel?.split(/\s+/).some((relToken)=>'stylesheet' === relToken.toLowerCase());
     });
 };
-export { attributesToString, checkIsNode, getSSRConfigByEntry, getSSRMode, hasStylesheetLink, safeReplace, serializeErrors };
+export { attributesToString, checkIsNode, getSSRConfigByEntry, getSSRMode, hasStylesheetLink, safeReplace, serializeErrors, shouldRedactServerError };