@bleedingdev/modern-js-runtime 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

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

@@ -28,64 +28,26 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createRouterPlugin: ()=>createRouterPlugin,
-    createRouterProviderRealm: ()=>external_provider_js_namespaceObject.createRouterProviderRealm,
-    default: ()=>internal,
+    default: ()=>external_plugin_js_namespaceObject.routerPlugin,
     modifyRoutes: ()=>external_plugin_js_namespaceObject.modifyRoutes,
-    registerRouterProvider: ()=>external_provider_js_namespaceObject.registerRouterProvider,
     renderRoutes: ()=>external_utils_js_namespaceObject.renderRoutes,
-    resolveRouterProvider: ()=>external_provider_js_namespaceObject.resolveRouterProvider,
-    routerPlugin: ()=>routerPlugin
+    routerPlugin: ()=>external_plugin_js_namespaceObject.routerPlugin,
+    routerProviderRegistryHooks: ()=>external_hooks_js_namespaceObject.routerProviderRegistryHooks
 });
-const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_plugin_js_namespaceObject = require("./plugin.js");
-const external_provider_js_namespaceObject = require("./provider.js");
 const external_utils_js_namespaceObject = require("./utils.js");
-(0, external_provider_js_namespaceObject.registerRouterProvider)('react-router', external_plugin_js_namespaceObject.routerPlugin, {
-    isDefault: true
-});
-const createRouterPlugin = (localProviders = [])=>{
-    const providerRealm = (0, external_provider_js_namespaceObject.createRouterProviderRealm)([
-        {
-            name: 'react-router',
-            factory: external_plugin_js_namespaceObject.routerPlugin,
-            isDefault: true
-        },
-        ...localProviders
-    ]);
-    return (userConfig = {})=>({
-            name: '@modern-js/plugin-router',
-            registryHooks: external_provider_js_namespaceObject.routerProviderRegistryHooks,
-            setup: (api)=>{
-                const mergedConfig = (0, merge_namespaceObject.merge)(api.getRuntimeConfig().router || {}, userConfig);
-                const pluginFactory = (0, external_provider_js_namespaceObject.resolveRouterProvider)(mergedConfig.framework, {
-                    realm: providerRealm
-                });
-                const providerPlugin = pluginFactory(userConfig);
-                (0, external_provider_js_namespaceObject.reportUnsupportedProviderRegistryHooks)(providerPlugin);
-                providerPlugin.setup?.(api);
-            }
-        });
-};
-const routerPlugin = createRouterPlugin();
-const internal = routerPlugin;
-exports.createRouterPlugin = __webpack_exports__.createRouterPlugin;
-exports.createRouterProviderRealm = __webpack_exports__.createRouterProviderRealm;
 exports["default"] = __webpack_exports__["default"];
 exports.modifyRoutes = __webpack_exports__.modifyRoutes;
-exports.registerRouterProvider = __webpack_exports__.registerRouterProvider;
 exports.renderRoutes = __webpack_exports__.renderRoutes;
-exports.resolveRouterProvider = __webpack_exports__.resolveRouterProvider;
 exports.routerPlugin = __webpack_exports__.routerPlugin;
+exports.routerProviderRegistryHooks = __webpack_exports__.routerProviderRegistryHooks;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createRouterPlugin",
-    "createRouterProviderRealm",
     "default",
     "modifyRoutes",
-    "registerRouterProvider",
     "renderRoutes",
-    "resolveRouterProvider",
-    "routerPlugin"
+    "routerPlugin",
+    "routerProviderRegistryHooks"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -34,14 +34,13 @@ __webpack_require__.d(__webpack_exports__, {
     routerPlugin: ()=>routerPlugin
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
 const router_namespaceObject = require("@modern-js/runtime-utils/router");
 const url_namespaceObject = require("@modern-js/runtime-utils/url");
 const external_react_namespaceObject = require("react");
-const index_js_namespaceObject = require("../../core/context/index.js");
-const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_PrefetchLink_js_namespaceObject = require("./PrefetchLink.js");
-const external_provider_js_namespaceObject = require("./provider.js");
 const external_rsc_router_js_namespaceObject = require("./rsc-router.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 let finalRouteConfig = {
@@ -57,7 +56,7 @@ function modifyRoutes(modifyFunction) {
 }
 const routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
-        registryHooks: external_provider_js_namespaceObject.routerProviderRegistryHooks,
+        registryHooks: external_hooks_js_namespaceObject.routerProviderRegistryHooks,
         setup: (api)=>{
             const routesContainer = {
                 current: []
@@ -93,8 +92,8 @@ const routerPlugin = (userConfig = {})=>({
                 const mergedConfig = (0, merge_namespaceObject.merge)(api.getRuntimeConfig().router || {}, userConfig);
                 const { serverBase = [], supportHtml5History = true, basename = '', routesConfig, createRoutes } = mergedConfig;
                 finalRouteConfig = {
-                    routes: (0, index_js_namespaceObject.getGlobalRoutes)(),
-                    globalApp: (0, index_js_namespaceObject.getGlobalLayoutApp)(),
+                    routes: (0, context_namespaceObject.getGlobalRoutes)(),
+                    globalApp: (0, context_namespaceObject.getGlobalLayoutApp)(),
                     ...routesConfig
                 };
                 if (!finalRouteConfig.routes && !createRoutes) return App;
@@ -102,9 +101,8 @@ const routerPlugin = (userConfig = {})=>({
                     const match = serverBase.find((baseUrl)=>isSegmentPrefix(pathname, baseUrl));
                     return match || '/';
                 };
-                let cachedRouter = null;
                 const RouterWrapper = (props)=>{
-                    const routerResult = useRouterCreation(("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, index_js_namespaceObject.getGlobalEnableRsc)()) ? {
+                    const routerResult = useRouterCreation(("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, context_namespaceObject.getGlobalEnableRsc)()) ? {
                         ...props,
                         rscPayload: props?.rscPayload
                     } : props, {
@@ -114,12 +112,7 @@ const routerPlugin = (userConfig = {})=>({
                         selectBasePath,
                         basename
                     });
-                    const router = (0, external_react_namespaceObject.useMemo)(()=>{
-                        if (cachedRouter) return cachedRouter;
-                        cachedRouter = routerResult.router;
-                        return cachedRouter;
-                    }, []);
-                    const { routes } = routerResult;
+                    const { router, routes } = routerResult;
                     routesContainer.current = routes;
                     beforeCreateRouter = false;
                     const routerContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
@@ -157,19 +150,20 @@ function isSegmentPrefix(pathname, base) {
 }
 function useRouterCreation(props, options) {
     const { api, createRoutes, supportHtml5History, selectBasePath, basename } = options;
-    const runtimeContext = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
+    const runtimeContext = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
     const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
     const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
     const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
-    const rscPayload = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, index_js_namespaceObject.getGlobalEnableRsc)()) && props?.rscPayload ? safeUse(props.rscPayload) : null;
-    let hydrationData = "u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA : true === (0, index_js_namespaceObject.getGlobalEnableRsc)() ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
-    return (0, external_react_namespaceObject.useMemo)(()=>{
+    const rscPayload = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, context_namespaceObject.getGlobalEnableRsc)()) && props?.rscPayload ? safeUse(props.rscPayload) : null;
+    let hydrationData = "u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA : true === (0, context_namespaceObject.getGlobalEnableRsc)() ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
+    const result = (0, external_react_namespaceObject.useRef)(null);
+    if (null === result.current) {
         if (hydrationData?.errors) hydrationData = {
             ...hydrationData,
             errors: (0, external_utils_js_namespaceObject.deserializeErrors)(hydrationData.errors)
         };
         let routes = null;
-        routes = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, index_js_namespaceObject.getGlobalEnableRsc)()) && (0, index_js_namespaceObject.getGlobalIsRscClient)() ? createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
+        routes = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, context_namespaceObject.getGlobalEnableRsc)()) && (0, context_namespaceObject.getGlobalIsRscClient)() ? createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
             routesConfig: finalRouteConfig
         }) : createRoutes ? createRoutes() : (0, router_namespaceObject.createRoutesFromElements)((0, external_utils_js_namespaceObject.renderRoutes)({
             routesConfig: finalRouteConfig,
@@ -177,12 +171,13 @@ function useRouterCreation(props, options) {
         }));
         if (!routes) routes = [];
         const hooks = api.getHooks();
-        if (("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, index_js_namespaceObject.getGlobalEnableRsc)()) && rscPayload) try {
+        if (("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, context_namespaceObject.getGlobalEnableRsc)()) && rscPayload) try {
             const router = (0, external_rsc_router_js_namespaceObject.createClientRouterFromPayload)(rscPayload, routes, _basename);
-            return {
+            result.current = {
                 router,
                 routes: router.routes || []
             };
+            return result.current;
         } catch (e) {
             console.error('Failed to create router from RSC payload:', e);
         }
@@ -203,11 +198,6 @@ function useRouterCreation(props, options) {
             basename: _basename,
             hydrationData
         });
-        (0, external_lifecycle_js_namespaceObject.applyRouterRuntimeState)(runtimeContext, {
-            framework: 'react-router',
-            basename: _basename,
-            instance: router
-        });
         hooks.onAfterCreateRouter.call({
             ...routerLifecycleContext,
             router,
@@ -236,17 +226,12 @@ function useRouterCreation(props, options) {
             };
             return originSubscribe(wrappedListener);
         };
-        return {
+        result.current = {
             router,
             routes: modifiedRoutes
         };
-    }, [
-        finalRouteConfig,
-        props,
-        _basename,
-        hydrationData,
-        getBlockNavState
-    ]);
+    }
+    return result.current;
 }
 exports.beforeCreateRouter = __webpack_exports__.beforeCreateRouter;
 exports.finalRouteConfig = __webpack_exports__.finalRouteConfig;

package/dist/cjs/router/runtime/plugin.node.js

@@ -41,19 +41,18 @@ __webpack_require__.d(__webpack_exports__, {
     routerPlugin: ()=>routerPlugin
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
 const router_namespaceObject = require("@modern-js/runtime-utils/router");
 const time_namespaceObject = require("@modern-js/runtime-utils/time");
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const external_react_namespaceObject = require("react");
-const index_js_namespaceObject = require("../../core/context/index.js");
 const index_server_js_namespaceObject = require("../../core/context/serverPayload/index.server.js");
 const external_DeferredDataScripts_node_js_namespaceObject = require("./DeferredDataScripts.node.js");
 var external_DeferredDataScripts_node_js_default = /*#__PURE__*/ __webpack_require__.n(external_DeferredDataScripts_node_js_namespaceObject);
-const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_PrefetchLink_js_namespaceObject = require("./PrefetchLink.js");
-const external_provider_js_namespaceObject = require("./provider.js");
 const external_rsc_router_js_namespaceObject = require("./rsc-router.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 function createRemixRequest(request) {
@@ -66,27 +65,9 @@ function createRemixRequest(request) {
         signal: controller.signal
     });
 }
-function createReactRouterServerSnapshot(routerContext, basename) {
-    return (0, external_lifecycle_js_namespaceObject.createRouterServerSnapshot)({
-        framework: 'react-router',
-        basename,
-        statusCode: routerContext.statusCode,
-        errors: routerContext.errors,
-        routerData: {
-            loaderData: routerContext.loaderData,
-            errors: routerContext.errors
-        },
-        matches: routerContext.matches.map((match)=>{
-            const routeId = match.route.id;
-            return 'string' == typeof routeId ? {
-                routeId
-            } : void 0;
-        }).filter((match)=>void 0 !== match)
-    });
-}
 const routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
-        registryHooks: external_provider_js_namespaceObject.routerProviderRegistryHooks,
+        registryHooks: external_hooks_js_namespaceObject.routerProviderRegistryHooks,
         setup: (api)=>{
             let finalRouteConfig = {};
             api.onBeforeRender(async (context, interrupt)=>{
@@ -100,12 +81,12 @@ const routerPlugin = (userConfig = {})=>({
                 const pluginConfig = api.getRuntimeConfig();
                 const { basename = '', routesConfig, createRoutes } = (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
                 finalRouteConfig = {
-                    routes: (0, index_js_namespaceObject.getGlobalRoutes)(),
-                    globalApp: (0, index_js_namespaceObject.getGlobalLayoutApp)(),
+                    routes: (0, context_namespaceObject.getGlobalRoutes)(),
+                    globalApp: (0, context_namespaceObject.getGlobalLayoutApp)(),
                     ...routesConfig
                 };
                 if (!finalRouteConfig.routes && !createRoutes) return;
-                const enableRsc = (0, index_js_namespaceObject.getGlobalEnableRsc)();
+                const enableRsc = (0, context_namespaceObject.getGlobalEnableRsc)();
                 if (enableRsc) await (0, external_rsc_router_js_namespaceObject.prepareRSCRoutes)(finalRouteConfig.routes);
                 const { request, mode: ssrMode, nonce, loaderFailureMode = 'errorBoundary', baseUrl } = context.ssrContext;
                 const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, basename) : baseUrl;
@@ -150,18 +131,9 @@ const routerPlugin = (userConfig = {})=>({
                     throw errors[0];
                 }
                 context.routerContext = routerContext;
-                const routerServerSnapshot = createReactRouterServerSnapshot(routerContext, _basename);
-                (0, external_lifecycle_js_namespaceObject.applyRouterRuntimeState)(context, {
-                    framework: 'react-router',
-                    basename: _basename,
-                    instance: routerContext,
-                    matchedRouteIds: routerServerSnapshot.matchedRouteIds,
-                    serverSnapshot: routerServerSnapshot
-                });
                 hooks.onAfterCreateRouter.call({
                     ...routerLifecycleContext,
                     router: routerContext,
-                    serverSnapshot: routerServerSnapshot,
                     runtimeContext: context
                 });
                 let payload;
@@ -182,9 +154,9 @@ const routerPlugin = (userConfig = {})=>({
             api.wrapRoot((App)=>{
                 if (!finalRouteConfig) return App;
                 const getRouteApp = ()=>{
-                    const enableRsc = (0, index_js_namespaceObject.getGlobalEnableRsc)();
+                    const enableRsc = (0, context_namespaceObject.getGlobalEnableRsc)();
                     return (props)=>{
-                        const context = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
+                        const context = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
                         const { routerContext, routes } = context;
                         const { basename } = routerContext;
                         if (enableRsc) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
@@ -194,7 +166,7 @@ const routerPlugin = (userConfig = {})=>({
                         }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_rsc_router_js_namespaceObject.RSCStaticRouter, {
                             basename: basename
                         });
-                        {
+                        else {
                             const { nonce, mode, useJsonScript } = context.ssrContext;
                             const remixRouter = (0, router_namespaceObject.createStaticRouter)(routes, routerContext);
                             const routerWrapper = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {

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

@@ -30,7 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 const handleRSCRedirect = (headers, basename, status)=>{
     const newHeaders = new Headers(headers);
     let redirectUrl = headers.get('Location');
-    if (!redirectUrl || ![
+    if (null === redirectUrl || '' === redirectUrl || ![
         301,
         302,
         303,

package/dist/esm/cli/code.mjs

@@ -73,7 +73,9 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 const bootstrapFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_BOOTSTRAP_FILE_NAME}`);
                 await fs.outputFile(bootstrapFile, `import(/* webpackChunkName: "async-${entryName}" */ './${INDEX_FILE_NAME}');`, 'utf8');
                 const bootstrapServerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_SERVER_BOOTSTRAP_FILE_NAME}`);
-                if (ssrMode) await fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler)`, 'utf8');
+                if (ssrMode) await fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler);
+// The renderer awaits this promise later; retain its rejection without an early unhandled rejection.
+requestHandler.catch(() => {});`, 'utf8');
             }
             if (ssrMode) {
                 const indexServerCode = __rspack_external__template_server_mjs_f98cfe58.serverIndex({

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

@@ -2,51 +2,6 @@ import { LOADABLE_STATS_FILE, isUseSSRBundle } from "@modern-js/utils";
 import path from "path";
 import loadable_bundler_plugin from "./loadable-bundler-plugin.mjs";
 import { resolveSSRMode } from "./mode.mjs";
-const getRspackPlugins = (rspackConfig)=>{
-    if (!rspackConfig) return [];
-    const rspackEntries = Array.isArray(rspackConfig) ? rspackConfig : [
-        rspackConfig
-    ];
-    const plugins = [];
-    for (const entry of rspackEntries){
-        if (!entry || 'function' == typeof entry || 'object' != typeof entry) continue;
-        const maybePlugins = entry.plugins;
-        if (Array.isArray(maybePlugins)) {
-            for (const plugin of maybePlugins)if (plugin) plugins.push(plugin);
-        }
-    }
-    return plugins;
-};
-const getRspackPluginName = (plugin)=>{
-    if ('string' == typeof plugin) return plugin;
-    if ('function' == typeof plugin) return plugin.name;
-    if (Array.isArray(plugin)) {
-        const [first] = plugin;
-        if (!first) return;
-        if ('string' == typeof first) return first;
-        if ('function' == typeof first) return first.name;
-        if ('object' == typeof first) return first.name || first.constructor?.name;
-        return;
-    }
-    return plugin.name || plugin.constructor?.name;
-};
-const hasServerRenderingConfig = (userConfig)=>{
-    const { output, server } = userConfig;
-    if (output?.ssg) return true;
-    if (output?.ssgByEntries && Object.keys(output.ssgByEntries).length > 0) return true;
-    if (server?.ssr) return true;
-    if (server?.ssrByEntries && Object.keys(server.ssrByEntries).length > 0) return true;
-    return false;
-};
-const isModuleFederationAppSSREnabledInConfig = (ssr)=>{
-    if (!ssr || 'object' != typeof ssr) return false;
-    return true === ssr.moduleFederationAppSSR;
-};
-const isModuleFederationAppSSREnabled = (userConfig)=>{
-    if (isModuleFederationAppSSREnabledInConfig(userConfig.server?.ssr)) return true;
-    if (userConfig.server?.ssrByEntries && 'object' == typeof userConfig.server.ssrByEntries) return Object.values(userConfig.server.ssrByEntries).some(isModuleFederationAppSSREnabledInConfig);
-    return false;
-};
 const checkUseStringSSR = (config, appDirectory, entrypoints)=>{
     if (entrypoints && entrypoints.length > 0) {
         for (const entrypoint of entrypoints){
@@ -62,41 +17,19 @@ const checkUseStringSSR = (config, appDirectory, entrypoints)=>{
     }
     return true;
 };
-const isModuleFederationRspackPlugin = (plugin)=>{
-    const candidate = getRspackPluginName(plugin);
-    return 'string' == typeof candidate && /modulefederation/i.test(candidate);
-};
-const hasModuleFederationMarker = (config)=>{
-    if ('true' === process.env.MF_SSR_PRJ) return true;
-    const define = config.source?.define || {};
-    if ('REMOTE_IP_STRATEGY' in define || 'FEDERATION_IPV4' in define) return true;
-    const plugins = getRspackPlugins(config.tools?.rspack);
-    return plugins.some(isModuleFederationRspackPlugin);
-};
 const isNodeEnvironmentTarget = (target)=>'string' == typeof target && ('node' === target || 'async-node' === target || target.startsWith('node'));
-const shouldUseModuleFederationNodeOutput = (config)=>isNodeEnvironmentTarget(config.output?.target) && hasModuleFederationMarker(config);
 const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
         name: '@modern-js/builder-plugin-ssr',
         setup (api) {
             api.modifyEnvironmentConfig((config, { name, mergeEnvironmentConfig })=>{
                 const isServerEnvironment = isNodeEnvironmentTarget(config.output.target) || 'workerSSR' === name;
                 const userConfig = modernAPI.getNormalizedConfig();
-                const hasServerRendering = hasServerRenderingConfig(userConfig);
-                const hasModuleFederationRuntimeMarker = hasServerRendering && shouldUseModuleFederationNodeOutput(config);
-                const hasExplicitMfSsrFlag = isModuleFederationAppSSREnabled(userConfig);
-                const requireExplicitMfSsrFlag = 'true' === process.env.MODERN_MF_APP_SSR_REQUIRE_EXPLICIT;
-                if (hasServerRendering && hasModuleFederationRuntimeMarker && !hasExplicitMfSsrFlag) {
-                    const warningMessage = '[modernjs][mf-ssr] Module Federation SSR was auto-detected from runtime markers. Set server.ssr.moduleFederationAppSSR=true explicitly in host and remotes to avoid heuristic drift.';
-                    if (requireExplicitMfSsrFlag) throw new Error(`${warningMessage} (enforced by MODERN_MF_APP_SSR_REQUIRE_EXPLICIT=true)`);
-                    console.warn(warningMessage);
-                }
-                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag;
                 const ssrEnv = userConfig.deploy?.worker?.ssr || userConfig.server?.rsc ? 'edge' : 'node';
                 const appContext = modernAPI.getAppContext();
                 const { appDirectory, entrypoints } = appContext;
                 const useLoadablePlugin = isUseSSRBundle(userConfig) && !isServerEnvironment && checkUseStringSSR(userConfig, appDirectory, entrypoints);
                 const outputConfig = {
-                    module: isServerEnvironment && (outputModule || 'workerSSR' === name && userConfig.deploy?.target === 'cloudflare')
+                    module: isServerEnvironment && outputModule
                 };
                 const useLoadableComponents = isUseSSRBundle(userConfig) && checkUseStringSSR(userConfig, appDirectory, entrypoints);
                 return mergeEnvironmentConfig(config, {
@@ -106,12 +39,10 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                             'process.env.MODERN_SSR_ENV': JSON.stringify(ssrEnv),
                             '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(String(isModuleFederationAppSSR))
+                            __MODERN_ENABLE_RSC__: JSON.stringify(Boolean(userConfig.server?.rsc))
                         }
                     },
                     output: outputConfig,
-                    splitChunks: isServerEnvironment && (hasModuleFederationRuntimeMarker || hasExplicitMfSsrFlag) ? false : void 0,
                     tools: {
                         bundlerChain: useLoadablePlugin ? (chain)=>{
                             chain.plugin('loadable').use(loadable_bundler_plugin, [
@@ -180,4 +111,4 @@ const ssrPlugin = ()=>({
     });
 const cli_ssr = ssrPlugin;
 export default cli_ssr;
-export { shouldUseModuleFederationNodeOutput, ssrPlugin };
+export { ssrPlugin };

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

@@ -2,6 +2,7 @@ import { fs } from "@modern-js/utils";
 import path_0 from "path";
 const normalizeChunkId = (id)=>'string' == typeof id && /^\d+$/.test(id) ? Number(id) : id;
 const DEFAULT_CHUNK_LOADING_GLOBAL = '__LOADABLE_LOADED_CHUNKS__';
+const normalizeStatsPublicPath = (publicPath)=>'auto' === publicPath || 'auto/' === publicPath ? '/' : publicPath;
 const normalizeChunkGroup = (group)=>({
         ...group,
         chunks: (group.chunks || []).map(normalizeChunkId)
@@ -44,6 +45,7 @@ class LoadablePlugin {
         for (const [name, ep] of Object.entries(stats.entrypoints || {}))entrypoints[name] = normalizeChunkGroup(ep);
         const output = {
             ...stats,
+            publicPath: normalizeStatsPublicPath(stats.publicPath),
             namedChunkGroups,
             entrypoints,
             generator: 'loadable-components',

package/dist/esm/cli/template.server.mjs

@@ -120,8 +120,7 @@ function genHandlerCode({ mode, metaName, customServerEntry, srcDirectory, inter
         return `
       export * from '${realEntryPath}';
       export { default as requestHandler } from '${realEntryPath}'`;
-    }
-    {
+    } else {
         const entrySource = enableRsc ? SERVER_ENTRY_RSC : SERVER_ENTRY;
         const serverEntry = transformServerEntry(entrySource, {
             metaName: metaName || 'modern-js',

package/dist/esm/core/browser/hydrate.mjs

@@ -1,4 +1,4 @@
-import { jsx } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { loadableReady } from "@loadable/component";
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 import { hydrateRoot } from "react-dom/client";
@@ -29,18 +29,23 @@ function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
     if ('stream' === renderMode) return streamSSRHydrate();
     function streamSSRHydrate() {
         if (renderLevel !== RenderLevel.SERVER_RENDER) return ModernRender(wrapRuntimeContextProvider(App, context));
-        {
+        else {
             const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
                     callback: callback,
                     children: App
                 });
-            return ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext));
+            return ModernHydrate(/*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext),
+                    null
+                ]
+            }));
         }
     }
     return stringSSRHydrate();
     function stringSSRHydrate() {
         if (renderLevel === RenderLevel.CLIENT_RENDER) return ModernRender(wrapRuntimeContextProvider(App, context));
-        {
+        else {
             if (renderLevel === RenderLevel.SERVER_RENDER) return loadableReady(()=>void 0, loadableReadyOptions).then(()=>{
                 const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
                         callback: callback,
@@ -48,13 +53,7 @@ function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
                     });
                 return ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext));
             });
-            const runtimeConsole = Reflect.get(globalThis, 'console');
-            if (null !== runtimeConsole && 'object' == typeof runtimeConsole) {
-                const warn = Reflect.get(runtimeConsole, 'warn');
-                if ('function' == typeof warn) Reflect.apply(warn, runtimeConsole, [
-                    `unknow render level: ${renderLevel}, execute render()`
-                ]);
-            }
+            console.warn(`unknow render level: ${renderLevel}, execute render()`);
             return ModernRender(wrapRuntimeContextProvider(App, context));
         }
     }

package/dist/esm/core/browser/index.mjs

@@ -1,7 +1,6 @@
+import { getGlobalInternalRuntimeContext, getInitialContext } from "@modern-js/runtime/context";
 import { parseCookie } from "cookie";
 import { createRoot } from "react-dom/client";
-import { getGlobalInternalRuntimeContext } from "../context/index.mjs";
-import { getInitialContext } from "../context/runtime.mjs";
 import { wrapRuntimeContextProvider } from "../react/wrapper.mjs";
 import { hydrateRoot, hydrateWithReact } from "./hydrate.mjs";
 const IS_REACT18 = 'true' === process.env.IS_REACT18;

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

@@ -41,10 +41,7 @@ function getGlobalBasename() {
     return globalContext.basename;
 }
 export { DefaultNotFound } from "../../router/runtime/DefaultNotFound.mjs";
-export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "../../router/runtime/hooks.mjs";
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
-export { createRouterProviderRealm, registerRouterProvider, resolveRouterProvider, routerProviderRegistryHooks } from "../../router/runtime/provider.mjs";
-export { createRuntimeContextExtension } from "./extensions.mjs";
-export { InternalRuntimeContext, RuntimeContext, getInitialContext } from "./runtime.mjs";
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, routerProviderRegistryHooks } from "../../router/runtime/hooks.mjs";
+export { InternalRuntimeContext, ReactRuntimeContext, RuntimeComponentResolverContext, RuntimeContext, getInitialContext, useRuntimeContext } from "./runtime.mjs";
 export { getServerPayload, setServerPayload } from "./serverPayload/index.mjs";
 export { getCurrentEntryName, getGlobalApp, getGlobalBasename, getGlobalEnableRsc, getGlobalInternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRSCRoot, getGlobalRoutes, setGlobalContext, setGlobalInternalRuntimeContext };

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

@@ -1,5 +1 @@
-import { createContext, useContext } from "react";
-const RuntimeContext = createContext({});
-const ReactRuntimeContext = RuntimeContext;
-const useRuntimeContext = ()=>useContext(RuntimeContext);
-export { ReactRuntimeContext, RuntimeContext, useRuntimeContext };
+export { ReactRuntimeContext, RuntimeContext, useRuntimeContext } from "@modern-js/runtime/context";

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

@@ -1,6 +1,10 @@
-import { createContext } from "react";
+import { createContext, useContext } from "react";
 const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
 const InternalRuntimeContext = createContext({});
+const RuntimeContext = createContext({});
+const RuntimeComponentResolverContext = createContext(void 0);
+const ReactRuntimeContext = RuntimeContext;
+const useRuntimeContext = ()=>useContext(RuntimeContext);
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
         request: {
@@ -24,5 +28,4 @@ const getInitialContext = (isBrowser = true, routeManifest)=>{
         context: requestContext
     };
 };
-export { ReactRuntimeContext, RuntimeContext, useRuntimeContext } from "./public.mjs";
-export { InternalRuntimeContext, getInitialContext };
+export { InternalRuntimeContext, ReactRuntimeContext, RuntimeComponentResolverContext, RuntimeContext, getInitialContext, useRuntimeContext };

package/dist/esm/core/index.mjs

@@ -1,2 +1,2 @@
+export { RuntimeContext, useRuntimeContext } from "@modern-js/runtime/context";
 export { defineRuntimeConfig } from "./config.mjs";
-export { RuntimeContext, useRuntimeContext } from "./context/runtime.mjs";

package/dist/esm/core/plugin/index.mjs

@@ -1,9 +1,9 @@
 import { runtime } from "@modern-js/plugin/runtime";
+import { setGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { compatPlugin } from "../compat/index.mjs";
 import { handleSetupResult } from "../compat/hooks.mjs";
 import { requestContextPlugin } from "../compat/requestContext.mjs";
-import { setGlobalInternalRuntimeContext } from "../context/index.mjs";
 function registerPlugin(internalPlugins, runtimeConfig) {
     const { plugins = [] } = runtimeConfig || {};
     const { runtimeContext } = runtime.run({

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

@@ -1,7 +1,7 @@
+import { getGlobalApp, getGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { parsedJSONFromElement } from "@modern-js/runtime-utils/parsed";
 import { isBrowser } from "../../common.mjs";
 import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../constants.mjs";
-import { getGlobalApp, getGlobalInternalRuntimeContext } from "../context/index.mjs";
 function createRoot(UserApp) {
     const App = UserApp || getGlobalApp();
     if (isBrowser()) {