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

package/dist/esm/exports/head.mjs

@@ -3,247 +3,18 @@ import react from "react";
 import { Helmet, HelmetData, HelmetProvider } from "react-helmet-async";
 import { InternalRuntimeContext } from "../core/context/index.mjs";
 import { ensureHelmetContext } from "../core/context/helmetContext.mjs";
-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)=>{
-    react.Children.forEach(children, (child)=>{
-        if (!react.isValidElement(child)) return;
-        if (child.type === react.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 = react.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();
+import * as __rspack_external__modern_js_runtime_extensions_ce611631 from "@modern-js/runtime-extensions";
 const collectServerHelmet = (runtimeContext, props)=>{
     const helmetContext = 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 = ()=>__rspack_external__modern_js_runtime_extensions_ce611631.createHelmetRecord(react, props);
+    const deriveState = (records)=>__rspack_external__modern_js_runtime_extensions_ce611631.deriveHelmetServerState(react, records);
+    const marker = __rspack_external__modern_js_runtime_extensions_ce611631.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
+    if (void 0 !== marker) return marker;
+    helmetContext.helmet = __rspack_external__modern_js_runtime_extensions_ce611631.collectImmediateHelmetState(react, helmetContext, createRecord());
 };
 const head_Helmet = (props)=>{
     const runtimeContext = react.useContext(InternalRuntimeContext);
-    if (null !== runtimeContext && false === runtimeContext.isBrowser) {
-        collectServerHelmet(runtimeContext, props);
-        return null;
-    }
+    if (null !== runtimeContext && false === runtimeContext.isBrowser) return __rspack_external__modern_js_runtime_extensions_ce611631.renderHeadMarker(react, collectServerHelmet(runtimeContext, props));
     return react.createElement(Helmet, props);
 };
 const head = {
@@ -253,4 +24,4 @@ const head = {
 };
 const exports_head = head;
 export default exports_head;
-export { HelmetData, HelmetProvider, head_Helmet as Helmet };
+export { head_Helmet as Helmet };

package/dist/esm/module-federation/last-known-good.mjs

@@ -1,3 +1,4 @@
+import { selectResolvedSurface } from "@modern-js/utils/universal";
 import { createDiscoveryError, deliveryUnitResolutionKey } from "./surface-resolution-types.mjs";
 const LAST_KNOWN_GOOD_PROVIDER_NAME = 'last-known-good';
 function createInMemoryLkgStorage() {
@@ -31,16 +32,38 @@ function staleRecordResult(ref, env, ageMs, maxStaleMs) {
         })
     };
 }
+function resolutionAnswersRef(resolved, ref) {
+    const selected = 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 = 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 {
@@ -52,6 +75,7 @@ function createLastKnownGoodProvider(options) {
         name: LAST_KNOWN_GOOD_PROVIDER_NAME,
         async resolve (ref, env) {
             const key = deliveryUnitResolutionKey(ref.unitId, env);
+            const generation = ++nextResolutionGeneration;
             let resolution;
             try {
                 resolution = await options.provider.resolve(ref, env);
@@ -68,7 +92,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: 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/esm/router/cli/nestedRoutesSpec.mjs

@@ -1,38 +1,11 @@
 import node_path from "node:path";
-import { setTimeout as promises_setTimeout } from "node:timers/promises";
 import { fs } from "@modern-js/utils";
 import { cloneDeep } from "@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 fs.ensureDir(node_path.dirname(specPath));
-    while(true){
-        try {
-            await fs.mkdir(lockDir);
-            return async ()=>{
-                await fs.remove(lockDir);
-            };
-        } catch (error) {
-            if ('EEXIST' !== error.code) throw error;
-        }
-        try {
-            const stat = await fs.stat(lockDir);
-            if (performance.timeOrigin + performance.now() - stat.mtimeMs > staleLockAgeMs) {
-                await fs.remove(lockDir);
-                continue;
-            }
-        } catch (error) {
-            if ('ENOENT' !== error.code) throw error;
-            continue;
-        }
-        await promises_setTimeout(lockPollIntervalMs);
-    }
-}
 async function writeJSONAtomically(filePath, value) {
     const directory = node_path.dirname(filePath);
+    await fs.ensureDir(directory);
     const tempPath = node_path.join(directory, `.${node_path.basename(filePath)}.${process.pid}.${tempFileCounter += 1}.tmp`);
     try {
         await fs.writeFile(tempPath, `${JSON.stringify(value)}\n`);
@@ -47,16 +20,12 @@ async function updateNestedRoutesSpec(specPath, nextRoutes) {
     const nextRoutesSnapshot = 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 fs.pathExists(resolvedSpecPath) ? await fs.readJSON(resolvedSpecPath) : {};
-            await writeJSONAtomically(resolvedSpecPath, {
-                ...existingRoutes,
-                ...nextRoutesSnapshot
-            });
-        } finally{
-            await releaseLock();
-        }
+        const existingRoutes = await fs.pathExists(resolvedSpecPath) ? await fs.readJSON(resolvedSpecPath) : {};
+        const mergedRoutes = {
+            ...existingRoutes,
+            ...nextRoutesSnapshot
+        };
+        await writeJSONAtomically(resolvedSpecPath, mergedRoutes);
     });
     pendingUpdates.set(resolvedSpecPath, currentUpdate);
     try {

package/dist/esm/router/runtime/PrefetchLink.mjs

@@ -1,8 +1,18 @@
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { getNavigationWarmupCacheKey } from "@modern-js/runtime-extensions";
 import { Link as router_Link, NavLink, matchRoutes, useHref, useMatches, useResolvedPath } from "@modern-js/runtime-utils/router";
 import react, { useContext, useMemo } from "react";
 import { InternalRuntimeContext } from "../../core/context/index.mjs";
+import { __webpack_require__ } from "../../rslib-runtime.mjs";
+const getWebpackChunkLoader = ()=>__webpack_chunk_load__;
+const getWebpackPublicPath = ()=>{
+    try {
+        return __webpack_require__.p || '';
+    } catch  {
+        return '';
+    }
+};
 function composeEventHandlers(theirHandler, ourHandler) {
     return (event)=>{
         theirHandler?.(event);
@@ -41,8 +51,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;
@@ -64,6 +73,7 @@ const scheduleWarmup = (key, run)=>{
     runNextWarmup();
     return ()=>{
         task.cancelled = true;
+        if (warmupQueue.includes(task)) warmupCache.delete(task.key);
     };
 };
 const setRef = (ref, value)=>{
@@ -147,16 +157,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)=>{
@@ -189,22 +200,31 @@ const PrefetchPageLinks = ({ path, includeData })=>{
         pathname,
         routes
     ]);
+    const chunkLoader = getWebpackChunkLoader();
+    const routeAssetGeneration = JSON.stringify([
+        getWebpackPublicPath(),
+        matches?.map(({ route: { id } })=>[
+                id,
+                routeAssets?.[id]?.chunkIds
+            ])
+    ]);
     react.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(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__*/ jsx(PrefetchDataLinks, {

package/dist/esm/router/runtime/redirect.mjs

@@ -1,7 +1,17 @@
 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/esm/router/runtime/utils.mjs

@@ -176,12 +176,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/rslib-runtime.mjs

@@ -0,0 +1,9 @@
+var __webpack_require__ = {};
+(()=>{
+    var scriptUrl;
+    if ("string" == typeof import.meta.url) scriptUrl = import.meta.url;
+    if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
+    scriptUrl = scriptUrl.replace(/^blob:/, "").replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+    __webpack_require__.p = scriptUrl;
+})();
+export { __webpack_require__ };

package/dist/esm-node/cli/ssr/index.mjs

@@ -109,7 +109,7 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                             'process.env.MODERN_ENABLE_HYDRATION': JSON.stringify(isUseSSRBundle(userConfig)),
                             'process.env.MODERN_ENABLE_RSC': JSON.stringify(Boolean(userConfig.server?.rsc)),
                             __MODERN_ENABLE_RSC__: JSON.stringify(Boolean(userConfig.server?.rsc)),
-                            'process.env.MODERN_MF_APP_SSR': JSON.stringify(isModuleFederationAppSSR)
+                            'process.env.MODERN_MF_APP_SSR': JSON.stringify(String(isModuleFederationAppSSR))
                         }
                     },
                     output: outputConfig,

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

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

@@ -6,18 +6,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-node/core/context/extensions.mjs

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

@@ -4,8 +4,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,

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

@@ -1,16 +1,18 @@
 import "node:module";
 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: {
@@ -30,9 +32,9 @@ function createRscSafeRequestContext(ssrContext) {
             host: request.host,
             referer: request.referer
         },
-        response: {
+        response: Object.assign(requestContext.response, {
             locals: response.locals ?? {}
-        }
+        })
     };
 }
 function wrapRuntimeContextProvider(App, contextValue) {