@bleedingdev/modern-js-runtime 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

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

@@ -70,7 +70,6 @@ __webpack_require__.d(__webpack_exports__, {
     NavLink: ()=>NavLink
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const router_namespaceObject = require("@modern-js/runtime-utils/router");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
@@ -90,62 +89,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);
@@ -153,70 +96,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] = external_react_default().useState(false);
-    const [shouldPrefetch, setShouldPrefetch] = external_react_default().useState(false);
-    const [shouldPreload, setShouldPreload] = external_react_default().useState(false);
-    const [viewportElement, setViewportElement] = external_react_default().useState(null);
+function usePrefetchBehavior(prefetch, preload, theirElementProps, policy) {
+    const [maybePrefetch, setMaybePrefetch] = external_react_default().useState(false);
+    const [state, setState] = external_react_default().useState({
+        code: false,
+        data: false
+    });
+    const [element, setElement] = external_react_default().useState(null);
+    const observerRef = external_react_default().useRef(void 0);
     const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
     external_react_default().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
+    ]);
+    external_react_default().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
+            });
         }
     };
-    external_react_default().useEffect(()=>{
-        if (maybeWarmup) {
-            const id = setTimeout(()=>{
-                if ('intent' === prefetch) setShouldPrefetch(true);
-                if ('intent' === preload) setShouldPreload(true);
-            }, INTENT_DELAY);
-            return ()=>{
-                clearTimeout(id);
-            };
-        }
-    }, [
-        maybeWarmup,
-        prefetch,
-        preload
-    ]);
-    external_react_default().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),
@@ -224,7 +162,7 @@ function usePrefetchBehavior(prefetch, preload, theirElementProps) {
             onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
             onTouchStart: composeEventHandlers(onTouchStart, setIntent)
         },
-        setViewportElement
+        setElement
     ];
 }
 async function loadRouteModule(route, routeAssets, chunkLoader) {
@@ -265,7 +203,8 @@ const PrefetchPageLinks = ({ path, includeData })=>{
     const context = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
     const { routeManifest, routes } = context;
     const { routeAssets } = routeManifest || {};
-    const allowNetworkWarmup = shouldWarmupOnCurrentNetwork();
+    const policy = context.linkPrefetchPolicy;
+    const allowNetworkWarmup = policy?.canWarmup() ?? true;
     const matches = (0, external_react_namespaceObject.useMemo)(()=>Array.isArray(routes) ? (0, router_namespaceObject.matchRoutes)(routes, pathname) : [], [
         pathname,
         routes
@@ -285,7 +224,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((0, runtime_extensions_namespaceObject.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());
@@ -294,6 +242,7 @@ const PrefetchPageLinks = ({ path, includeData })=>{
         allowNetworkWarmup,
         chunkLoader,
         context,
+        policy,
         routeAssetGeneration
     ]);
     if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
@@ -305,10 +254,11 @@ const PrefetchPageLinks = ({ path, includeData })=>{
 };
 const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
     const { pathname, search, hash } = path;
+    const policy = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext).linkPrefetchPolicy;
     const currentMatches = (0, router_namespaceObject.useMatches)();
     const basename = (0, router_namespaceObject.useHref)('/');
     const dataHrefs = (0, external_react_namespaceObject.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);
@@ -335,16 +285,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__*/ (external_react_default()).forwardRef(({ to, prefetch = DEFAULT_PREFETCH_BEHAVIOR, preload, ...props }, forwardedRef)=>{
+const createPrefetchLink = (Link)=>/*#__PURE__*/ (external_react_default()).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 = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext).linkPrefetchPolicy;
+        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, preload, props, policy);
         const setAnchorRef = external_react_default().useCallback((element)=>{
             setViewportElement(element);
             setRef(forwardedRef, element);

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

@@ -33,7 +33,8 @@ __webpack_require__.d(__webpack_exports__, {
     onAfterHydrateRouter: ()=>onAfterHydrateRouter,
     onBeforeCreateRouter: ()=>onBeforeCreateRouter,
     onBeforeCreateRoutes: ()=>onBeforeCreateRoutes,
-    onBeforeHydrateRouter: ()=>onBeforeHydrateRouter
+    onBeforeHydrateRouter: ()=>onBeforeHydrateRouter,
+    routerProviderRegistryHooks: ()=>routerProviderRegistryHooks
 });
 const plugin_namespaceObject = require("@modern-js/plugin");
 const createRouterSyncHook = ()=>(0, plugin_namespaceObject.createSyncHook)();
@@ -43,19 +44,29 @@ const onBeforeCreateRouter = createRouterSyncHook();
 const onAfterCreateRouter = createRouterSyncHook();
 const onBeforeHydrateRouter = createRouterSyncHook();
 const onAfterHydrateRouter = createRouterSyncHook();
+const routerProviderRegistryHooks = {
+    modifyRoutes,
+    onBeforeCreateRoutes,
+    onBeforeCreateRouter,
+    onAfterCreateRouter,
+    onBeforeHydrateRouter,
+    onAfterHydrateRouter
+};
 exports.modifyRoutes = __webpack_exports__.modifyRoutes;
 exports.onAfterCreateRouter = __webpack_exports__.onAfterCreateRouter;
 exports.onAfterHydrateRouter = __webpack_exports__.onAfterHydrateRouter;
 exports.onBeforeCreateRouter = __webpack_exports__.onBeforeCreateRouter;
 exports.onBeforeCreateRoutes = __webpack_exports__.onBeforeCreateRoutes;
 exports.onBeforeHydrateRouter = __webpack_exports__.onBeforeHydrateRouter;
+exports.routerProviderRegistryHooks = __webpack_exports__.routerProviderRegistryHooks;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "modifyRoutes",
     "onAfterCreateRouter",
     "onAfterHydrateRouter",
     "onBeforeCreateRouter",
     "onBeforeCreateRoutes",
-    "onBeforeHydrateRouter"
+    "onBeforeHydrateRouter",
+    "routerProviderRegistryHooks"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -39,9 +39,8 @@ 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: []
@@ -203,11 +202,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,

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

@@ -51,9 +51,8 @@ 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)=>{
@@ -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;

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/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";
@@ -34,7 +34,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/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, 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/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 "./runtime.mjs";