@bleedingdev/modern-js-runtime 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

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

@@ -1,10 +1,9 @@
 "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";
+import { __webpack_require__ } from "../../rslib-runtime~1.mjs";
 const getWebpackChunkLoader = ()=>__webpack_chunk_load__;
 const getWebpackPublicPath = ()=>{
     try {
@@ -20,62 +19,6 @@ function composeEventHandlers(theirHandler, ourHandler) {
     };
 }
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-const DEFAULT_PREFETCH_BEHAVIOR = 'render';
-const INTENT_DELAY = 100;
-const VIEWPORT_ROOT_MARGIN = '200px';
-const MAX_CONCURRENT_WARMUPS = 4;
-const WARMUP_TTL = 30000;
-const SLOW_EFFECTIVE_TYPES = new Set([
-    'slow-2g',
-    '2g'
-]);
-const warmupCache = new Map();
-const warmupQueue = [];
-let activeWarmups = 0;
-const getWarmupTimestamp = ()=>performance.now();
-const getConnection = ()=>{
-    const nav = globalThis.navigator;
-    return nav?.connection || nav?.mozConnection || nav?.webkitConnection;
-};
-const shouldWarmupOnCurrentNetwork = ()=>{
-    const connection = getConnection();
-    if (connection?.saveData) return false;
-    if ('string' == typeof connection?.effectiveType && SLOW_EFFECTIVE_TYPES.has(connection.effectiveType)) return false;
-    return true;
-};
-const pruneWarmupCache = (now = getWarmupTimestamp())=>{
-    for (const [key, timestamp] of warmupCache)if (now - timestamp > WARMUP_TTL) warmupCache.delete(key);
-};
-const runNextWarmup = ()=>{
-    while(activeWarmups < MAX_CONCURRENT_WARMUPS && warmupQueue.length > 0){
-        const task = warmupQueue.shift();
-        if (task.cancelled) continue;
-        activeWarmups += 1;
-        task.run().catch(()=>{
-            warmupCache.delete(task.key);
-        }).finally(()=>{
-            activeWarmups -= 1;
-            runNextWarmup();
-        });
-    }
-};
-const scheduleWarmup = (key, run)=>{
-    if (!shouldWarmupOnCurrentNetwork()) return ()=>{};
-    pruneWarmupCache();
-    if (warmupCache.has(key)) return ()=>{};
-    warmupCache.set(key, getWarmupTimestamp());
-    const task = {
-        key,
-        run,
-        cancelled: false
-    };
-    warmupQueue.push(task);
-    runNextWarmup();
-    return ()=>{
-        task.cancelled = true;
-        if (warmupQueue.includes(task)) warmupCache.delete(task.key);
-    };
-};
 const setRef = (ref, value)=>{
     if (!ref) return;
     if ('function' == typeof ref) return void ref(value);
@@ -83,70 +26,65 @@ const setRef = (ref, value)=>{
         ref.current = value;
     } catch  {}
 };
-const isDataWarmupEnabled = (route)=>{
-    const handle = route.handle;
-    return handle?.navigationWarmup?.data !== false;
-};
-function usePrefetchBehavior(prefetch, preload, theirElementProps) {
-    const [maybeWarmup, setMaybeWarmup] = react.useState(false);
-    const [shouldPrefetch, setShouldPrefetch] = react.useState(false);
-    const [shouldPreload, setShouldPreload] = react.useState(false);
-    const [viewportElement, setViewportElement] = react.useState(null);
+function usePrefetchBehavior(prefetch, preload, theirElementProps, policy) {
+    const [maybePrefetch, setMaybePrefetch] = react.useState(false);
+    const [state, setState] = react.useState({
+        code: false,
+        data: false
+    });
+    const [element, setElement] = react.useState(null);
+    const observerRef = react.useRef(void 0);
     const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
     react.useEffect(()=>{
-        if ('render' === prefetch) setShouldPrefetch(true);
-        if ('render' === preload) setShouldPreload(true);
+        if (!policy) return void setState({
+            code: 'render' === prefetch,
+            data: 'render' === prefetch
+        });
+        const observer = policy.observe({
+            element,
+            prefetch,
+            preload,
+            notify: (next)=>setState((previous)=>previous.code === next.code && previous.data === next.data ? previous : next)
+        });
+        observerRef.current = observer;
+        return ()=>{
+            observerRef.current = void 0;
+            observer.dispose();
+        };
     }, [
+        policy,
         prefetch,
-        preload
+        preload,
+        element
+    ]);
+    react.useEffect(()=>{
+        if (policy || !maybePrefetch) return;
+        const timer = setTimeout(()=>setState({
+                code: true,
+                data: true
+            }), 100);
+        return ()=>clearTimeout(timer);
+    }, [
+        policy,
+        maybePrefetch
     ]);
     const setIntent = ()=>{
-        if ('intent' === prefetch || 'intent' === preload) setMaybeWarmup(true);
+        if (policy) observerRef.current?.onIntent();
+        else if ('intent' === prefetch) setMaybePrefetch(true);
     };
     const cancelIntent = ()=>{
-        if ('intent' === prefetch || 'intent' === preload) {
-            setMaybeWarmup(false);
-            setShouldPrefetch(false);
-            setShouldPreload(false);
+        if (policy) observerRef.current?.onCancel();
+        else if ('intent' === prefetch) {
+            setMaybePrefetch(false);
+            setState({
+                code: false,
+                data: false
+            });
         }
     };
-    react.useEffect(()=>{
-        if (maybeWarmup) {
-            const id = setTimeout(()=>{
-                if ('intent' === prefetch) setShouldPrefetch(true);
-                if ('intent' === preload) setShouldPreload(true);
-            }, INTENT_DELAY);
-            return ()=>{
-                clearTimeout(id);
-            };
-        }
-    }, [
-        maybeWarmup,
-        prefetch,
-        preload
-    ]);
-    react.useEffect(()=>{
-        if (!viewportElement || 'viewport' !== prefetch && 'viewport' !== preload || "u" < typeof IntersectionObserver) return;
-        const observer = new IntersectionObserver((entries)=>{
-            if (!entries.some((entry)=>entry.isIntersecting)) return;
-            if ('viewport' === prefetch) setShouldPrefetch(true);
-            if ('viewport' === preload) setShouldPreload(true);
-            observer.disconnect();
-        }, {
-            rootMargin: VIEWPORT_ROOT_MARGIN
-        });
-        observer.observe(viewportElement);
-        return ()=>{
-            observer.disconnect();
-        };
-    }, [
-        prefetch,
-        preload,
-        viewportElement
-    ]);
     return [
-        shouldPrefetch,
-        shouldPreload,
+        state.data,
+        state.code,
         {
             onFocus: composeEventHandlers(onFocus, setIntent),
             onBlur: composeEventHandlers(onBlur, cancelIntent),
@@ -154,7 +92,7 @@ function usePrefetchBehavior(prefetch, preload, theirElementProps) {
             onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
             onTouchStart: composeEventHandlers(onTouchStart, setIntent)
         },
-        setViewportElement
+        setElement
     ];
 }
 async function loadRouteModule(route, routeAssets, chunkLoader) {
@@ -195,7 +133,8 @@ const PrefetchPageLinks = ({ path, includeData })=>{
     const context = useContext(InternalRuntimeContext);
     const { routeManifest, routes } = context;
     const { routeAssets } = routeManifest || {};
-    const allowNetworkWarmup = shouldWarmupOnCurrentNetwork();
+    const policy = context.linkPrefetchPolicy;
+    const allowNetworkWarmup = policy?.canWarmup() ?? true;
     const matches = useMemo(()=>Array.isArray(routes) ? matchRoutes(routes, pathname) : [], [
         pathname,
         routes
@@ -215,7 +154,16 @@ const PrefetchPageLinks = ({ path, includeData })=>{
             const routeAsset = routeId ? routeAssets[routeId] : void 0;
             const chunkIds = routeAsset?.chunkIds;
             if (!routeId || !Array.isArray(chunkIds) || 0 === chunkIds.length) return ()=>{};
-            return scheduleWarmup(getNavigationWarmupCacheKey(context, chunkLoader, getWebpackPublicPath(), `route-module:${routeId}:${chunkIds.join(',')}`), ()=>loadRouteModule(match.route, routeAssets, chunkLoader));
+            const run = ()=>loadRouteModule(match.route, routeAssets, chunkLoader);
+            if (policy) return policy.schedule({
+                runtimeContext: context,
+                chunkLoader,
+                publicPath: getWebpackPublicPath(),
+                key: `route-module:${routeId}:${chunkIds.join(',')}`,
+                run
+            });
+            run().catch(()=>{});
+            return ()=>{};
         });
         return ()=>{
             cancellations.forEach((cancel)=>cancel());
@@ -224,6 +172,7 @@ const PrefetchPageLinks = ({ path, includeData })=>{
         allowNetworkWarmup,
         chunkLoader,
         context,
+        policy,
         routeAssetGeneration
     ]);
     if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
@@ -235,10 +184,11 @@ const PrefetchPageLinks = ({ path, includeData })=>{
 };
 const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
     const { pathname, search, hash } = path;
+    const policy = useContext(InternalRuntimeContext).linkPrefetchPolicy;
     const currentMatches = useMatches();
     const basename = useHref('/');
     const dataHrefs = useMemo(()=>matches?.filter((match, index)=>{
-            if (!isDataWarmupEnabled(match.route) || !match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
+            if (policy?.allowData(match.route) === false || !match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
             if (match.route.shouldRevalidate) {
                 const currentUrl = new URL(location.pathname + location.search + location.hash, window.origin);
                 const nextUrl = new URL(pathname + search + hash, window.origin);
@@ -265,16 +215,10 @@ const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
         children: dataHrefs
     });
 };
-const normalizePreloadBehavior = (preload, prefetch)=>{
-    if (false === preload || 'none' === preload) return 'none';
-    if (void 0 !== preload) return preload;
-    if ('none' === prefetch) return 'none';
-    return prefetch;
-};
-const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = DEFAULT_PREFETCH_BEHAVIOR, preload, ...props }, forwardedRef)=>{
+const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch, preload, ...props }, forwardedRef)=>{
         const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);
-        const resolvedPreload = normalizePreloadBehavior(preload, prefetch);
-        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, resolvedPreload, props);
+        const policy = useContext(InternalRuntimeContext).linkPrefetchPolicy;
+        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, preload, props, policy);
         const setAnchorRef = react.useCallback((element)=>{
             setViewportElement(element);
             setRef(forwardedRef, element);

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

@@ -6,4 +6,12 @@ const onBeforeCreateRouter = createRouterSyncHook();
 const onAfterCreateRouter = createRouterSyncHook();
 const onBeforeHydrateRouter = createRouterSyncHook();
 const onAfterHydrateRouter = createRouterSyncHook();
-export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter };
+const routerProviderRegistryHooks = {
+    modifyRoutes: modifyRoutes,
+    onBeforeCreateRoutes: onBeforeCreateRoutes,
+    onBeforeCreateRouter: onBeforeCreateRouter,
+    onAfterCreateRouter: onAfterCreateRouter,
+    onBeforeHydrateRouter: onBeforeHydrateRouter,
+    onAfterHydrateRouter: onAfterHydrateRouter
+};
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, routerProviderRegistryHooks };

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

@@ -1,34 +1,3 @@
-import { merge } from "@modern-js/runtime-utils/merge";
-import { modifyRoutes, routerPlugin } from "./plugin.mjs";
-import { createRouterProviderRealm, registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks } from "./provider.mjs";
-registerRouterProvider('react-router', routerPlugin, {
-    isDefault: true
-});
-const createRouterPlugin = (localProviders = [])=>{
-    const providerRealm = createRouterProviderRealm([
-        {
-            name: 'react-router',
-            factory: routerPlugin,
-            isDefault: true
-        },
-        ...localProviders
-    ]);
-    return (userConfig = {})=>({
-            name: '@modern-js/plugin-router',
-            registryHooks: routerProviderRegistryHooks,
-            setup: (api)=>{
-                const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
-                const pluginFactory = resolveRouterProvider(mergedConfig.framework, {
-                    realm: providerRealm
-                });
-                const providerPlugin = pluginFactory(userConfig);
-                reportUnsupportedProviderRegistryHooks(providerPlugin);
-                providerPlugin.setup?.(api);
-            }
-        });
-};
-const internal_routerPlugin = createRouterPlugin();
-const internal = internal_routerPlugin;
+export { routerProviderRegistryHooks } from "./hooks.mjs";
+export { modifyRoutes, routerPlugin as default, routerPlugin } from "./plugin.mjs";
 export { renderRoutes } from "./utils.mjs";
-export default internal;
-export { createRouterPlugin, createRouterProviderRealm, internal_routerPlugin as routerPlugin, modifyRoutes, registerRouterProvider, resolveRouterProvider };

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

@@ -4,9 +4,8 @@ import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFrom
 import { normalizePathname } from "@modern-js/runtime-utils/url";
 import * as __rspack_external_react from "react";
 import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
-import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { Link } from "./PrefetchLink.mjs";
-import { routerProviderRegistryHooks } from "./provider.mjs";
 import { createClientRouterFromPayload } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, deserializeErrors, renderRoutes, urlJoin } from "./utils.mjs";
 let finalRouteConfig = {
@@ -168,11 +167,6 @@ function useRouterCreation(props, options) {
             basename: _basename,
             hydrationData
         });
-        applyRouterRuntimeState(runtimeContext, {
-            framework: 'react-router',
-            basename: _basename,
-            instance: router
-        });
         hooks.onAfterCreateRouter.call({
             ...routerLifecycleContext,
             router,

package/dist/esm/router/runtime/plugin.node.mjs

@@ -8,9 +8,8 @@ import { useContext } from "react";
 import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
 import { setServerPayload } from "../../core/context/serverPayload/index.server.mjs";
 import DeferredDataScripts_node from "./DeferredDataScripts.node.mjs";
-import { applyRouterRuntimeState, createRouterServerSnapshot } from "./lifecycle.mjs";
+import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { Link } from "./PrefetchLink.mjs";
-import { routerProviderRegistryHooks } from "./provider.mjs";
 import { RSCStaticRouter, createServerPayload, handleRSCRedirect, prepareRSCRoutes } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, renderRoutes, urlJoin } from "./utils.mjs";
 function createRemixRequest(request) {
@@ -23,24 +22,6 @@ function createRemixRequest(request) {
         signal: controller.signal
     });
 }
-function createReactRouterServerSnapshot(routerContext, basename) {
-    return 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: routerProviderRegistryHooks,
@@ -107,18 +88,9 @@ const routerPlugin = (userConfig = {})=>({
                     throw errors[0];
                 }
                 context.routerContext = routerContext;
-                const routerServerSnapshot = createReactRouterServerSnapshot(routerContext, _basename);
-                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;

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

@@ -1,7 +1,7 @@
 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-node/cli/code.mjs

@@ -74,7 +74,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-node/cli/ssr/index.mjs

@@ -4,51 +4,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){
@@ -64,41 +19,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, {
@@ -108,12 +41,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, [
@@ -182,4 +113,4 @@ const ssrPlugin = ()=>({
     });
 const cli_ssr = ssrPlugin;
 export default cli_ssr;
-export { shouldUseModuleFederationNodeOutput, ssrPlugin };
+export { ssrPlugin };

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

@@ -1,5 +1,5 @@
 import "node:module";
-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";
@@ -35,7 +35,12 @@ function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
                     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();

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

@@ -42,10 +42,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, RuntimeComponentResolverContext, RuntimeContext, getInitialContext } 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-node/core/context/public.mjs

@@ -1,6 +1,2 @@
 import "node:module";
-import { createContext, useContext } from "react";
-const RuntimeContext = createContext({});
-const ReactRuntimeContext = RuntimeContext;
-const useRuntimeContext = ()=>useContext(RuntimeContext);
-export { ReactRuntimeContext, RuntimeContext, useRuntimeContext };
+export { ReactRuntimeContext, RuntimeContext, useRuntimeContext } from "./runtime.mjs";

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

@@ -1,7 +1,17 @@
 import "node:module";
-import { createContext } from "react";
+import { createContext, useContext } from "react";
 const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
-const InternalRuntimeContext = createContext({});
+function getRuntimeReactContext(kind, create) {
+    const key = Symbol.for(`@modern-js/runtime:react-context:v1:${kind}`);
+    const contexts = globalThis;
+    contexts[key] ??= create();
+    return contexts[key];
+}
+const InternalRuntimeContext = getRuntimeReactContext('internal', ()=>createContext({}));
+const RuntimeContext = getRuntimeReactContext('public', ()=>createContext({}));
+const RuntimeComponentResolverContext = getRuntimeReactContext('component-resolver', ()=>createContext(void 0));
+const ReactRuntimeContext = RuntimeContext;
+const useRuntimeContext = ()=>useContext(RuntimeContext);
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
         request: {
@@ -25,5 +35,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 };