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

package/dist/esm/core/server/string/loadable.mjs

@@ -1,6 +1,6 @@
 import { ChunkExtractor } from "@loadable/server";
 import { createFederatedCssLinks } from "../federatedCss.mjs";
-import { getMatchedRouteAssets, orderHydrationScriptChunks } from "../scriptOrder.mjs";
+import { getMatchedRouteChunks, orderHydrationScriptChunks } from "../scriptOrder.mjs";
 import { attributesToString, checkIsNode, hasStylesheetLink } from "../utils.mjs";
 const extname = (uri)=>{
     if ('string' != typeof uri || !uri.includes('.')) return '';
@@ -28,11 +28,6 @@ const readAsset = async (chunk)=>{
     return fs.readFile(filepath, 'utf-8');
 };
 class LoadableCollector {
-    getMatchedRouteChunks() {
-        const { routeManifest, runtimeContext } = this.options;
-        if (!routeManifest) return [];
-        return getMatchedRouteAssets(runtimeContext, routeManifest).map(routeAssetToChunk);
-    }
     collect(comopnent) {
         const { stats, entryName } = this.options;
         if (!stats) return comopnent;
@@ -54,7 +49,7 @@ class LoadableCollector {
             ]));
         } catch (e) {}
         const collectedChunks = extractor ? extractor.getChunkAssets(extractor.chunks) : [];
-        const matchedRouteChunks = this.getMatchedRouteChunks();
+        const matchedRouteChunks = getMatchedRouteChunks(options.runtimeContext, options.routeManifest, routeAssetToChunk);
         const orderedScriptChunks = orderHydrationScriptChunks({
             asyncEntryChunks: asyncChunks,
             collectedChunks,
@@ -132,4 +127,4 @@ class LoadableCollector {
         this.options = options;
     }
 }
-export { LoadableCollector, orderHydrationScriptChunks };
+export { LoadableCollector };

package/dist/esm/exports/loadable.mjs

@@ -1,4 +1,4 @@
-import * as __rspack_external__loadable_component_0aaae075 from "@loadable/component";
+import * as __rspack_external__loadable_component_ee3b4254 from "@loadable/component";
 export * from "@loadable/component";
 function asLoadableNamespace(value) {
     return 'object' == typeof value && null !== value ? value : {};
@@ -15,8 +15,8 @@ function resolveLoadable(module) {
     if ('function' != typeof loadable) throw new TypeError('Modern.js runtime loadable export must resolve to a function');
     return loadable;
 }
-const loadable_loadable = resolveLoadable(__rspack_external__loadable_component_0aaae075);
-const loadableNamespace = asLoadableNamespace(__rspack_external__loadable_component_0aaae075);
+const loadable_loadable = resolveLoadable(__rspack_external__loadable_component_ee3b4254);
+const loadableNamespace = asLoadableNamespace(__rspack_external__loadable_component_ee3b4254);
 const loadableDefaultNamespace = asLoadableNamespace(loadableNamespace.default);
 const callableLoadableNamespace = asLoadableNamespace(loadable_loadable);
 const lazy = loadableNamespace.lazy ?? loadableDefaultNamespace.lazy ?? callableLoadableNamespace.lazy;

package/dist/esm/index.mjs

@@ -1,5 +1,6 @@
 export { isBrowser } from "./common.mjs";
-export { RuntimeContext, defineRuntimeConfig, useRuntimeContext } from "./core/index.mjs";
+export { defineRuntimeConfig } from "./core/config.mjs";
 export { getMonitors } from "./core/context/monitors/index.mjs";
+export { RuntimeContext, useRuntimeContext } from "./core/context/public.mjs";
 export { getRequest } from "./core/context/request/index.mjs";
 export { redirect, setHeaders, setStatus } from "./core/context/response/index.mjs";

package/dist/esm/module-federation/consume-surface.mjs

@@ -0,0 +1,158 @@
+import { classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry } from "./index.mjs";
+import { createDiscoveryError, formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "./surface-resolution-types.mjs";
+function classifyDiscoveryError(code) {
+    switch(code){
+        case 'major-not-published':
+        case 'stale-record':
+            return 'version-skew';
+        case 'identity-mismatch':
+            return 'contract';
+        case 'unknown-unit':
+        case 'unknown-surface':
+        case 'provider-unavailable':
+            return 'remote-unavailable';
+        default:
+            return 'remote-unavailable';
+    }
+}
+function toRemoteString(ref) {
+    return void 0 === validateSurfaceRef(ref) ? formatSurfaceRef(ref) : `${ref.unitId}#${ref.surfaceId}`;
+}
+async function reportFailure(options, ref, base) {
+    const remote = toRemoteString(ref);
+    const telemetry = createModuleFederationFallbackTelemetry({
+        appName: options.appName,
+        classification: base.classification,
+        error: base.error ?? base.discoveryError,
+        metadata: {
+            env: options.env,
+            surfaceRef: remote,
+            ...base.discoveryError ? {
+                discoveryErrorCode: base.discoveryError.code
+            } : {},
+            ...base.resolved ? {
+                buildMarker: base.resolved.buildMarker
+            } : {}
+        },
+        phase: base.phase,
+        remote,
+        status: 'degraded'
+    });
+    try {
+        await emitModuleFederationFallbackTelemetry({
+            appName: options.appName,
+            classification: base.classification,
+            error: base.error ?? base.discoveryError,
+            metadata: telemetry.metadata,
+            phase: base.phase,
+            remote,
+            status: 'degraded'
+        }, options.telemetry ?? {});
+    } catch  {}
+    const failure = {
+        ref,
+        env: options.env,
+        phase: base.phase,
+        classification: base.classification,
+        telemetry
+    };
+    if (base.discoveryError) failure.discoveryError = base.discoveryError;
+    if (void 0 !== base.error) failure.error = base.error;
+    if (base.resolved) failure.resolved = base.resolved;
+    const critical = (options.classification ?? 'critical') === 'critical';
+    const reason = base.discoveryError ?? (void 0 !== base.error ? base.error : createDiscoveryError('identity-mismatch', remote, `resolved record for "${remote}" is incompatible`, {
+        env: options.env
+    }));
+    let degradedValue;
+    try {
+        degradedValue = await options.degraded(failure);
+    } catch (handlerError) {
+        try {
+            await emitModuleFederationFallbackTelemetry({
+                appName: options.appName,
+                classification: base.classification,
+                error: handlerError,
+                metadata: {
+                    ...telemetry.metadata,
+                    degradedHandlerFailed: true
+                },
+                phase: base.phase,
+                remote,
+                status: 'failed'
+            }, options.telemetry ?? {});
+        } catch  {}
+        if (critical) throw reason;
+        return;
+    }
+    if (critical) throw reason;
+    return degradedValue;
+}
+async function consumeSurface(options) {
+    let ref;
+    if ('string' == typeof options.ref) {
+        const parsed = parseSurfaceRef(options.ref);
+        if (!parsed.ok) {
+            const hashIndex = options.ref.indexOf('#');
+            const echoed = -1 === hashIndex ? {
+                unitId: options.ref,
+                surfaceId: ''
+            } : {
+                unitId: options.ref.slice(0, hashIndex),
+                surfaceId: options.ref.slice(hashIndex + 1)
+            };
+            return reportFailure(options, echoed, {
+                phase: 'discovery',
+                classification: 'remote-unavailable',
+                discoveryError: createDiscoveryError('unknown-surface', options.ref, `SurfaceRef "${options.ref}" is not a valid canonical reference (${parsed.error.code}).`, {
+                    parseError: parsed.error,
+                    env: options.env
+                })
+            });
+        }
+        ref = parsed.ref;
+    } else ref = options.ref;
+    let resolution;
+    try {
+        resolution = await options.provider.resolve(ref, options.env);
+    } catch (error) {
+        return reportFailure(options, ref, {
+            phase: 'discovery',
+            classification: classifyModuleFederationFallback(error),
+            error
+        });
+    }
+    if (!resolution.ok) return reportFailure(options, ref, {
+        phase: 'discovery',
+        classification: classifyDiscoveryError(resolution.error.code),
+        discoveryError: resolution.error
+    });
+    const resolved = resolution.unit;
+    if ('incompatible' === resolved.compatibility.status) return reportFailure(options, ref, {
+        phase: 'discovery',
+        classification: 'contract',
+        resolved
+    });
+    try {
+        return await options.load({
+            resolved,
+            ref,
+            env: options.env
+        });
+    } catch (error) {
+        return reportFailure(options, ref, {
+            phase: 'load',
+            classification: classifyModuleFederationFallback(error),
+            error,
+            resolved
+        });
+    }
+}
+function createSurfaceConsumer(base) {
+    return function(options) {
+        return consumeSurface({
+            ...base,
+            ...options
+        });
+    };
+}
+export { consumeSurface, createSurfaceConsumer };

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

@@ -0,0 +1,81 @@
+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/module-federation/index.mjs

@@ -1,3 +1,8 @@
+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';
@@ -106,4 +111,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/module-federation/last-known-good.mjs

@@ -0,0 +1,80 @@
+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/module-federation/manifest-recovery-runtime-plugin.mjs

@@ -0,0 +1,100 @@
+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/module-federation/surface-resolution-types.mjs

@@ -0,0 +1,8 @@
+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/router/cli/code/index.mjs

@@ -6,7 +6,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) {
@@ -89,7 +89,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,
@@ -106,12 +106,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,
@@ -125,7 +125,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/router/cli/code/nestedRoutes.mjs

@@ -82,6 +82,7 @@ const walk = async (options)=>{
     let pageLoaderFile = '';
     let pageRoute = null;
     let pageConfigFile = '';
+    let pageSearchFile = '';
     let pageClientData = '';
     let pageData = '';
     let pageAction = '';
@@ -128,12 +129,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/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();