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

package/dist/esm-node/module-federation/distributed-ssr.mjs

@@ -0,0 +1,82 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { useRuntimeContext } from "../core/context/runtime.mjs";
+const DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY = '__modernDistributedSsrFragments';
+const DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY = '__modernDistributedSsrFragmentRequest';
+function distributedSsrFragmentKey(remote, expose) {
+    return `${remote}::${expose}`;
+}
+function getDistributedSsrFragmentContext(response) {
+    const locals = response?.locals;
+    if (!locals || 'object' != typeof locals) return;
+    const context = locals[DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY];
+    if (!context || 'object' != typeof context) return;
+    return context;
+}
+function useDistributedSsrFragmentProps({ boundaryId, expose }) {
+    const runtimeContext = useRuntimeContext();
+    const locals = runtimeContext.requestContext?.response?.locals;
+    const request = locals && 'object' == typeof locals ? locals[DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY] : void 0;
+    if (!request || 'object' != typeof request || request.boundaryId !== boundaryId || request.expose !== expose) throw new Error(`Distributed SSR fragment request contract mismatch for ${boundaryId} ${expose}.`);
+    const props = request.props;
+    if (!props || 'object' != typeof props || Array.isArray(props)) throw new Error(`Distributed SSR fragment request props must be an object for ${boundaryId} ${expose}.`);
+    return props;
+}
+function isThenable(value) {
+    return 'function' == typeof value.then;
+}
+function DistributedSsrBoundary({ children, expose, fallback, fragmentProps = {}, remote }) {
+    const runtimeContext = useRuntimeContext();
+    const key = distributedSsrFragmentKey(remote, expose);
+    const attributes = {
+        'data-modern-distributed-ssr-boundary': key
+    };
+    if (runtimeContext.isBrowser) return /*#__PURE__*/ jsx("div", {
+        ...attributes,
+        children: children
+    });
+    const fragmentContext = getDistributedSsrFragmentContext(runtimeContext.requestContext?.response);
+    if (!fragmentContext) return /*#__PURE__*/ jsx("div", {
+        ...attributes,
+        children: children
+    });
+    const fragmentOrPromise = fragmentContext.resolve?.(remote, expose, fragmentProps) ?? fragmentContext.fragments?.[key];
+    if (fragmentOrPromise && isThenable(fragmentOrPromise)) throw fragmentOrPromise;
+    const fragment = fragmentOrPromise;
+    if (fragment?.status === 'ready') return /*#__PURE__*/ jsx("div", {
+        ...attributes,
+        "data-modern-distributed-ssr-build": fragment.buildMarker,
+        "data-modern-distributed-ssr-digest": fragment.digest,
+        "data-modern-distributed-ssr-status": "ready",
+        dangerouslySetInnerHTML: {
+            __html: fragment.html
+        }
+    });
+    return /*#__PURE__*/ jsx("div", {
+        ...attributes,
+        "data-modern-distributed-ssr-reason": fragment?.reason ?? 'missing',
+        "data-modern-distributed-ssr-status": "degraded",
+        children: fallback
+    });
+}
+function createDistributedSsrComponent({ createComponent, expose, fallback, remote }) {
+    let RemoteComponent;
+    function DeferredRemoteComponent(props) {
+        RemoteComponent ??= createComponent();
+        return /*#__PURE__*/ jsx(RemoteComponent, {
+            ...props
+        });
+    }
+    return function(props) {
+        return /*#__PURE__*/ jsx(DistributedSsrBoundary, {
+            expose: expose,
+            fallback: fallback,
+            fragmentProps: props,
+            remote: remote,
+            children: /*#__PURE__*/ jsx(DeferredRemoteComponent, {
+                ...props
+            })
+        });
+    };
+}
+export { DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY, DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, DistributedSsrBoundary, createDistributedSsrComponent, distributedSsrFragmentKey, useDistributedSsrFragmentProps };

package/dist/esm-node/module-federation/index.mjs

@@ -1,4 +1,9 @@
 import "node:module";
+export * from "./consume-surface.mjs";
+export * from "./distributed-ssr.mjs";
+export * from "./last-known-good.mjs";
+export * from "./manifest-recovery-runtime-plugin.mjs";
+export * from "./surface-resolution-types.mjs";
 const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
 const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
 const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
@@ -107,4 +112,5 @@ async function emitModuleFederationFallbackTelemetry(input, options = {}) {
         postStatus: response.status
     };
 }
+export { DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, useDistributedSsrFragmentProps } from "./distributed-ssr.mjs";
 export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT, MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT, ModuleFederationRemoteComponentContractError, ModuleFederationRemoteLoadError, ModuleFederationRemoteLoadTimeoutError, classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry, toModuleFederationFallbackAttributes };

package/dist/esm-node/module-federation/last-known-good.mjs

@@ -0,0 +1,81 @@
+import "node:module";
+import { createDiscoveryError, deliveryUnitResolutionKey } from "./surface-resolution-types.mjs";
+const LAST_KNOWN_GOOD_PROVIDER_NAME = 'last-known-good';
+function createInMemoryLkgStorage() {
+    const map = new Map();
+    return {
+        read (key) {
+            return map.get(key);
+        },
+        write (key, record) {
+            map.set(key, record);
+        }
+    };
+}
+function markDegraded(resolved, reason) {
+    return {
+        ...resolved,
+        compatibility: {
+            ...resolved.compatibility,
+            status: 'degraded',
+            reason
+        }
+    };
+}
+function staleRecordResult(ref, env, ageMs, maxStaleMs) {
+    return {
+        ok: false,
+        error: createDiscoveryError('stale-record', ref, `Last-known-good record for surface is stale: age ${ageMs}ms exceeds maxStaleMs ${maxStaleMs}ms`, {
+            env,
+            ageMs,
+            maxStaleMs
+        })
+    };
+}
+function createLastKnownGoodProvider(options) {
+    const storage = options.storage ?? createInMemoryLkgStorage();
+    const now = options.now ?? (()=>Date.now());
+    const maxStaleMs = options.freshness?.maxStaleMs;
+    async function serveFromCache(ref, env, fallback) {
+        const key = deliveryUnitResolutionKey(ref.unitId, env);
+        const cached = await storage.read(key);
+        if (!cached) return fallback();
+        if (cached.major !== ref.major) return fallback();
+        if ('incompatible' === cached.resolved.compatibility.status) return fallback();
+        const ageMs = now() - cached.storedAt;
+        if (void 0 !== maxStaleMs && ageMs > maxStaleMs) return staleRecordResult(ref, env, ageMs, maxStaleMs);
+        return {
+            ok: true,
+            unit: markDegraded(cached.resolved, `served last-known-good record (age ${ageMs}ms) after provider failure`)
+        };
+    }
+    return {
+        name: LAST_KNOWN_GOOD_PROVIDER_NAME,
+        async resolve (ref, env) {
+            const key = deliveryUnitResolutionKey(ref.unitId, env);
+            let resolution;
+            try {
+                resolution = await options.provider.resolve(ref, env);
+            } catch (error) {
+                return serveFromCache(ref, env, ()=>({
+                        ok: false,
+                        error: createDiscoveryError('provider-unavailable', ref, error instanceof Error ? error.message : 'provider threw a non-error value', {
+                            env,
+                            provider: options.provider.name
+                        })
+                    }));
+            }
+            if (!resolution.ok) {
+                const failure = resolution;
+                return serveFromCache(ref, env, ()=>failure);
+            }
+            if ('incompatible' !== resolution.unit.compatibility.status) await storage.write(key, {
+                resolved: resolution.unit,
+                storedAt: now(),
+                major: ref.major
+            });
+            return resolution;
+        }
+    };
+}
+export { LAST_KNOWN_GOOD_PROVIDER_NAME, createInMemoryLkgStorage, createLastKnownGoodProvider };

package/dist/esm-node/module-federation/manifest-recovery-runtime-plugin.mjs

@@ -0,0 +1,101 @@
+import "node:module";
+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 manifest_recovery_runtime_plugin = createModuleFederationManifestRecoveryPlugin;
+export default manifest_recovery_runtime_plugin;
+export { createModuleFederationManifestRecoveryPlugin };

package/dist/esm-node/module-federation/surface-resolution-types.mjs

@@ -0,0 +1,9 @@
+import "node:module";
+import { createDiscoveryError, formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "@modern-js/utils/universal";
+function surfaceResolutionKey(ref, env) {
+    return `${env}::${formatSurfaceRef(ref)}`;
+}
+function deliveryUnitResolutionKey(unitId, env) {
+    return `${env}::${unitId}`;
+}
+export { createDiscoveryError, deliveryUnitResolutionKey, formatSurfaceRef, parseSurfaceRef, surfaceResolutionKey, validateSurfaceRef };

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

@@ -7,7 +7,7 @@ import { resolveSSRMode } from "../../../cli/ssr/mode.mjs";
 import { FILE_SYSTEM_ROUTES_FILE_NAME } from "../constants.mjs";
 import { walk } from "./nestedRoutes.mjs";
 import { getServerCombinedModuleFile, getServerLoadersFile } from "./utils.mjs";
-import * as __rspack_external__templates_mjs_4da4c6c8 from "./templates.mjs";
+import * as __rspack_external__templates_mjs_ab577925 from "./templates.mjs";
 async function generateRoutesForEntry(entrypoint, appContext) {
     const routes = [];
     if (entrypoint.nestedRoutesEntry) {
@@ -90,7 +90,7 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                 }
                 const { code } = await hooks.onBeforeGenerateRoutes.call({
                     entrypoint,
-                    code: await __rspack_external__templates_mjs_4da4c6c8.fileSystemRoutes({
+                    code: await __rspack_external__templates_mjs_ab577925.fileSystemRoutes({
                         metaName,
                         routes: routes,
                         ssrMode: isUseRsc(config) ? 'stream' : ssrMode,
@@ -107,12 +107,12 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                     const routesServerFile = getServerLoadersFile(internalDirectory, entryName);
                     const filtedRoutesForServer = filterRoutesForServer(routes);
                     const routesForServerLoaderMatches = filterRoutesLoader(routes);
-                    const code = __rspack_external__templates_mjs_4da4c6c8.routesForServer({
+                    const code = __rspack_external__templates_mjs_ab577925.routesForServer({
                         routesForServerLoaderMatches
                     });
                     await fs.ensureFile(routesServerFile);
                     await fs.writeFile(routesServerFile, code);
-                    const serverRoutesCode = await __rspack_external__templates_mjs_4da4c6c8.fileSystemRoutes({
+                    const serverRoutesCode = await __rspack_external__templates_mjs_ab577925.fileSystemRoutes({
                         metaName,
                         routes: filtedRoutesForServer,
                         ssrMode,
@@ -126,7 +126,7 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                     });
                     await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, 'utf8');
                 }
-                const serverLoaderCombined = __rspack_external__templates_mjs_4da4c6c8.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
+                const serverLoaderCombined = __rspack_external__templates_mjs_ab577925.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
                 if (serverLoaderCombined) {
                     const serverLoaderFile = getServerCombinedModuleFile(internalDirectory, entryName);
                     await fs.outputFile(serverLoaderFile, serverLoaderCombined);

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

@@ -83,6 +83,7 @@ const walk = async (options)=>{
     let pageLoaderFile = '';
     let pageRoute = null;
     let pageConfigFile = '';
+    let pageSearchFile = '';
     let pageClientData = '';
     let pageData = '';
     let pageAction = '';
@@ -129,12 +130,14 @@ const walk = async (options)=>{
                 if (await hasAction(itemPath)) pageAction = itemPathWithAlias;
             }
             if (itemWithoutExt === NESTED_ROUTE.PAGE_CONFIG_FILE) pageConfigFile = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_SEARCH_FILE) pageSearchFile = itemPathWithAlias;
             if (itemWithoutExt === 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/esm-node/router/cli/code/templates.mjs

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

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

@@ -19,6 +19,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-node/router/cli/handler.mjs

@@ -4,7 +4,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 = {}) {
@@ -26,7 +26,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,
@@ -36,7 +36,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-node/router/cli/nestedRoutesSpec.mjs

@@ -2,6 +2,7 @@ import "node:module";
 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();
@@ -44,6 +45,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);
@@ -51,7 +53,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-node/router/runtime/hooks.mjs

@@ -1,9 +1,10 @@
 import "node:module";
 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-node/router/runtime/internal.mjs

@@ -1,27 +1,35 @@
 import "node:module";
 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-node/router/runtime/plugin.mjs

@@ -65,10 +65,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,
@@ -122,16 +122,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,
@@ -139,7 +138,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,