@bleedingdev/modern-js-runtime 3.5.0-ultramodern.1 → 3.5.0-ultramodern.100

package/dist/esm/router/cli/code/templates.mjs

@@ -182,7 +182,8 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
             component = `component_${components.length - 1}`;
         }
         const isClientComponent = 'nested' === route.type && Boolean(route._component) && Boolean(srcDirectory) && Boolean(internalSrcAlias) && await hasUseClientDirective(route._component, srcDirectory, internalSrcAlias);
-        const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent;
+        const shouldHydrateRscRoute = isRscClientBundle && !isClientComponent && !route.loader && !route.data;
+        const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent || shouldHydrateRscRoute;
         const finalRoute = {
             ...route,
             loading,
@@ -285,7 +286,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     ${importLazyCode}
     ${!isRscClientBundle ? importComponentsCode : ''}
     ${importRuntimeRouterCode}
-    ${!isRscClientBundle ? rootLayoutCode : ''}
+    ${rootLayoutCode}
     ${importLoadingCode}
     ${importErrorComponentsCode}
     ${importLoadersCode}

package/dist/esm/router/cli/constants.mjs

@@ -18,6 +18,7 @@ const NESTED_ROUTE = {
     PAGE_FILE: 'page',
     PAGE_CONFIG_FILE: 'page.config',
     PAGE_LOADER_FILE: 'page.loader',
+    PAGE_SEARCH_FILE: 'page.search',
     PAGE_DATA_FILE: 'page.data',
     PAGE_CLIENT_LOADER: 'page.data.client',
     SPLATE_FILE: '$',

package/dist/esm/router/cli/handler.mjs

@@ -3,7 +3,7 @@ import { cloneDeep } from "@modern-js/utils/lodash";
 import path from "path";
 import { isPageComponentFile } from "./code/utils.mjs";
 import { modifyEntrypoints } from "./entry.mjs";
-import * as __rspack_external__code_templates_mjs_5e908598 from "./code/templates.mjs";
+import * as __rspack_external__code_templates_mjs_f6c22489 from "./code/templates.mjs";
 const DEFAULT_ENTRYPOINTS_KEY = '__default_router_entries__';
 const originEntrypointsByKey = new Map();
 async function handleModifyEntrypoints(entrypoints, routesDir, options = {}) {
@@ -25,7 +25,7 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
         if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
             const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);
             const basename = route?.urlPath || '/';
-            generatorRegisterCode(internalDirectory, entrypoint.entryName, await __rspack_external__code_templates_mjs_5e908598.runtimeGlobalContext({
+            generatorRegisterCode(internalDirectory, entrypoint.entryName, await __rspack_external__code_templates_mjs_f6c22489.runtimeGlobalContext({
                 entryName: entrypoint.entryName,
                 metaName: appContext.metaName,
                 srcDirectory: appContext.srcDirectory,
@@ -35,7 +35,7 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
                 rscType: enableRsc ? 'client' : void 0,
                 basename
             }));
-            if (enableRsc) generatorServerRegisterCode(internalDirectory, entrypoint.entryName, await __rspack_external__code_templates_mjs_5e908598.runtimeGlobalContext({
+            if (enableRsc) generatorServerRegisterCode(internalDirectory, entrypoint.entryName, await __rspack_external__code_templates_mjs_f6c22489.runtimeGlobalContext({
                 entryName: entrypoint.entryName,
                 metaName: appContext.metaName,
                 srcDirectory: appContext.srcDirectory,

package/dist/esm/router/cli/nestedRoutesSpec.mjs

@@ -1,6 +1,7 @@
 import node_path from "node:path";
 import { setTimeout as promises_setTimeout } from "node:timers/promises";
 import { fs } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
 const lockPollIntervalMs = 25;
 const staleLockAgeMs = 120000;
 const pendingUpdates = new Map();
@@ -43,6 +44,7 @@ async function writeJSONAtomically(filePath, value) {
 }
 async function updateNestedRoutesSpec(specPath, nextRoutes) {
     const resolvedSpecPath = node_path.resolve(specPath);
+    const nextRoutesSnapshot = cloneDeep(nextRoutes);
     const previousUpdate = pendingUpdates.get(resolvedSpecPath) ?? Promise.resolve();
     const currentUpdate = previousUpdate.catch(()=>void 0).then(async ()=>{
         const releaseLock = await acquireSpecLock(resolvedSpecPath);
@@ -50,7 +52,7 @@ async function updateNestedRoutesSpec(specPath, nextRoutes) {
             const existingRoutes = await fs.pathExists(resolvedSpecPath) ? await fs.readJSON(resolvedSpecPath) : {};
             await writeJSONAtomically(resolvedSpecPath, {
                 ...existingRoutes,
-                ...nextRoutes
+                ...nextRoutesSnapshot
             });
         } finally{
             await releaseLock();

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

@@ -1,8 +1,9 @@
 import { createSyncHook } from "@modern-js/plugin";
-const modifyRoutes = createSyncHook();
-const onBeforeCreateRoutes = createSyncHook();
-const onBeforeCreateRouter = createSyncHook();
-const onAfterCreateRouter = createSyncHook();
-const onBeforeHydrateRouter = createSyncHook();
-const onAfterHydrateRouter = createSyncHook();
+const createRouterSyncHook = ()=>createSyncHook();
+const modifyRoutes = createRouterSyncHook();
+const onBeforeCreateRoutes = createRouterSyncHook();
+const onBeforeCreateRouter = createRouterSyncHook();
+const onAfterCreateRouter = createRouterSyncHook();
+const onBeforeHydrateRouter = createRouterSyncHook();
+const onAfterHydrateRouter = createRouterSyncHook();
 export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter };

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

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

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

@@ -64,10 +64,10 @@ const routerPlugin = (userConfig = {})=>({
                 };
                 let cachedRouter = null;
                 const RouterWrapper = (props)=>{
-                    const routerResult = useRouterCreation({
+                    const routerResult = useRouterCreation(process.env.MODERN_ENABLE_RSC ? {
                         ...props,
                         rscPayload: props?.rscPayload
-                    }, {
+                    } : props, {
                         api: api,
                         createRoutes,
                         supportHtml5History,
@@ -121,16 +121,15 @@ function useRouterCreation(props, options) {
     const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
     const _basename = '/' === baseUrl ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
     const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
-    const rscPayload = props?.rscPayload ? safeUse(props.rscPayload) : null;
-    let hydrationData = window._ROUTER_DATA || rscPayload;
+    const rscPayload = process.env.MODERN_ENABLE_RSC && props?.rscPayload ? safeUse(props.rscPayload) : null;
+    let hydrationData = process.env.MODERN_ENABLE_RSC ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
     return (0, __rspack_external_react.useMemo)(()=>{
         if (hydrationData?.errors) hydrationData = {
             ...hydrationData,
             errors: deserializeErrors(hydrationData.errors)
         };
-        const isRscClient = getGlobalIsRscClient();
         let routes = null;
-        routes = isRscClient ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
+        routes = process.env.MODERN_ENABLE_RSC && getGlobalIsRscClient() ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
             routesConfig: finalRouteConfig
         }) : createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
             routesConfig: finalRouteConfig,
@@ -138,7 +137,7 @@ function useRouterCreation(props, options) {
         }));
         if (!routes) routes = [];
         const hooks = api.getHooks();
-        if (rscPayload) try {
+        if (process.env.MODERN_ENABLE_RSC && rscPayload) try {
             const router = createClientRouterFromPayload(rscPayload, routes, _basename);
             return {
                 router,

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

@@ -12,46 +12,89 @@ function reportUnsupportedProviderRegistryHooks(providerPlugin) {
     if (unsupportedHookNames.length > 0) console.warn(`[@modern-js/runtime] The router provider "${providerPlugin.name}" declares registry hooks outside the router hook contract: ${unsupportedHookNames.join(', ')}. These hooks are not registered when the provider is resolved through \`runtime.router.framework\` — declare them on a separate runtime plugin instead.`);
     return unsupportedHookNames;
 }
-const REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v2');
+function createRouterProviderRealm(registrations) {
+    const providers = new Map();
+    let defaultProvider;
+    for (const registration of registrations){
+        if (!registration.name) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
+        if (providers.has(registration.name)) throw new Error(`[@modern-js/runtime] Router provider "${registration.name}" is declared more than once in the same runtime realm.`);
+        if (true === registration.isDefault && void 0 !== defaultProvider && defaultProvider !== registration.name) throw new Error(`[@modern-js/runtime] Router provider realm declares both "${defaultProvider}" and "${registration.name}" as defaults.`);
+        providers.set(registration.name, registration.factory);
+        if (true === registration.isDefault) defaultProvider = registration.name;
+    }
+    const providerNames = Object.freeze([
+        ...providers.keys()
+    ]);
+    return Object.freeze({
+        ...defaultProvider ? {
+            defaultProvider
+        } : {},
+        get: (name)=>providers.get(name),
+        names: ()=>providerNames
+    });
+}
+const REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v3');
+const LEGACY_V2_REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v2');
 function getRegistry() {
     const host = globalThis;
     host[REGISTRY_SLOT] ??= {
         providers: new Map(),
+        duplicateProviders: new Set(),
         warnedDuplicates: new Set()
     };
+    host[REGISTRY_SLOT].duplicateProviders ??= new Set();
     host[REGISTRY_SLOT].warnedDuplicates ??= new Set();
     return host[REGISTRY_SLOT];
 }
+function getLegacyV2Registry() {
+    const host = globalThis;
+    return host[LEGACY_V2_REGISTRY_SLOT];
+}
 function registerRouterProvider(name, factory, options = {}) {
     const registry = getRegistry();
     const existing = registry.providers.get(name);
     if (void 0 !== existing) {
-        if (existing !== factory && !registry.warnedDuplicates.has(name)) {
-            registry.warnedDuplicates.add(name);
-            console.warn(`[@modern-js/runtime] The router provider "${name}" was registered more than once with different module instances; keeping the first registration. This usually means two copies of the providing plugin were bundled — for Module Federation, add the provider runtime (e.g. '@modern-js/plugin-tanstack/runtime') to the shared modules of both the host and the remote to deduplicate it.`);
-        }
+        if (existing !== factory) registry.duplicateProviders.add(name);
         return;
     }
-    if (true !== options.isDefault) {
-        if (void 0 !== registry.nonDefaultProvider && registry.nonDefaultProvider !== name) throw new Error(`[@modern-js/runtime] Cannot register router provider "${name}": the competing router provider "${registry.nonDefaultProvider}" is already registered. Only one non-default router provider may be installed at a time — remove one of the router plugins.`);
-        registry.nonDefaultProvider = name;
-    } else registry.defaultProvider = name;
+    if (true === options.isDefault) registry.defaultProvider = name;
     registry.providers.set(name, factory);
 }
 function resolveRouterProvider(framework, options = {}) {
+    if (void 0 !== options.realm) {
+        const name = framework || options.realm.defaultProvider;
+        const realmProviderNames = options.realm.names();
+        if (void 0 === name) throw new Error(`[@modern-js/runtime] The app-owned router provider realm does not declare a default provider. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}.`);
+        const factory = options.realm.get(name);
+        if (void 0 === factory) throw new Error(`[@modern-js/runtime] Router provider "${name}" is not registered in the app-owned router provider realm. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}. Compatibility registry fallback is disabled for app-owned realms.`);
+        return factory;
+    }
     const registry = getRegistry();
-    const name = framework || registry.defaultProvider || options.localDefault?.name;
+    const legacyV2Registry = getLegacyV2Registry();
+    const name = framework || options.localDefault?.name || registry.defaultProvider || legacyV2Registry?.defaultProvider;
     if (void 0 === name) throw new Error('[@modern-js/runtime] No default router provider is registered. This is a bug in the runtime setup.');
     if (void 0 !== options.localDefault && name === options.localDefault.name) return options.localDefault.factory;
     const factory = registry.providers.get(name);
-    if (void 0 !== factory) return factory;
+    if (void 0 !== factory) {
+        if (registry.duplicateProviders.has(name) && !registry.warnedDuplicates.has(name)) {
+            registry.warnedDuplicates.add(name);
+            console.warn(`[@modern-js/runtime] The router provider "${name}" was registered more than once with different module instances, and a router wrapper without an app-owned provider realm is resolving the mixed-version compatibility fallback. The fallback is keeping the first registration. Modern router wrappers isolate app-owned realms automatically. For an older wrapper, share the provider runtime between Module Federation host and remotes or upgrade every app to a realm-aware runtime.`);
+        }
+        return factory;
+    }
+    const legacyV2Factory = legacyV2Registry?.providers.get(name);
+    if (void 0 !== legacyV2Factory) return legacyV2Factory;
     if ('tanstack' === name) throw new Error("[@modern-js/runtime] `runtime.router.framework` is set to \"tanstack\", but no TanStack router provider is registered. Install @modern-js/plugin-tanstack, add `tanstackRouterPlugin()` to the `plugins` array in modern.config.ts, and make sure '@modern-js/plugin-tanstack/runtime' is imported (e.g. in modern.runtime.ts).");
     throw new Error(`[@modern-js/runtime] Unknown router framework "${name}". Registered providers: ${[
-        ...registry.providers.keys()
+        ...new Set([
+            ...registry.providers.keys(),
+            ...legacyV2Registry?.providers.keys() ?? []
+        ])
     ].join(', ') || '(none)'}. Install and register the plugin that provides this router framework.`);
 }
 function unsafe_resetRouterProvidersForTesting() {
     const host = globalThis;
     delete host[REGISTRY_SLOT];
+    delete host[LEGACY_V2_REGISTRY_SLOT];
 }
-export { registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks, unsafe_resetRouterProvidersForTesting };
+export { createRouterProviderRealm, registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks, unsafe_resetRouterProvidersForTesting };

package/dist/esm-node/boundary-debugger/index.mjs

@@ -110,9 +110,20 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
     ]);
     useEffect(()=>{
         if (!enabled) return void setBoxes([]);
+        let resizeObserver;
+        const observedElements = new Set();
+        const observeBoundaryElements = (elements)=>{
+            if (void 0 === resizeObserver) return;
+            for (const element of elements)if (!observedElements.has(element)) {
+                observedElements.add(element);
+                resizeObserver.observe(element);
+            }
+        };
         const readBoxes = ()=>{
+            const elements = collectBoundaryElements(legacySelector);
+            observeBoundaryElements(elements);
             const seenBoxes = new Set();
-            const nextBoxes = collectBoundaryElements(legacySelector).map((element)=>{
+            const nextBoxes = elements.map((element)=>{
                 const boundaryId = getBoundaryId(element);
                 if (void 0 === boundaryId || '' === boundaryId) return;
                 const rect = element.getBoundingClientRect();
@@ -140,9 +151,8 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
             }).filter((box)=>void 0 !== box);
             setBoxes(nextBoxes);
         };
+        resizeObserver = "u" < typeof ResizeObserver ? void 0 : new ResizeObserver(readBoxes);
         readBoxes();
-        const resizeObserver = "u" < typeof ResizeObserver ? void 0 : new ResizeObserver(readBoxes);
-        for (const element of collectBoundaryElements(legacySelector))resizeObserver?.observe(element);
         const mutationObserver = new MutationObserver(readBoxes);
         mutationObserver.observe(document.body, {
             childList: true,

package/dist/esm-node/cli/code.mjs

@@ -3,8 +3,8 @@ import { formatImportPath, fs } from "@modern-js/utils";
 import path from "path";
 import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_POINT_REGISTER_FILE_NAME, ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME, ENTRY_SERVER_BOOTSTRAP_FILE_NAME, INDEX_FILE_NAME, SERVER_ENTRY_POINT_FILE_NAME } from "./constants.mjs";
 import { resolveSSRMode } from "./ssr/mode.mjs";
-import * as __rspack_external__template_mjs_d6ab8956 from "./template.mjs";
-import * as __rspack_external__template_server_mjs_38d6edb1 from "./template.server.mjs";
+import * as __rspack_external__template_mjs_d1604447 from "./template.mjs";
+import * as __rspack_external__template_server_mjs_f98cfe58 from "./template.server.mjs";
 const normalizePreEntry = (preEntry)=>{
     if (!preEntry) return [];
     if (Array.isArray(preEntry)) return preEntry.filter((v)=>'string' == typeof v && v.length > 0);
@@ -36,7 +36,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 nestedRoutesEntry
             });
             let indexCode = '';
-            indexCode = ssrMode || !config.server.rsc || customEntry ? __rspack_external__template_mjs_d6ab8956.index({
+            indexCode = ssrMode || !config.server.rsc || customEntry ? __rspack_external__template_mjs_d1604447.index({
                 srcDirectory,
                 internalSrcAlias,
                 metaName,
@@ -46,7 +46,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 mountId,
                 enableRsc: config.server.rsc,
                 isNestedRouter: !!entrypoint.nestedRoutesEntry
-            }) : __rspack_external__template_mjs_d6ab8956.entryForCSRWithRSC({
+            }) : __rspack_external__template_mjs_d1604447.entryForCSRWithRSC({
                 metaName,
                 entryName,
                 mountId,
@@ -77,7 +77,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 if (ssrMode) await fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler)`, 'utf8');
             }
             if (ssrMode) {
-                const indexServerCode = __rspack_external__template_server_mjs_38d6edb1.serverIndex({
+                const indexServerCode = __rspack_external__template_server_mjs_f98cfe58.serverIndex({
                     entry,
                     entryName,
                     internalSrcAlias,
@@ -91,16 +91,16 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
             } else if (config.server.rsc) {
                 const indexServerFile = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
-                const indexServerCode = __rspack_external__template_server_mjs_38d6edb1.entryForCSRWithRSC({
+                const indexServerCode = __rspack_external__template_server_mjs_f98cfe58.entryForCSRWithRSC({
                     entryName,
                     metaName
                 });
                 await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
             }
-            const registerCode = __rspack_external__template_mjs_d6ab8956.register();
+            const registerCode = __rspack_external__template_mjs_d1604447.register();
             const registerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_REGISTER_FILE_NAME}`);
             await fs.outputFile(registerFile, registerCode, 'utf8');
-            const registerRuntimeCode = __rspack_external__template_mjs_d6ab8956.runtimeRegister({
+            const registerRuntimeCode = __rspack_external__template_mjs_d1604447.runtimeRegister({
                 entryName,
                 srcDirectory,
                 internalSrcAlias,
@@ -114,7 +114,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
             if (!config.server.rsc || entrypoint.nestedRoutesEntry) {
                 const route = serverRoutes.find((r)=>r.entryName === entryName);
                 const basename = route?.urlPath || '/';
-                contextCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContext({
+                contextCode = __rspack_external__template_mjs_d1604447.runtimeGlobalContext({
                     entryName,
                     srcDirectory,
                     internalSrcAlias,
@@ -125,18 +125,18 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 });
             } else {
                 const AppProxyPath = path.join(internalDirectory, entryName, './AppProxy.jsx');
-                const appProxyCode = __rspack_external__template_mjs_d6ab8956.AppProxyForRSC({
+                const appProxyCode = __rspack_external__template_mjs_d1604447.AppProxyForRSC({
                     srcDirectory,
                     internalSrcAlias,
                     entry,
                     customEntry
                 });
                 await fs.outputFile(AppProxyPath, appProxyCode);
-                contextCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContextForRSCClient({
+                contextCode = __rspack_external__template_mjs_d1604447.runtimeGlobalContextForRSCClient({
                     metaName,
                     customEntry
                 });
-                const contextServerCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContextForRSCServer({
+                const contextServerCode = __rspack_external__template_mjs_d1604447.runtimeGlobalContextForRSCServer({
                     metaName
                 });
                 const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`);

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

@@ -1,6 +1,6 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { cleanRequireCache, isReact18 as utils_isReact18 } from "@modern-js/utils";
+import { cleanRequireCache } from "@modern-js/utils";
 import path_0 from "path";
 import { documentPlugin } from "../document/cli/index.mjs";
 import { getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, routerPlugin, updateNestedRoutesSpec } from "../router/cli/index.mjs";
@@ -56,12 +56,10 @@ const runtimePlugin = (params)=>({
             });
             api.config(()=>{
                 const { appDirectory, metaName } = api.getAppContext();
-                const isReact18 = utils_isReact18(appDirectory);
-                process.env.IS_REACT18 = isReact18.toString();
                 return {
                     source: {
                         globalVars: {
-                            'process.env.IS_REACT18': process.env.IS_REACT18
+                            'process.env.IS_REACT18': 'true'
                         },
                         include: [
                             new RegExp(`[\\\\/]node_modules[\\\\/]@${metaName}[\\\\/]runtime[\\\\/].*[\\\\/]head\\.`)
@@ -70,14 +68,6 @@ const runtimePlugin = (params)=>({
                     tools: {
                         bundlerChain: (chain)=>{
                             chain.module.rule('modern-entry').test(/\.jsx?$/).include.add(path_0.resolve(appDirectory, 'node_modules', `.${metaName}`)).end().sideEffects(true);
-                        },
-                        rspack: (_config, { appendPlugins, rspack })=>{
-                            if (!isReact18) appendPlugins([
-                                new rspack.IgnorePlugin({
-                                    resourceRegExp: /^react-dom\/client$/,
-                                    contextRegExp: /@modern-js\/runtime/
-                                })
-                            ]);
                         }
                     }
                 };

package/dist/esm-node/cli/registry.mjs

@@ -0,0 +1 @@
+import "node:module";

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

@@ -86,14 +86,13 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                 const hasServerRendering = hasServerRenderingConfig(userConfig);
                 const hasModuleFederationRuntimeMarker = hasServerRendering && shouldUseModuleFederationNodeOutput(config);
                 const hasExplicitMfSsrFlag = isModuleFederationAppSSREnabled(userConfig);
-                const isCloudflareWorkerSSR = 'workerSSR' === name && userConfig.deploy?.target === 'cloudflare';
                 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 && !isCloudflareWorkerSSR;
+                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag;
                 const ssrEnv = userConfig.deploy?.worker?.ssr || userConfig.server?.rsc ? 'edge' : 'node';
                 const appContext = modernAPI.getAppContext();
                 const { appDirectory, entrypoints } = appContext;
@@ -107,6 +106,8 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                         define: {
                             'process.env.MODERN_TARGET': isServerEnvironment ? JSON.stringify('node') : JSON.stringify('browser'),
                             '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)),
                             'process.env.MODERN_MF_APP_SSR': JSON.stringify(isModuleFederationAppSSR)
                         }
                     },

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

@@ -2,6 +2,7 @@ import "node:module";
 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 normalizeChunkGroup = (group)=>({
         ...group,
         chunks: (group.chunks || []).map(normalizeChunkId)
@@ -9,7 +10,11 @@ const normalizeChunkGroup = (group)=>({
 class LoadablePlugin {
     apply(compiler) {
         this.compiler = compiler;
-        compiler.options.output.chunkLoadingGlobal = this.opts.chunkLoadingGlobal;
+        const chunkLoadingGlobal = this.opts.chunkLoadingGlobal ?? compiler.options.output.chunkLoadingGlobal ?? DEFAULT_CHUNK_LOADING_GLOBAL;
+        compiler.options.output.chunkLoadingGlobal = chunkLoadingGlobal;
+        new compiler.webpack.DefinePlugin({
+            'process.env.MODERN_CHUNK_LOADING_GLOBAL': JSON.stringify(chunkLoadingGlobal)
+        }).apply(compiler);
         if (this.opts.outputAsset || this.opts.writeToDisk) compiler.hooks.make.tap(LoadablePlugin.name, (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: LoadablePlugin.name,
@@ -69,10 +74,9 @@ class LoadablePlugin {
         const outputFile = path_0.resolve(outputFolder || '', this.opts.filename);
         fs.outputFileSync(outputFile, manifest);
     }
-    constructor({ filename = 'loadable-stats.json', path, writeToDisk, outputAsset = true, chunkLoadingGlobal = '__LOADABLE_LOADED_CHUNKS__' } = {
+    constructor({ filename = 'loadable-stats.json', path, writeToDisk, outputAsset = true, chunkLoadingGlobal } = {
         filename: 'loadable-stats.json',
-        outputAsset: true,
-        chunkLoadingGlobal: '__LOADABLE_LOADED_CHUNKS__'
+        outputAsset: true
     }){
         this.opts = {
             filename,

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

@@ -1,11 +1,22 @@
 import "node:module";
 import { jsx } 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";
 import { RenderLevel } from "../constants.mjs";
 import { wrapRuntimeContextProvider } from "../react/wrapper.mjs";
 import { WithCallback } from "./withCallback.mjs";
 const isReact18 = ()=>'true' === process.env.IS_REACT18;
-function hydrateRoot(App, context, ModernRender, ModernHydrate) {
+const runtimeProcess = Reflect.get(globalThis, 'process');
+const loadableReadyOptions = {
+    chunkLoadingGlobal: runtimeProcess?.env?.MODERN_CHUNK_LOADING_GLOBAL || '__LOADABLE_LOADED_CHUNKS__'
+};
+async function hydrateWithReact(App, rootElement) {
+    return hydrateRoot(rootElement, App, {
+        identifierPrefix: SSR_HYDRATION_ID_PREFIX
+    });
+}
+function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
     const hydrateContext = {
         ...context,
         get routes () {
@@ -41,14 +52,14 @@ function hydrateRoot(App, context, ModernRender, ModernHydrate) {
                 ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext)).then((root)=>{
                     resolve(root);
                 });
-            }) : loadableReady(()=>{
+            }, loadableReadyOptions) : loadableReady(()=>{
                 ModernHydrate(wrapRuntimeContextProvider(App, hydrateContext), callback).then((root)=>{
                     resolve(root);
                 });
-            });
+            }, loadableReadyOptions);
         });
         console.warn(`unknow render level: ${renderLevel}, execute render()`);
         return ModernRender(wrapRuntimeContextProvider(App, context));
     }
 }
-export { hydrateRoot, isReact18 };
+export { hydrateWithReact, hydrate_hydrateRoot as hydrateRoot, isReact18 };

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

@@ -1,10 +1,10 @@
 import "node:module";
-import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 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 } from "./hydrate.mjs";
+import { hydrateRoot, hydrateWithReact } from "./hydrate.mjs";
 const IS_REACT18 = 'true' === process.env.IS_REACT18;
 const getQuery = ()=>window.location.search.substring(1).split('&').reduce((res, item)=>{
         const [key, value] = item.split('=');
@@ -48,10 +48,9 @@ function getSSRData() {
 function isClientArgs(id) {
     return void 0 === id || 'string' == typeof id || "u" > typeof HTMLElement && id instanceof HTMLElement;
 }
-async function render(App, id) {
+async function renderApp(App, id, hydrateFromSsrData, internalRuntimeContext) {
     const context = getInitialContext();
     const runBeforeRender = async (context)=>{
-        const internalRuntimeContext = getGlobalInternalRuntimeContext();
         const api = internalRuntimeContext.pluginAPI;
         api.updateRuntimeContext(context);
         const hooks = internalRuntimeContext.hooks;
@@ -71,17 +70,23 @@ async function render(App, id) {
             return renderFunc(App, rootElement);
         }
         async function ModernHydrate(App, callback) {
-            const hydrateFunc = IS_REACT18 ? hydrateWithReact18 : hydrateWithReact17;
-            return hydrateFunc(App, rootElement, callback);
+            if (IS_REACT18) return hydrateWithReact(App, rootElement);
+            return hydrateWithReact17(App, rootElement, callback);
         }
-        if (window._SSR_DATA) return hydrateRoot(App, context, ModernRender, ModernHydrate);
+        if (hydrateFromSsrData && process.env.MODERN_ENABLE_HYDRATION && window._SSR_DATA) return hydrateRoot(App, context, ModernRender, ModernHydrate);
         return ModernRender(wrapRuntimeContextProvider(App, context));
     }
     throw Error('`render` function needs id in browser environment, it needs to be string or element');
 }
+async function render(App, id) {
+    return renderApp(App, id, true, getGlobalInternalRuntimeContext());
+}
+function createNestedAppRenderer() {
+    const internalRuntimeContext = getGlobalInternalRuntimeContext();
+    return (App, id)=>renderApp(App, id, false, internalRuntimeContext);
+}
 async function renderWithReact18(App, rootElement) {
-    const ReactDOM = await import("react-dom/client");
-    const root = ReactDOM.createRoot(rootElement);
+    const root = createRoot(rootElement);
     root.render(App);
     return root;
 }
@@ -90,16 +95,9 @@ async function renderWithReact17(App, rootElement) {
     ReactDOM.render(App, rootElement);
     return rootElement;
 }
-async function hydrateWithReact18(App, rootElement) {
-    const ReactDOM = await import("react-dom/client");
-    const root = ReactDOM.hydrateRoot(rootElement, App, {
-        identifierPrefix: SSR_HYDRATION_ID_PREFIX
-    });
-    return root;
-}
 async function hydrateWithReact17(App, rootElement, callback) {
     const ReactDOM = await import("react-dom");
     const root = ReactDOM.hydrate(App, rootElement, callback);
     return root;
 }
-export { hydrateWithReact17, hydrateWithReact18, render, renderWithReact17, renderWithReact18 };
+export { createNestedAppRenderer, hydrateWithReact, hydrateWithReact17, render, renderWithReact17, renderWithReact18 };