@bleedingdev/modern-js-runtime 3.5.0-ultramodern.5 → 3.5.0-ultramodern.75

package/dist/cjs/module-federation/manifest-recovery-runtime-plugin.js

@@ -0,0 +1,140 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const DEFAULT_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY_MS = 100;
+const DEFAULT_TIMEOUT_MS = 1000;
+const MAX_ATTEMPTS = 5;
+const MAX_RETRY_DELAY_MS = 1000;
+const MAX_TIMEOUT_MS = 5000;
+const RETRYABLE_HTTP_STATUSES = new Set([
+    408,
+    425,
+    429,
+    500,
+    502,
+    503,
+    504
+]);
+const NON_RETRYABLE_ERROR_PATTERNS = [
+    /RUNTIME-013/i,
+    /invalid manifest/i,
+    /manifest (?:schema|contract|version|identity)/i,
+    /(?:incompatible|mismatch).*(?:manifest|remote)/i
+];
+const clampInteger = (value, fallback, minimum, maximum)=>{
+    if (void 0 === value || !Number.isFinite(value)) return fallback;
+    return Math.min(maximum, Math.max(minimum, Math.floor(value)));
+};
+const getErrorMessage = (error)=>{
+    if (error instanceof Error) return error.message;
+    return 'string' == typeof error ? error : '';
+};
+const getErrorStatus = (error)=>{
+    if ('object' == typeof error && null !== error && 'status' in error && 'number' == typeof error.status) return error.status;
+};
+const isRetryableError = (error)=>{
+    if (error instanceof SyntaxError) return false;
+    const message = getErrorMessage(error);
+    if (NON_RETRYABLE_ERROR_PATTERNS.some((pattern)=>pattern.test(message))) return false;
+    const status = getErrorStatus(error);
+    if (void 0 !== status) return RETRYABLE_HTTP_STATUSES.has(status);
+    if (error instanceof Error && [
+        'AbortError',
+        'TimeoutError'
+    ].includes(error.name)) return true;
+    return error instanceof TypeError || /(?:fetch failed|network|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN)/i.test(message);
+};
+const isHttpManifestUrl = (id)=>{
+    if (!id) return false;
+    try {
+        const url = new URL(id);
+        return ('http:' === url.protocol || 'https:' === url.protocol) && url.pathname.endsWith('.json');
+    } catch  {
+        return false;
+    }
+};
+const defaultWait = (milliseconds)=>new Promise((resolve)=>{
+        setTimeout(resolve, milliseconds);
+    });
+const fetchWithTimeout = async (fetchImpl, url, timeoutMs)=>{
+    const controller = new AbortController();
+    const timeout = setTimeout(()=>controller.abort(), timeoutMs);
+    try {
+        return await fetchImpl(url, {
+            signal: controller.signal
+        });
+    } finally{
+        clearTimeout(timeout);
+    }
+};
+const createModuleFederationManifestRecoveryPlugin = (options = {})=>{
+    const attempts = clampInteger(options.attempts, DEFAULT_ATTEMPTS, 1, MAX_ATTEMPTS);
+    const retryDelayMs = clampInteger(options.retryDelayMs, DEFAULT_RETRY_DELAY_MS, 0, MAX_RETRY_DELAY_MS);
+    const timeoutMs = clampInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS, 1, MAX_TIMEOUT_MS);
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    const waitImpl = options.waitImpl ?? defaultWait;
+    return {
+        name: 'modern-js-manifest-recovery-plugin',
+        async errorLoadRemote (args) {
+            if ('afterResolve' !== args.lifecycle || !isHttpManifestUrl(args.id) || !isRetryableError(args.error) || 'function' != typeof fetchImpl) return;
+            for(let attempt = 0; attempt < attempts; attempt++){
+                if (attempt > 0 && retryDelayMs > 0) await waitImpl(retryDelayMs);
+                try {
+                    const response = await fetchWithTimeout(fetchImpl, args.id, timeoutMs);
+                    if (!response.ok) {
+                        if (!RETRYABLE_HTTP_STATUSES.has(response.status) || attempt === attempts - 1) return;
+                        continue;
+                    }
+                    try {
+                        return await response.json();
+                    } catch  {
+                        break;
+                    }
+                } catch (error) {
+                    if (!isRetryableError(error) || attempt === attempts - 1) break;
+                }
+            }
+        }
+    };
+};
+const __rspack_default_export = createModuleFederationManifestRecoveryPlugin;
+__webpack_require__.d(__webpack_exports__, {}, {
+    createModuleFederationManifestRecoveryPlugin: createModuleFederationManifestRecoveryPlugin,
+    default: __rspack_default_export
+});
+exports.createModuleFederationManifestRecoveryPlugin = __webpack_exports__.createModuleFederationManifestRecoveryPlugin;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModuleFederationManifestRecoveryPlugin",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation/surface-resolution-types.js

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createDiscoveryError: ()=>universal_namespaceObject.createDiscoveryError,
+    deliveryUnitResolutionKey: ()=>deliveryUnitResolutionKey,
+    formatSurfaceRef: ()=>universal_namespaceObject.formatSurfaceRef,
+    parseSurfaceRef: ()=>universal_namespaceObject.parseSurfaceRef,
+    surfaceResolutionKey: ()=>surfaceResolutionKey,
+    validateSurfaceRef: ()=>universal_namespaceObject.validateSurfaceRef
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+function surfaceResolutionKey(ref, env) {
+    return `${env}::${(0, universal_namespaceObject.formatSurfaceRef)(ref)}`;
+}
+function deliveryUnitResolutionKey(unitId, env) {
+    return `${env}::${unitId}`;
+}
+exports.createDiscoveryError = __webpack_exports__.createDiscoveryError;
+exports.deliveryUnitResolutionKey = __webpack_exports__.deliveryUnitResolutionKey;
+exports.formatSurfaceRef = __webpack_exports__.formatSurfaceRef;
+exports.parseSurfaceRef = __webpack_exports__.parseSurfaceRef;
+exports.surfaceResolutionKey = __webpack_exports__.surfaceResolutionKey;
+exports.validateSurfaceRef = __webpack_exports__.validateSurfaceRef;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDiscoveryError",
+    "deliveryUnitResolutionKey",
+    "formatSurfaceRef",
+    "parseSurfaceRef",
+    "surfaceResolutionKey",
+    "validateSurfaceRef"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/cli/code/nestedRoutes.js

@@ -116,6 +116,7 @@ const walk = async (options)=>{
     let pageLoaderFile = '';
     let pageRoute = null;
     let pageConfigFile = '';
+    let pageSearchFile = '';
     let pageClientData = '';
     let pageData = '';
     let pageAction = '';
@@ -162,12 +163,14 @@ const walk = async (options)=>{
                 if (await (0, external_utils_js_namespaceObject.hasAction)(itemPath)) pageAction = itemPathWithAlias;
             }
             if (itemWithoutExt === external_constants_js_namespaceObject.NESTED_ROUTE.PAGE_CONFIG_FILE) pageConfigFile = itemPathWithAlias;
+            if (itemWithoutExt === external_constants_js_namespaceObject.NESTED_ROUTE.PAGE_SEARCH_FILE) pageSearchFile = itemPathWithAlias;
             if (itemWithoutExt === external_constants_js_namespaceObject.NESTED_ROUTE.PAGE_FILE) {
                 pageRoute = createIndexRoute({
                     _component: itemPathWithAlias
                 }, rootDir, itemPath, entryName, isMainEntry);
                 if (pageLoaderFile) pageRoute.loader = pageLoaderFile;
                 if (pageConfigFile) pageRoute.config = pageConfigFile;
+                if (pageSearchFile) pageRoute.validateSearch = pageSearchFile;
                 if (pageData) pageRoute.data = pageData;
                 if (pageClientData) pageRoute.clientData = pageClientData;
                 if (pageAction) pageRoute.action = pageAction;

package/dist/cjs/router/cli/code/templates.js

@@ -227,7 +227,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,
@@ -330,7 +331,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     ${importLazyCode}
     ${!isRscClientBundle ? importComponentsCode : ''}
     ${importRuntimeRouterCode}
-    ${!isRscClientBundle ? rootLayoutCode : ''}
+    ${rootLayoutCode}
     ${importLoadingCode}
     ${importErrorComponentsCode}
     ${importLoadersCode}

package/dist/cjs/router/cli/constants.js

@@ -47,6 +47,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/cjs/router/cli/nestedRoutesSpec.js

@@ -43,6 +43,7 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const promises_namespaceObject = require("node:timers/promises");
 const utils_namespaceObject = require("@modern-js/utils");
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
 const lockPollIntervalMs = 25;
 const staleLockAgeMs = 120000;
 const pendingUpdates = new Map();
@@ -85,6 +86,7 @@ async function writeJSONAtomically(filePath, value) {
 }
 async function updateNestedRoutesSpec(specPath, nextRoutes) {
     const resolvedSpecPath = external_node_path_default().resolve(specPath);
+    const nextRoutesSnapshot = (0, lodash_namespaceObject.cloneDeep)(nextRoutes);
     const previousUpdate = pendingUpdates.get(resolvedSpecPath) ?? Promise.resolve();
     const currentUpdate = previousUpdate.catch(()=>void 0).then(async ()=>{
         const releaseLock = await acquireSpecLock(resolvedSpecPath);
@@ -92,7 +94,7 @@ async function updateNestedRoutesSpec(specPath, nextRoutes) {
             const existingRoutes = await utils_namespaceObject.fs.pathExists(resolvedSpecPath) ? await utils_namespaceObject.fs.readJSON(resolvedSpecPath) : {};
             await writeJSONAtomically(resolvedSpecPath, {
                 ...existingRoutes,
-                ...nextRoutes
+                ...nextRoutesSnapshot
             });
         } finally{
             await releaseLock();

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

@@ -36,12 +36,13 @@ __webpack_require__.d(__webpack_exports__, {
     onBeforeHydrateRouter: ()=>onBeforeHydrateRouter
 });
 const plugin_namespaceObject = require("@modern-js/plugin");
-const modifyRoutes = (0, plugin_namespaceObject.createSyncHook)();
-const onBeforeCreateRoutes = (0, plugin_namespaceObject.createSyncHook)();
-const onBeforeCreateRouter = (0, plugin_namespaceObject.createSyncHook)();
-const onAfterCreateRouter = (0, plugin_namespaceObject.createSyncHook)();
-const onBeforeHydrateRouter = (0, plugin_namespaceObject.createSyncHook)();
-const onAfterHydrateRouter = (0, plugin_namespaceObject.createSyncHook)();
+const createRouterSyncHook = ()=>(0, plugin_namespaceObject.createSyncHook)();
+const modifyRoutes = createRouterSyncHook();
+const onBeforeCreateRoutes = createRouterSyncHook();
+const onBeforeCreateRouter = createRouterSyncHook();
+const onAfterCreateRouter = createRouterSyncHook();
+const onBeforeHydrateRouter = createRouterSyncHook();
+const onAfterHydrateRouter = createRouterSyncHook();
 exports.modifyRoutes = __webpack_exports__.modifyRoutes;
 exports.onAfterCreateRouter = __webpack_exports__.onAfterCreateRouter;
 exports.onAfterHydrateRouter = __webpack_exports__.onAfterHydrateRouter;

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

@@ -28,6 +28,8 @@ 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,
     modifyRoutes: ()=>external_plugin_js_namespaceObject.modifyRoutes,
     registerRouterProvider: ()=>external_provider_js_namespaceObject.registerRouterProvider,
@@ -42,23 +44,33 @@ const external_utils_js_namespaceObject = require("./utils.js");
 (0, external_provider_js_namespaceObject.registerRouterProvider)('react-router', external_plugin_js_namespaceObject.routerPlugin, {
     isDefault: true
 });
-const routerPlugin = (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, {
-                localDefault: {
-                    name: 'react-router',
-                    factory: external_plugin_js_namespaceObject.routerPlugin
-                }
-            });
-            const providerPlugin = pluginFactory(userConfig);
-            (0, external_provider_js_namespaceObject.reportUnsupportedProviderRegistryHooks)(providerPlugin);
-            providerPlugin.setup?.(api);
-        }
-    });
+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;
@@ -66,6 +78,8 @@ exports.renderRoutes = __webpack_exports__.renderRoutes;
 exports.resolveRouterProvider = __webpack_exports__.resolveRouterProvider;
 exports.routerPlugin = __webpack_exports__.routerPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouterPlugin",
+    "createRouterProviderRealm",
     "default",
     "modifyRoutes",
     "registerRouterProvider",

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

@@ -99,10 +99,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,
@@ -156,16 +156,15 @@ function useRouterCreation(props, options) {
     const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
     const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
     const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
-    const rscPayload = 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, external_react_namespaceObject.useMemo)(()=>{
         if (hydrationData?.errors) hydrationData = {
             ...hydrationData,
             errors: (0, external_utils_js_namespaceObject.deserializeErrors)(hydrationData.errors)
         };
-        const isRscClient = (0, index_js_namespaceObject.getGlobalIsRscClient)();
         let routes = null;
-        routes = isRscClient ? createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
+        routes = process.env.MODERN_ENABLE_RSC && (0, index_js_namespaceObject.getGlobalIsRscClient)() ? createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
             routesConfig: finalRouteConfig
         }) : createRoutes ? createRoutes() : (0, router_namespaceObject.createRoutesFromElements)((0, external_utils_js_namespaceObject.renderRoutes)({
             routesConfig: finalRouteConfig,
@@ -173,7 +172,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 = (0, external_rsc_router_js_namespaceObject.createClientRouterFromPayload)(rscPayload, routes, _basename);
             return {
                 router,

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

@@ -28,6 +28,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    createRouterProviderRealm: ()=>createRouterProviderRealm,
     registerRouterProvider: ()=>registerRouterProvider,
     reportUnsupportedProviderRegistryHooks: ()=>reportUnsupportedProviderRegistryHooks,
     resolveRouterProvider: ()=>resolveRouterProvider,
@@ -48,54 +49,99 @@ 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];
 }
+exports.createRouterProviderRealm = __webpack_exports__.createRouterProviderRealm;
 exports.registerRouterProvider = __webpack_exports__.registerRouterProvider;
 exports.reportUnsupportedProviderRegistryHooks = __webpack_exports__.reportUnsupportedProviderRegistryHooks;
 exports.resolveRouterProvider = __webpack_exports__.resolveRouterProvider;
 exports.routerProviderRegistryHooks = __webpack_exports__.routerProviderRegistryHooks;
 exports.unsafe_resetRouterProvidersForTesting = __webpack_exports__.unsafe_resetRouterProvidersForTesting;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouterProviderRealm",
     "registerRouterProvider",
     "reportUnsupportedProviderRegistryHooks",
     "resolveRouterProvider",

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

@@ -109,9 +109,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();
@@ -139,9 +150,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,