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

package/dist/cjs/exports/head.js

@@ -39,256 +39,25 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Helmet: ()=>Helmet,
-    HelmetData: ()=>external_react_helmet_async_namespaceObject.HelmetData,
-    HelmetProvider: ()=>external_react_helmet_async_namespaceObject.HelmetProvider,
     default: ()=>exports_head
 });
+const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
 const external_react_helmet_async_namespaceObject = require("react-helmet-async");
 const index_js_namespaceObject = require("../core/context/index.js");
 const helmetContext_js_namespaceObject = require("../core/context/helmetContext.js");
-const ATTRIBUTE_NAME_MAP = {
-    charSet: 'charset',
-    className: 'class',
-    contentEditable: 'contenteditable',
-    httpEquiv: 'http-equiv',
-    hrefLang: 'hreflang',
-    itemProp: 'itemprop',
-    tabIndex: 'tabindex'
-};
-const CONTENT_PROPERTIES = new Set([
-    'innerHTML',
-    'cssText'
-]);
-const escapeHtml = (value)=>String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
-const toHtmlAttributeName = (name)=>ATTRIBUTE_NAME_MAP[name] ?? name;
-const attributesToString = (attributes, includeHelmetAttribute = false)=>{
-    const pairs = [];
-    if (includeHelmetAttribute) pairs.push('data-rh="true"');
-    for (const [name, value] of Object.entries(attributes ?? {})){
-        if (false === value || null == value) continue;
-        if (CONTENT_PROPERTIES.has(name)) continue;
-        const htmlName = toHtmlAttributeName(name);
-        if (true === value) pairs.push(htmlName);
-        else pairs.push(`${htmlName}="${escapeHtml(value)}"`);
-    }
-    return pairs.join(' ');
-};
-const createDatum = (tagName, tags)=>({
-        toComponent: ()=>[],
-        toString: ()=>tags.map((tag)=>{
-                const attrs = attributesToString(tag, true);
-                if ("script" === tagName && 'string' == typeof tag.innerHTML) return `<script ${attrs}>${tag.innerHTML}</script>`;
-                if ('style' === tagName && 'string' == typeof tag.cssText) return `<style ${attrs}>${tag.cssText}</style>`;
-                if ("noscript" === tagName && 'string' == typeof tag.innerHTML) return `<noscript ${attrs}>${tag.innerHTML}</noscript>`;
-                return `<${tagName} ${attrs}>`;
-            }).join('')
-    });
-const createAttributeDatum = (attributes)=>({
-        toComponent: ()=>attributes,
-        toString: ()=>attributesToString(attributes)
-    });
-const createTitleDatum = (title, attributes)=>({
-        toComponent: ()=>[],
-        toString: ()=>{
-            if (void 0 === title || '' === title) return '';
-            const attrs = attributesToString(attributes, true);
-            return `<title ${attrs}>${escapeHtml(title)}</title>`;
-        }
-    });
-const normalizeHelmetTitle = (title)=>{
-    if ('string' == typeof title) return title;
-    if (Array.isArray(title)) return title.map((part)=>String(part)).join('');
-};
-const mergeAttributes = (current, next)=>({
-        ...current,
-        ...next ?? {}
-    });
-const collectChildren = (children, draft)=>{
-    external_react_default().Children.forEach(children, (child)=>{
-        if (!external_react_default().isValidElement(child)) return;
-        if (child.type === external_react_default().Fragment) return void collectChildren(child.props.children, draft);
-        if ('string' != typeof child.type) return;
-        const { children: nestedChildren, ...props } = child.props;
-        if ('title' === child.type) {
-            draft.title = external_react_default().Children.toArray(nestedChildren).join('');
-            draft.titleAttributes = mergeAttributes(draft.titleAttributes, props);
-            return;
-        }
-        if ('html' === child.type) {
-            draft.htmlAttributes = mergeAttributes(draft.htmlAttributes ?? {}, props);
-            return;
-        }
-        if ('body' === child.type) {
-            draft.bodyAttributes = mergeAttributes(draft.bodyAttributes ?? {}, props);
-            return;
-        }
-        if ('base' === child.type || 'link' === child.type || 'meta' === child.type || "noscript" === child.type || "script" === child.type || 'style' === child.type) {
-            const tag = {
-                ...props
-            };
-            if (("script" === child.type || 'style' === child.type || "noscript" === child.type) && 'string' == typeof nestedChildren) tag['style' === child.type ? 'cssText' : 'innerHTML'] = nestedChildren;
-            draft[child.type].push(tag);
-        }
-    });
-};
-const createHelmetRecord = (props)=>{
-    const draft = {
-        base: [
-            ...void 0 !== props.base ? [
-                props.base
-            ] : []
-        ],
-        bodyAttributes: props.bodyAttributes,
-        htmlAttributes: props.htmlAttributes,
-        link: [
-            ...props.link ?? []
-        ],
-        meta: [
-            ...props.meta ?? []
-        ],
-        noscript: [
-            ...props.noscript ?? []
-        ],
-        script: [
-            ...props.script ?? []
-        ],
-        style: [
-            ...props.style ?? []
-        ],
-        title: normalizeHelmetTitle(props.title),
-        titleAttributes: props.titleAttributes ?? {}
-    };
-    collectChildren(props.children, draft);
-    return {
-        ...draft,
-        titleTemplate: props.titleTemplate,
-        defaultTitle: props.defaultTitle
-    };
-};
-const getInnermostDefined = (records, pick)=>{
-    for(let i = records.length - 1; i >= 0; i -= 1){
-        const value = pick(records[i]);
-        if (void 0 !== value) return value;
-    }
-};
-const deriveTitle = (records)=>{
-    const innermostTitle = getInnermostDefined(records, (record)=>record.title);
-    const innermostTemplate = getInnermostDefined(records, (record)=>record.titleTemplate);
-    if (innermostTemplate && innermostTitle) return innermostTemplate.replaceAll('%s', innermostTitle);
-    return innermostTitle || getInnermostDefined(records, (record)=>record.defaultTitle);
-};
-const mergeRecordAttributes = (records, pick)=>records.reduce((merged, record)=>mergeAttributes(merged, pick(record)), {});
-const deriveBaseTags = (records)=>{
-    for(let i = records.length - 1; i >= 0; i -= 1){
-        const tags = records[i].base;
-        for(let j = tags.length - 1; j >= 0; j -= 1)if (tags[j].href) return [
-            tags[j]
-        ];
-    }
-    return [];
-};
-const TAG_PRIMARY_ATTRIBUTES = {
-    link: [
-        'rel',
-        'href'
-    ],
-    meta: [
-        'name',
-        'charset',
-        'http-equiv',
-        'property',
-        'itemprop'
-    ],
-    noscript: [
-        'innerHTML'
-    ],
-    script: [
-        'src',
-        'innerHTML'
-    ],
-    style: [
-        'cssText'
-    ]
-};
-const getPrimaryAttribute = (tagName, tag)=>{
-    const candidates = TAG_PRIMARY_ATTRIBUTES[tagName];
-    let selectedKey;
-    let selectedValue;
-    for (const [key, value] of Object.entries(tag)){
-        const normalizedKey = CONTENT_PROPERTIES.has(key) ? key : toHtmlAttributeName(key).toLowerCase();
-        if (candidates.includes(normalizedKey)) {
-            if ('rel' !== selectedKey || 'canonical' !== String(selectedValue).toLowerCase()) {
-                if ('rel' !== normalizedKey || 'stylesheet' !== String(value).toLowerCase()) {
-                    selectedKey = normalizedKey;
-                    selectedValue = value;
-                }
-            }
-        }
-    }
-    if (void 0 === selectedKey || !selectedValue) return;
-    return {
-        key: selectedKey,
-        value: String(selectedValue).toLowerCase()
-    };
-};
-const dedupeTags = (tagName, records)=>{
-    const approvedValues = new Map();
-    const approved = [];
-    for(let i = records.length - 1; i >= 0; i -= 1){
-        const instanceValues = new Map();
-        const kept = [];
-        for (const tag of records[i][tagName]){
-            const primary = getPrimaryAttribute(tagName, tag);
-            if (void 0 === primary) continue;
-            if (approvedValues.get(primary.key)?.has(primary.value)) continue;
-            let seen = instanceValues.get(primary.key);
-            if (void 0 === seen) {
-                seen = new Set();
-                instanceValues.set(primary.key, seen);
-            }
-            seen.add(primary.value);
-            kept.push(tag);
-        }
-        approved.unshift(...kept);
-        for (const [key, values] of instanceValues){
-            const target = approvedValues.get(key);
-            if (void 0 === target) approvedValues.set(key, values);
-            else for (const value of values)target.add(value);
-        }
-    }
-    return approved;
-};
-const deriveHelmetServerState = (records)=>({
-        base: createDatum('base', deriveBaseTags(records)),
-        bodyAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.bodyAttributes)),
-        htmlAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.htmlAttributes)),
-        link: createDatum('link', dedupeTags('link', records)),
-        meta: createDatum('meta', dedupeTags('meta', records)),
-        noscript: createDatum("noscript", dedupeTags("noscript", records)),
-        priority: createDatum('meta', []),
-        script: createDatum("script", dedupeTags("script", records)),
-        style: createDatum('style', dedupeTags('style', records)),
-        title: createTitleDatum(deriveTitle(records), mergeRecordAttributes(records, (record)=>record.titleAttributes))
-    });
-const serverHelmetRecords = new WeakMap();
 const collectServerHelmet = (runtimeContext, props)=>{
     const helmetContext = (0, helmetContext_js_namespaceObject.ensureHelmetContext)(runtimeContext);
-    let records = serverHelmetRecords.get(helmetContext);
-    if (void 0 === records) {
-        records = [];
-        serverHelmetRecords.set(helmetContext, records);
-    }
-    records.push(createHelmetRecord(props));
-    helmetContext.helmet = deriveHelmetServerState(records);
+    const createRecord = ()=>runtime_extensions_namespaceObject.createHelmetRecord(external_react_default(), props);
+    const deriveState = (records)=>runtime_extensions_namespaceObject.deriveHelmetServerState(external_react_default(), records);
+    const marker = runtime_extensions_namespaceObject.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
+    if (void 0 !== marker) return marker;
+    helmetContext.helmet = runtime_extensions_namespaceObject.collectImmediateHelmetState(external_react_default(), helmetContext, createRecord());
 };
 const Helmet = (props)=>{
     const runtimeContext = external_react_default().useContext(index_js_namespaceObject.InternalRuntimeContext);
-    if (null !== runtimeContext && false === runtimeContext.isBrowser) {
-        collectServerHelmet(runtimeContext, props);
-        return null;
-    }
+    if (null !== runtimeContext && false === runtimeContext.isBrowser) return runtime_extensions_namespaceObject.renderHeadMarker(external_react_default(), collectServerHelmet(runtimeContext, props));
     return external_react_default().createElement(external_react_helmet_async_namespaceObject.Helmet, props);
 };
 const head = {
@@ -298,13 +67,9 @@ const head = {
 };
 const exports_head = head;
 exports.Helmet = __webpack_exports__.Helmet;
-exports.HelmetData = __webpack_exports__.HelmetData;
-exports.HelmetProvider = __webpack_exports__.HelmetProvider;
 exports["default"] = __webpack_exports__["default"];
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "Helmet",
-    "HelmetData",
-    "HelmetProvider",
     "default"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/module-federation/last-known-good.js

@@ -32,6 +32,7 @@ __webpack_require__.d(__webpack_exports__, {
     createInMemoryLkgStorage: ()=>createInMemoryLkgStorage,
     createLastKnownGoodProvider: ()=>createLastKnownGoodProvider
 });
+const universal_namespaceObject = require("@modern-js/utils/universal");
 const external_surface_resolution_types_js_namespaceObject = require("./surface-resolution-types.js");
 const LAST_KNOWN_GOOD_PROVIDER_NAME = 'last-known-good';
 function createInMemoryLkgStorage() {
@@ -65,16 +66,38 @@ function staleRecordResult(ref, env, ageMs, maxStaleMs) {
         })
     };
 }
+function resolutionAnswersRef(resolved, ref) {
+    const selected = (0, universal_namespaceObject.selectResolvedSurface)(resolved, ref);
+    return selected.ok && selected.surface.servedMajor === ref.major;
+}
 function createLastKnownGoodProvider(options) {
     const storage = options.storage ?? createInMemoryLkgStorage();
     const now = options.now ?? (()=>Math.floor(performance.timeOrigin + performance.now()));
     const maxStaleMs = options.freshness?.maxStaleMs;
+    let nextResolutionGeneration = 0;
+    const latestCacheableGenerationByKey = new Map();
+    const writeTailByKey = new Map();
+    async function cacheCompatibleResolution(key, generation, record) {
+        latestCacheableGenerationByKey.set(key, Math.max(latestCacheableGenerationByKey.get(key) ?? 0, generation));
+        const previous = writeTailByKey.get(key) ?? Promise.resolve();
+        const write = previous.catch(()=>void 0).then(async ()=>{
+            if (latestCacheableGenerationByKey.get(key) !== generation) return;
+            await storage.write(key, record);
+        });
+        writeTailByKey.set(key, write);
+        try {
+            await write;
+        } finally{
+            if (writeTailByKey.get(key) === write) writeTailByKey.delete(key);
+        }
+    }
     async function serveFromCache(ref, env, fallback) {
         const key = (0, external_surface_resolution_types_js_namespaceObject.deliveryUnitResolutionKey)(ref.unitId, env);
         const cached = await storage.read(key);
         if (!cached) return fallback();
         if (cached.major !== ref.major) return fallback();
-        if ('incompatible' === cached.resolved.compatibility.status) return fallback();
+        if (!resolutionAnswersRef(cached.resolved, ref)) return fallback();
+        if ('compatible' !== cached.resolved.compatibility.status) return fallback();
         const ageMs = now() - cached.storedAt;
         if (void 0 !== maxStaleMs && ageMs > maxStaleMs) return staleRecordResult(ref, env, ageMs, maxStaleMs);
         return {
@@ -86,6 +109,7 @@ function createLastKnownGoodProvider(options) {
         name: LAST_KNOWN_GOOD_PROVIDER_NAME,
         async resolve (ref, env) {
             const key = (0, external_surface_resolution_types_js_namespaceObject.deliveryUnitResolutionKey)(ref.unitId, env);
+            const generation = ++nextResolutionGeneration;
             let resolution;
             try {
                 resolution = await options.provider.resolve(ref, env);
@@ -102,7 +126,16 @@ function createLastKnownGoodProvider(options) {
                 const failure = resolution;
                 return serveFromCache(ref, env, ()=>failure);
             }
-            if ('incompatible' !== resolution.unit.compatibility.status) await storage.write(key, {
+            if (!resolutionAnswersRef(resolution.unit, ref)) return serveFromCache(ref, env, ()=>({
+                    ok: false,
+                    error: (0, external_surface_resolution_types_js_namespaceObject.createDiscoveryError)('identity-mismatch', ref, `Provider ${options.provider.name} returned a delivery unit that does not answer the requested surface.`, {
+                        env,
+                        provider: options.provider.name,
+                        recordUnitId: resolution.unit.unitId,
+                        availableSurfaces: resolution.unit.surfaces.map((surface)=>surface.surfaceId)
+                    })
+                }));
+            if ('compatible' === resolution.unit.compatibility.status) await cacheCompatibleResolution(key, generation, {
                 resolved: resolution.unit,
                 storedAt: now(),
                 major: ref.major

package/dist/cjs/router/cli/nestedRoutesSpec.js

@@ -41,40 +41,13 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const promises_namespaceObject = require("node:timers/promises");
 const utils_namespaceObject = require("@modern-js/utils");
 const lodash_namespaceObject = require("@modern-js/utils/lodash");
-const lockPollIntervalMs = 25;
-const staleLockAgeMs = 120000;
 const pendingUpdates = new Map();
 let tempFileCounter = 0;
-async function acquireSpecLock(specPath) {
-    const lockDir = `${specPath}.lock`;
-    await utils_namespaceObject.fs.ensureDir(external_node_path_default().dirname(specPath));
-    while(true){
-        try {
-            await utils_namespaceObject.fs.mkdir(lockDir);
-            return async ()=>{
-                await utils_namespaceObject.fs.remove(lockDir);
-            };
-        } catch (error) {
-            if ('EEXIST' !== error.code) throw error;
-        }
-        try {
-            const stat = await utils_namespaceObject.fs.stat(lockDir);
-            if (performance.timeOrigin + performance.now() - stat.mtimeMs > staleLockAgeMs) {
-                await utils_namespaceObject.fs.remove(lockDir);
-                continue;
-            }
-        } catch (error) {
-            if ('ENOENT' !== error.code) throw error;
-            continue;
-        }
-        await (0, promises_namespaceObject.setTimeout)(lockPollIntervalMs);
-    }
-}
 async function writeJSONAtomically(filePath, value) {
     const directory = external_node_path_default().dirname(filePath);
+    await utils_namespaceObject.fs.ensureDir(directory);
     const tempPath = external_node_path_default().join(directory, `.${external_node_path_default().basename(filePath)}.${process.pid}.${tempFileCounter += 1}.tmp`);
     try {
         await utils_namespaceObject.fs.writeFile(tempPath, `${JSON.stringify(value)}\n`);
@@ -89,16 +62,12 @@ async function updateNestedRoutesSpec(specPath, nextRoutes) {
     const nextRoutesSnapshot = (0, lodash_namespaceObject.cloneDeep)(nextRoutes);
     const previousUpdate = pendingUpdates.get(resolvedSpecPath) ?? Promise.resolve();
     const currentUpdate = previousUpdate.catch(()=>void 0).then(async ()=>{
-        const releaseLock = await acquireSpecLock(resolvedSpecPath);
-        try {
-            const existingRoutes = await utils_namespaceObject.fs.pathExists(resolvedSpecPath) ? await utils_namespaceObject.fs.readJSON(resolvedSpecPath) : {};
-            await writeJSONAtomically(resolvedSpecPath, {
-                ...existingRoutes,
-                ...nextRoutesSnapshot
-            });
-        } finally{
-            await releaseLock();
-        }
+        const existingRoutes = await utils_namespaceObject.fs.pathExists(resolvedSpecPath) ? await utils_namespaceObject.fs.readJSON(resolvedSpecPath) : {};
+        const mergedRoutes = {
+            ...existingRoutes,
+            ...nextRoutesSnapshot
+        };
+        await writeJSONAtomically(resolvedSpecPath, mergedRoutes);
     });
     pendingUpdates.set(resolvedSpecPath, currentUpdate);
     try {

package/dist/cjs/router/runtime/PrefetchLink.js

@@ -22,6 +22,16 @@ var __webpack_require__ = {};
         define(values, "value");
     };
 })();
+(()=>{
+    __webpack_require__.g = (()=>{
+        if ('object' == typeof globalThis) return globalThis;
+        try {
+            return this || new Function('return this')();
+        } catch (e) {
+            if ('object' == typeof window) return window;
+        }
+    })();
+})();
 (()=>{
     __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
 })();
@@ -35,6 +45,24 @@ var __webpack_require__ = {};
         });
     };
 })();
+(()=>{
+    var scriptUrl;
+    if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
+    var document = __webpack_require__.g.document;
+    if (!scriptUrl && document) {
+        if (document.currentScript && 'SCRIPT' === document.currentScript.tagName.toUpperCase()) scriptUrl = document.currentScript.src;
+        if (!scriptUrl) {
+            var scripts = document.getElementsByTagName("script");
+            if (scripts.length) {
+                var i = scripts.length - 1;
+                while(i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl)))scriptUrl = scripts[i--].src;
+            }
+        }
+    }
+    if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
+    scriptUrl = scriptUrl.replace(/^blob:/, "").replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+    __webpack_require__.p = scriptUrl + '../../';
+})();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
@@ -42,10 +70,19 @@ __webpack_require__.d(__webpack_exports__, {
     NavLink: ()=>NavLink
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const router_namespaceObject = require("@modern-js/runtime-utils/router");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
 const index_js_namespaceObject = require("../../core/context/index.js");
+const getWebpackChunkLoader = ()=>__webpack_chunk_load__;
+const getWebpackPublicPath = ()=>{
+    try {
+        return __webpack_require__.p || '';
+    } catch  {
+        return '';
+    }
+};
 function composeEventHandlers(theirHandler, ourHandler) {
     return (event)=>{
         theirHandler?.(event);
@@ -84,8 +121,7 @@ const runNextWarmup = ()=>{
         const task = warmupQueue.shift();
         if (task.cancelled) continue;
         activeWarmups += 1;
-        task.run().catch((error)=>{
-            console.error(error);
+        task.run().catch(()=>{
             warmupCache.delete(task.key);
         }).finally(()=>{
             activeWarmups -= 1;
@@ -107,6 +143,7 @@ const scheduleWarmup = (key, run)=>{
     runNextWarmup();
     return ()=>{
         task.cancelled = true;
+        if (warmupQueue.includes(task)) warmupCache.delete(task.key);
     };
 };
 const setRef = (ref, value)=>{
@@ -190,16 +227,17 @@ function usePrefetchBehavior(prefetch, preload, theirElementProps) {
         setViewportElement
     ];
 }
-async function loadRouteModule(route, routeAssets) {
+async function loadRouteModule(route, routeAssets, chunkLoader) {
     const routeId = route.id;
     if (!routeId) return;
     if (!routeAssets[routeId]) return;
     const { chunkIds } = routeAssets[routeId];
     if (!chunkIds) return;
     try {
-        await Promise.all(chunkIds.map((chunkId)=>__webpack_chunk_load__?.(chunkId)));
+        await Promise.all(chunkIds.map((chunkId)=>chunkLoader(chunkId)));
     } catch (error) {
         console.error(error);
+        throw error;
     }
 }
 const getRequestUrl = (pathname, routeId)=>{
@@ -232,22 +270,31 @@ const PrefetchPageLinks = ({ path, includeData })=>{
         pathname,
         routes
     ]);
+    const chunkLoader = getWebpackChunkLoader();
+    const routeAssetGeneration = JSON.stringify([
+        getWebpackPublicPath(),
+        matches?.map(({ route: { id } })=>[
+                id,
+                routeAssets?.[id]?.chunkIds
+            ])
+    ]);
     external_react_default().useEffect(()=>{
-        if (!allowNetworkWarmup || !Array.isArray(matches) || !routeAssets || !__webpack_chunk_load__) return;
+        if (!allowNetworkWarmup || !Array.isArray(matches) || !routeAssets || !chunkLoader) return;
         const cancellations = matches.map((match)=>{
             const routeId = match.route.id;
             const routeAsset = routeId ? routeAssets[routeId] : void 0;
             const chunkIds = routeAsset?.chunkIds;
             if (!routeId || !Array.isArray(chunkIds) || 0 === chunkIds.length) return ()=>{};
-            return scheduleWarmup(`route-module:${routeId}:${chunkIds.join(',')}`, ()=>loadRouteModule(match.route, routeAssets));
+            return scheduleWarmup((0, runtime_extensions_namespaceObject.getNavigationWarmupCacheKey)(context, chunkLoader, getWebpackPublicPath(), `route-module:${routeId}:${chunkIds.join(',')}`), ()=>loadRouteModule(match.route, routeAssets, chunkLoader));
         });
         return ()=>{
             cancellations.forEach((cancel)=>cancel());
         };
     }, [
         allowNetworkWarmup,
-        matches,
-        routeAssets
+        chunkLoader,
+        context,
+        routeAssetGeneration
     ]);
     if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(PrefetchDataLinks, {

package/dist/cjs/router/runtime/redirect.js

@@ -30,7 +30,17 @@ __webpack_require__.r(__webpack_exports__);
 const handleRSCRedirect = (headers, basename, status)=>{
     const newHeaders = new Headers(headers);
     let redirectUrl = headers.get('Location');
-    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    if (!redirectUrl || ![
+        301,
+        302,
+        303,
+        307,
+        308
+    ].includes(status) || !URL.canParse(redirectUrl, 'http://localhost')) return new Response(null, {
+        status,
+        headers: newHeaders
+    });
+    if ('/' !== basename && redirectUrl.startsWith(basename)) redirectUrl = redirectUrl.slice(basename.length) || '/';
     newHeaders.set('X-Modernjs-Redirect', redirectUrl);
     newHeaders.set('X-Modernjs-BaseUrl', basename);
     newHeaders.delete('Location');

package/dist/cjs/router/runtime/utils.js

@@ -227,12 +227,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'
     };
 }

package/dist/esm/cli/ssr/loadable-bundler-plugin.mjs

@@ -12,7 +12,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/esm/core/browser/hydrate.mjs

@@ -5,18 +5,8 @@ import { hydrateRoot } from "react-dom/client";
 import { RenderLevel } from "../constants.mjs";
 import { wrapRuntimeContextProvider } from "../react/wrapper.mjs";
 import { WithCallback } from "./withCallback.mjs";
-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(hydrateRoot(rootElement, App, {

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

@@ -4,8 +4,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/esm/core/context/runtime.mjs

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