@bleedingdev/modern-js-runtime 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

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,6 +18,42 @@ 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;
     const scriptTags = getScriptTags(template);
@@ -22,4 +61,24 @@ function injectBeforeHydrationEntryScript(template, scripts, entryName = 'index'
     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/deferredScript.mjs

@@ -22,12 +22,15 @@ function isPromiseLike(value) {
     return !!value && 'function' == typeof value.then;
 }
 function toErrorInfo(error) {
+    if ('production' === process.env.NODE_ENV) return {
+        message: 'Unexpected Server Error'
+    };
     if (error && 'object' == typeof error) {
         const maybeMsg = error.message;
         const maybeStack = error.stack;
         return {
             message: 'string' == typeof maybeMsg ? maybeMsg : String(maybeMsg ?? error),
-            stack: 'production' !== process.env.NODE_ENV ? maybeStack : void 0
+            stack: maybeStack
         };
     }
     return {

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

@@ -4,9 +4,9 @@ import server from "react-dom/server";
 import { RenderLevel } from "../../constants.mjs";
 import { getGlobalInternalRuntimeContext } from "../../context/index.mjs";
 import { wrapRuntimeContextProvider } from "../../react/wrapper.mjs";
-import { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants.mjs";
+import { CHUNK_CSS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants.mjs";
 import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
-import { injectBeforeHydrationEntryScript } from "../scriptOrder.mjs";
+import { replaceChunkJsPlaceholder } from "../scriptOrder.mjs";
 import { buildHtml } from "../shared.mjs";
 import { SSRErrors, SSRTimings } from "../tracer.mjs";
 import { getSSRConfigByEntry, safeReplace } from "../utils.mjs";
@@ -98,13 +98,7 @@ function createReplaceSSRDataScript(data) {
     return (template)=>safeReplace(template, SSR_DATA_PLACEHOLDER, data);
 }
 function createReplaceChunkJs(js, entryName) {
-    return (template)=>{
-        if (!js) return safeReplace(template, CHUNK_JS_PLACEHOLDER, '');
-        const withoutPlaceholder = safeReplace(template, CHUNK_JS_PLACEHOLDER, '');
-        const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, js, entryName);
-        if (withEarlyScripts !== withoutPlaceholder) return withEarlyScripts;
-        return safeReplace(template, CHUNK_JS_PLACEHOLDER, js);
-    };
+    return (template)=>replaceChunkJsPlaceholder(template, js, entryName);
 }
 function createReplaceChunkCss(css) {
     return (template)=>safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);

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

@@ -1,39 +1,21 @@
 import { ChunkExtractor } from "@loadable/server";
-import { getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
 import { createFederatedCssLinks } from "../federatedCss.mjs";
+import { getMatchedRouteAssets, orderHydrationScriptChunks } from "../scriptOrder.mjs";
 import { attributesToString, checkIsNode } from "../utils.mjs";
 const extname = (uri)=>{
     if ('string' != typeof uri || !uri.includes('.')) return '';
     return `.${uri?.split('.').pop()}` || '';
 };
 const generateChunks = (chunks, ext)=>chunks.filter((chunk)=>Boolean(chunk.url)).filter((chunk)=>extname(chunk.url).slice(1) === ext);
-const dedupeChunksByUrl = (chunks)=>{
-    const seen = new Set();
-    return chunks.filter((chunk)=>{
-        if (!chunk.url || seen.has(chunk.url)) return false;
-        seen.add(chunk.url);
-        return true;
+const routeAssetToChunk = (asset)=>({
+        chunk: asset,
+        filename: asset.replace(/^\//, ''),
+        linkType: 'preload',
+        path: asset,
+        scriptType: asset.endsWith('.css') ? 'style' : "script",
+        type: 'routeAsset',
+        url: asset
     });
-};
-const isAsyncEntryScriptChunk = (chunk, entryName)=>{
-    if (!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}-`);
-};
-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 dedupeChunksByUrl([
-        ...asyncEntryDependencyChunks,
-        ...collectedChunks,
-        ...matchedRouteChunks,
-        ...asyncEntryScriptChunks
-    ]);
-};
 const checkIsInline = (chunk, enableInline)=>{
     if ('production' !== process.env.NODE_ENV) return false;
     if (enableInline instanceof RegExp) return enableInline.test(chunk.url);
@@ -52,17 +34,8 @@ class LoadableCollector {
     }
     getMatchedRouteChunks() {
         const { routeManifest, runtimeContext } = this.options;
-        const routeAssets = routeManifest?.routeAssets;
-        if (!routeAssets) return [];
-        const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
-        return matchedRouteIds.flatMap((routeId)=>{
-            const routeAsset = routeAssets[routeId];
-            return (routeAsset?.assets ?? []).map((asset)=>({
-                    filename: asset.replace(/^\//, ''),
-                    path: asset,
-                    url: asset
-                }));
-        });
+        if (!routeManifest) return [];
+        return getMatchedRouteAssets(runtimeContext, routeManifest).map(routeAssetToChunk);
     }
     collect(comopnent) {
         const { stats, entryName } = this.options;

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

@@ -1,5 +1,5 @@
 import { serializeJson } from "@modern-js/runtime-utils/node";
-import { getRouterHydrationScripts } from "../../../router/runtime/lifecycle.mjs";
+import { getRouterHydrationScripts, getRouterServerSnapshot } from "../../../router/runtime/lifecycle.mjs";
 import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../../constants.mjs";
 import { attributesToString, serializeErrors } from "../utils.mjs";
 function _check_private_redeclaration(obj, privateCollection) {
@@ -89,7 +89,7 @@ function getSSRData() {
 }
 function getRouterData() {
     const { routerContext, runtimeContext } = _class_private_field_get(this, _options);
-    const snapshotRouterData = runtimeContext.routerServerSnapshot?.routerData;
+    const snapshotRouterData = getRouterServerSnapshot(runtimeContext)?.routerData;
     if (snapshotRouterData) return {
         loaderData: snapshotRouterData.loaderData,
         errors: serializeErrors(snapshotRouterData.errors || null)

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

@@ -12,17 +12,40 @@ function serializeErrors(errors) {
     if (!errors) return null;
     const entries = Object.entries(errors);
     const serialized = {};
-    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = {
-        ...val,
-        __type: 'RouteErrorResponse'
+    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = serializeRouteErrorResponse(val);
+    else if (val instanceof Error) serialized[key] = serializeError(val);
+    else serialized[key] = val;
+    return serialized;
+}
+function shouldRedactServerError() {
+    return 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV;
+}
+function serializeError(error) {
+    if (shouldRedactServerError()) return {
+        message: 'Unexpected Server Error',
+        stack: void 0,
+        __type: 'Error'
     };
-    else if (val instanceof Error) serialized[key] = {
-        message: val.message,
-        stack: val.stack,
+    return {
+        message: error.message,
+        stack: error.stack,
         __type: 'Error'
     };
-    else serialized[key] = val;
-    return serialized;
+}
+function serializeRouteErrorResponse(error) {
+    if (!isRouteErrorResponse(error)) return error;
+    if (error.status >= 500 && shouldRedactServerError()) return {
+        status: error.status,
+        statusText: 'Internal Server Error',
+        data: 'Unexpected Server Error',
+        __type: 'RouteErrorResponse'
+    };
+    return {
+        status: error.status,
+        statusText: error.statusText,
+        data: error.data,
+        __type: 'RouteErrorResponse'
+    };
 }
 function getSSRConfigByEntry(entryName, ssr, ssrByEntries) {
     if (ssrByEntries?.[entryName]) return ssrByEntries[entryName];