@bleedingdev/modern-js-runtime 3.5.0-ultramodern.99 → 3.8.1-ultramodern.2

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

@@ -91,7 +91,7 @@ async function hasUseClientDirective(componentPath, srcDirectory, internalSrcAli
         await fh?.close();
     }
 }
-const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClientBundle = false, srcDirectory, internalSrcAlias })=>{
+const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClientBundle = false, hydrateRscClientRoutes = false, isolateRouteDataInRscLayer = false, srcDirectory, internalSrcAlias })=>{
     const components = [];
     const loadings = [];
     const errors = [];
@@ -163,7 +163,6 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
                     componentPath: route._component,
                     routeId: route.id
                 });
-                rootLayoutCode = `import RootLayout from '${route._component}'`;
                 component = 'RootLayout';
             } else if (splitRouteChunks) {
                 lazyImport = createLazyImport({
@@ -184,8 +183,9 @@ 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 shouldHydrateRscRoute = isRscClientBundle && !isClientComponent && !route.loader && !route.data;
+        const shouldHydrateRscRoute = hydrateRscClientRoutes && isRscClientBundle && !isClientComponent && ('nested' !== route.type || !route.loader && !route.data);
         const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent || shouldHydrateRscRoute;
+        if ('nested' === route.type && route.isRoot && route._component && shouldIncludeClientBundle) rootLayoutCode = `import RootLayout from '${route._component}'`;
         const finalRoute = {
             ...route,
             loading,
@@ -246,32 +246,30 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     const importComponentsCode = components.map((component, index)=>`import component_${index} from '${component}';\n`).join('');
     const importErrorComponentsCode = errors.map((error, index)=>`import error_${index} from '${error}';\n`).join('');
     let importLoadersCode = '';
-    for (const [key, loaderInfo] of Object.entries(loadersMap))if (loaderInfo.inline) {
+    const isolatedRouteDataDirectory = path.join(internalDirectory, entryName, '__rsc_route_data__');
+    await fs.remove(isolatedRouteDataDirectory);
+    if (isolateRouteDataInRscLayer) await fs.ensureDir(isolatedRouteDataDirectory);
+    for (const [key, loaderInfo] of Object.entries(loadersMap)){
         const { route } = loaderInfo;
-        if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${slash(loaderInfo.filePath)}${getDataLoaderPath({
+        const loaderRequest = `${slash(loaderInfo.filePath)}${getDataLoaderPath({
             loaderId: key,
             clientData: loaderInfo.clientData,
-            action: route.action,
+            action: route.action || false,
             inline: loaderInfo.inline,
             routeId: loaderInfo.routeId,
             inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";\n`;
-        else importLoadersCode += `import { loader as ${key} } from "${slash(loaderInfo.filePath)}${getDataLoaderPath({
-            loaderId: key,
-            clientData: loaderInfo.clientData,
-            action: false,
-            inline: loaderInfo.inline,
-            routeId: route.id,
-            inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";\n`;
-    } else importLoadersCode += `import ${key} from "${slash(loaderInfo.filePath)}${getDataLoaderPath({
-        loaderId: key,
-        clientData: loaderInfo.clientData,
-        action: false,
-        inline: loaderInfo.inline,
-        routeId: loaderInfo.routeId,
-        inValidSSRRoute: loaderInfo.inValidSSRRoute
-    })}";\n`;
+        })}`;
+        let loaderImport = loaderRequest;
+        if (isolateRouteDataInRscLayer) {
+            const isolatedLoaderFile = path.join(isolatedRouteDataDirectory, `${key}.js`);
+            const isolatedLoaderCode = loaderInfo.inline ? route.action ? `export { loader, action } from ${JSON.stringify(loaderRequest)};` : `export { loader } from ${JSON.stringify(loaderRequest)};` : `export { default } from ${JSON.stringify(loaderRequest)};`;
+            await fs.outputFile(isolatedLoaderFile, isolatedLoaderCode, 'utf8');
+            loaderImport = `./__rsc_route_data__/${key}.js`;
+        }
+        if (loaderInfo.inline) if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${loaderImport}";\n`;
+        else importLoadersCode += `import { loader as ${key} } from "${loaderImport}";\n`;
+        else importLoadersCode += `import ${key} from "${loaderImport}";\n`;
+    }
     let importConfigsCode = '';
     for (const [key, configPath] of Object.entries(configsMap))importConfigsCode += `import * as ${key} from "${slash(configPath)}";\n`;
     await fs.ensureFile(loadersMapFile);
@@ -297,7 +295,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     ${routeComponentsCode}
   `;
 };
-function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
+function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext, options = {}) {
     const { entryName, isMainEntry } = entrypoint;
     const { packageName } = appContext;
     const ssr = getEntryOptions(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
@@ -305,6 +303,17 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
     if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
         const serverLoaderRuntime = require.resolve('@modern-js/plugin-data-loader/runtime');
         const serverLoadersFile = './route-server-loaders.js';
+        const includeRouteServerLoaders = false !== options.includeRouteServerLoaders;
+        if (!includeRouteServerLoaders) {
+            if (!config.source.enableAsyncEntry) return `export * from "${slash(serverLoaderRuntime)}"`;
+            return `
+      async function loadModules() {
+        return import("${slash(serverLoaderRuntime)}");
+      }
+
+      export { loadModules };
+      `;
+        }
         const combinedModule = `export * from "${slash(serverLoaderRuntime)}"; export * from "${serverLoadersFile}"`;
         if (!config.source.enableAsyncEntry) return combinedModule;
         return `
@@ -325,7 +334,7 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
     }
     return null;
 }
-const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false, basename })=>{
+const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false, routesImportPath = './routes', basename })=>{
     const imports = [
         `import { setGlobalContext } from '@${metaName}/runtime/context';`
     ];
@@ -356,7 +365,7 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
     const enableRsc = Boolean(rscType);
     if (isClient) return `${imports.join('\n')}
 
-    import { routes } from './routes';
+    import { routes } from '${routesImportPath}';
 
     const entryName = '${entryName}';
     const basename = '${basename || '/'}';
@@ -372,7 +381,7 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
     `;
     return `${imports.join('\n')}
 
-    import { routes } from './routes';
+    import { routes } from '${routesImportPath}';
 
     const entryName = '${entryName}';
     const basename = '${basename || '/'}';

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

@@ -21,7 +21,12 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
     const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code/index.mjs");
     originEntrypointsByKey.set(entrypointsKey, cloneDeep(entrypoints));
     const enableRsc = resolvedConfig?.server?.rsc;
-    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api);
+    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api, {
+        hydrateRscClientRoutes: normalizedOptions.hydrateRscClientRoutes,
+        includeRouteServerLoadersInSsrEntry: normalizedOptions.includeRouteServerLoadersInSsrEntry,
+        isolateRouteDataInRscLayer: normalizedOptions.isolateRouteDataInRscLayer,
+        serverRoutesFileName: normalizedOptions.serverRoutesFileName
+    });
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
             const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);
@@ -44,6 +49,7 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
                 internalSrcAlias: appContext.internalSrcAlias,
                 globalApp: entrypoint.fileSystemRoutes?.globalApp,
                 rscType: 'server',
+                routesImportPath: normalizedOptions.serverRoutesFileName ? `./${normalizedOptions.serverRoutesFileName.replace(/\.js$/, '')}` : void 0,
                 basename
             }));
         }

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

@@ -1,11 +1,12 @@
 import "node:module";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { merge } from "@modern-js/runtime-utils/merge";
-import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFromElements, useHref, useLocation, useMatches } from "@modern-js/runtime-utils/router";
+import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFromElements, useHref, useInRouterContext, useLocation, useMatches, useNavigate, useParams } from "@modern-js/runtime-utils/router";
 import { normalizePathname } from "@modern-js/runtime-utils/url";
 import * as __rspack_external_react from "react";
-import { InternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
+import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
 import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { Link } from "./PrefetchLink.mjs";
 import { routerProviderRegistryHooks } from "./provider.mjs";
 import { createClientRouterFromPayload } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, deserializeErrors, renderRoutes, urlJoin } from "./utils.mjs";
@@ -39,9 +40,13 @@ const routerPlugin = (userConfig = {})=>({
                     }
                 }
                 context.router = {
+                    Link: Link,
                     useMatches: useMatches,
                     useLocation: useLocation,
-                    useHref: useHref
+                    useHref: useHref,
+                    useInRouterContext: useInRouterContext,
+                    useNavigate: useNavigate,
+                    useParams: useParams
                 };
                 Object.defineProperty(context, 'routes', {
                     get () {
@@ -65,7 +70,7 @@ const routerPlugin = (userConfig = {})=>({
                 };
                 let cachedRouter = null;
                 const RouterWrapper = (props)=>{
-                    const routerResult = useRouterCreation(process.env.MODERN_ENABLE_RSC ? {
+                    const routerResult = useRouterCreation(("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) ? {
                         ...props,
                         rscPayload: props?.rscPayload
                     } : props, {
@@ -83,18 +88,18 @@ const routerPlugin = (userConfig = {})=>({
                     const { routes } = routerResult;
                     routesContainer.current = routes;
                     beforeCreateRouter = false;
-                    const RouterContent = ()=>/*#__PURE__*/ jsxs(Fragment, {
-                            children: [
-                                /*#__PURE__*/ jsx(RouterProvider, {
-                                    router: router
-                                }),
-                                /*#__PURE__*/ jsx(EmptyComponent, {}),
-                                /*#__PURE__*/ jsx(EmptyComponent, {})
-                            ]
-                        });
+                    const routerContent = /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(RouterProvider, {
+                                router: router
+                            }),
+                            /*#__PURE__*/ jsx(EmptyComponent, {}),
+                            /*#__PURE__*/ jsx(EmptyComponent, {})
+                        ]
+                    });
                     return App ? /*#__PURE__*/ jsx(App, {
-                        children: /*#__PURE__*/ jsx(RouterContent, {})
-                    }) : /*#__PURE__*/ jsx(RouterContent, {});
+                        children: routerContent
+                    }) : routerContent;
                 };
                 return RouterWrapper;
             });
@@ -122,15 +127,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 = 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;
+    const rscPayload = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && props?.rscPayload ? safeUse(props.rscPayload) : null;
+    let hydrationData = "u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA : true === getGlobalEnableRsc() ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
     return (0, __rspack_external_react.useMemo)(()=>{
         if (hydrationData?.errors) hydrationData = {
             ...hydrationData,
             errors: deserializeErrors(hydrationData.errors)
         };
         let routes = null;
-        routes = process.env.MODERN_ENABLE_RSC && getGlobalIsRscClient() ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
+        routes = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && getGlobalIsRscClient() ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
             routesConfig: finalRouteConfig
         }) : createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
             routesConfig: finalRouteConfig,
@@ -138,7 +143,7 @@ function useRouterCreation(props, options) {
         }));
         if (!routes) routes = [];
         const hooks = api.getHooks();
-        if (process.env.MODERN_ENABLE_RSC && rscPayload) try {
+        if (("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && rscPayload) try {
             const router = createClientRouterFromPayload(rscPayload, routes, _basename);
             return {
                 router,

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

@@ -2,7 +2,7 @@ import "node:module";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { createRequestContext } from "@modern-js/runtime-utils/node";
-import { StaticRouterProvider, createRoutesFromElements, createStaticHandler, createStaticRouter } from "@modern-js/runtime-utils/router";
+import { StaticRouterProvider, createRoutesFromElements, createStaticHandler, createStaticRouter, useInRouterContext, useLocation, useNavigate, useParams } from "@modern-js/runtime-utils/router";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { useContext } from "react";
@@ -10,6 +10,7 @@ import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlob
 import { setServerPayload } from "../../core/context/serverPayload/index.server.mjs";
 import DeferredDataScripts_node from "./DeferredDataScripts.node.mjs";
 import { applyRouterRuntimeState, createRouterServerSnapshot } from "./lifecycle.mjs";
+import { Link } from "./PrefetchLink.mjs";
 import { routerProviderRegistryHooks } from "./provider.mjs";
 import { RSCStaticRouter, createServerPayload, handleRSCRedirect, prepareRSCRoutes } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, renderRoutes, urlJoin } from "./utils.mjs";
@@ -47,6 +48,13 @@ const routerPlugin = (userConfig = {})=>({
         setup: (api)=>{
             let finalRouteConfig = {};
             api.onBeforeRender(async (context, interrupt)=>{
+                context.router = {
+                    Link: Link,
+                    useInRouterContext: useInRouterContext,
+                    useLocation: useLocation,
+                    useNavigate: useNavigate,
+                    useParams: useParams
+                };
                 const pluginConfig = api.getRuntimeConfig();
                 const { basename = '', routesConfig, createRoutes } = merge(pluginConfig.router || {}, userConfig);
                 finalRouteConfig = {
@@ -135,10 +143,8 @@ const routerPlugin = (userConfig = {})=>({
                     const enableRsc = getGlobalEnableRsc();
                     return (props)=>{
                         const context = useContext(InternalRuntimeContext);
-                        const { routerContext, ssrContext, routes } = context;
-                        const { nonce, mode, useJsonScript } = ssrContext;
+                        const { routerContext, routes } = context;
                         const { basename } = routerContext;
-                        const remixRouter = createStaticRouter(routes, routerContext);
                         if (enableRsc) return App ? /*#__PURE__*/ jsx(App, {
                             children: /*#__PURE__*/ jsx(RSCStaticRouter, {
                                 basename: basename
@@ -147,6 +153,8 @@ const routerPlugin = (userConfig = {})=>({
                             basename: basename
                         });
                         {
+                            const { nonce, mode, useJsonScript } = context.ssrContext;
+                            const remixRouter = createStaticRouter(routes, routerContext);
                             const routerWrapper = /*#__PURE__*/ jsxs(Fragment, {
                                 children: [
                                     /*#__PURE__*/ jsx(StaticRouterProvider, {

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

@@ -17,7 +17,7 @@ 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 (0 === registration.name.length) 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);
@@ -27,7 +27,7 @@ function createRouterProviderRealm(registrations) {
         ...providers.keys()
     ]);
     return Object.freeze({
-        ...defaultProvider ? {
+        ...void 0 !== defaultProvider ? {
             defaultProvider
         } : {},
         get: (name)=>providers.get(name),

package/dist/esm-node/router/runtime/redirect.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+const handleRSCRedirect = (headers, basename, status)=>{
+    const newHeaders = new Headers(headers);
+    let redirectUrl = headers.get('Location');
+    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
+    newHeaders.set('X-Modernjs-BaseUrl', basename);
+    newHeaders.delete('Location');
+    return new Response(null, {
+        status,
+        headers: newHeaders
+    });
+};
+export { handleRSCRedirect };

package/dist/esm-node/router/runtime/routerHelper.mjs

@@ -1,5 +1,6 @@
 import "node:module";
 import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
+const isRouteErrorResponse = (error)=>null !== error && 'object' == typeof error && 'number' == typeof error.status && 'string' == typeof error.statusText && 'boolean' == typeof error.internal && 'data' in error;
 const isObjectLike = (value)=>'object' == typeof value && null !== value || 'function' == typeof value;
 const isRouteComponent = (value)=>'function' == typeof value || isObjectLike(value) && '$$typeof' in value;
 const getRouteModules = ()=>{
@@ -52,4 +53,4 @@ const handleRouteModuleError = (error)=>{
     console.error(error);
     return null;
 };
-export { createShouldRevalidate, handleRouteModule, handleRouteModuleError, resolveRouteComponent };
+export { createShouldRevalidate, handleRouteModule, handleRouteModuleError, isRouteErrorResponse, resolveRouteComponent };

package/dist/esm-node/router/runtime/rsc-router.mjs

@@ -86,18 +86,6 @@ const createServerPayload = (routerContext, routes)=>{
         })
     };
 };
-const handleRSCRedirect = (headers, basename, status)=>{
-    const newHeaders = new Headers(headers);
-    let redirectUrl = headers.get('Location');
-    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
-    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
-    newHeaders.set('X-Modernjs-BaseUrl', basename);
-    newHeaders.delete('Location');
-    return new Response(null, {
-        status: status,
-        headers: newHeaders
-    });
-};
 const prepareRSCRoutes = async (routes)=>{
     const isLazyComponent = (component)=>null != component && 'object' == typeof component && '_init' in component && '_payload' in component;
     const processRoutes = async (routesList)=>{
@@ -326,4 +314,5 @@ const RSCStaticRouter = ({ basename })=>{
         children: createRSCStaticRouterComponent(payload, basename)
     });
 };
-export { RSCStaticRouter, createClientRouterFromPayload, createServerPayload, handleRSCRedirect, prepareRSCRoutes };
+export { handleRSCRedirect } from "./redirect.mjs";
+export { RSCStaticRouter, createClientRouterFromPayload, createServerPayload, prepareRSCRoutes };

package/dist/esm-node/router/runtime/utils.mjs

@@ -1,10 +1,11 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
 import { renderNestedRoute } from "@modern-js/runtime-utils/browser";
-import { Route, UNSAFE_ErrorResponseImpl, isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+import { Route, UNSAFE_ErrorResponseImpl } from "@modern-js/runtime-utils/router";
 import react from "react";
 import { DefaultNotFound } from "./DefaultNotFound.mjs";
 import DeferredDataScripts from "./DeferredDataScripts.mjs";
+import { isRouteErrorResponse } from "./routerHelper.mjs";
 function getRouteComponents(routes, { globalApp, ssrMode, props }) {
     const Layout = ({ Component, ...props })=>{
         const GlobalLayout = globalApp;

package/dist/types/core/browser/hydrate.d.ts

@@ -1,6 +1,5 @@
 import type React from 'react';
 import { type Root } from 'react-dom/client';
 import type { TRuntimeContext } from '../context/runtime';
-export declare const isReact18: () => boolean;
 export declare function hydrateWithReact(App: React.ReactElement, rootElement: HTMLElement): Promise<Root>;
 export declare function hydrateRoot(App: React.ReactElement, context: TRuntimeContext, ModernRender: (App: React.ReactElement) => Promise<HTMLElement | Root>, ModernHydrate: (App: React.ReactElement, callback?: () => void) => Promise<HTMLElement | Root>): Promise<HTMLElement | Root>;

package/dist/types/core/server/utils.d.ts

@@ -1,5 +1,5 @@
 import type { ServerUserConfig } from '@modern-js/app-tools';
-import { type StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { StaticHandlerContext } from '@modern-js/runtime-utils/router';
 import type { SSRConfig } from './shared';
 export declare function attributesToString(attributes: Record<string, any>): string;
 /**

package/dist/types/document/cli/index.d.ts

@@ -1,5 +1,6 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import type { Entrypoint } from '@modern-js/types/cli';
+export declare const processScriptPlaceholders: (html: string, nonce?: string) => string;
 export declare const getDocumentByEntryName: (entrypoints: Entrypoint[], entryName: string, fallbackDir?: string) => string | undefined;
 export declare const documentPlugin: () => CliPlugin<AppTools>;
 export default documentPlugin;

package/dist/types/module-federation/distributed-ssr.d.ts

@@ -23,11 +23,11 @@ export type DistributedSsrFragmentContext = {
     required: true;
     resolve?: (remote: string, expose: string, props: Record<string, unknown>) => DistributedSsrFragmentResult | PromiseLike<DistributedSsrFragmentResult>;
 };
-export type DistributedSsrBoundaryProps = {
+export type DistributedSsrBoundaryProps<Props extends object = Record<string, unknown>> = {
     children: ReactNode;
     expose: string;
     fallback: ReactNode;
-    fragmentProps?: Record<string, unknown>;
+    fragmentProps?: Props;
     remote: string;
 };
 export type CreateDistributedSsrComponentOptions<Props extends object> = {
@@ -49,7 +49,7 @@ export declare function useDistributedSsrFragmentProps<Props extends object>({ b
  * Node SSR has no distributed-fragment context and therefore renders the
  * child normally, preserving Module Federation's in-process SSR path.
  */
-export declare function DistributedSsrBoundary({ children, expose, fallback, fragmentProps, remote, }: DistributedSsrBoundaryProps): import("react").JSX.Element;
+export declare function DistributedSsrBoundary<Props extends object = Record<string, unknown>>({ children, expose, fallback, fragmentProps, remote, }: DistributedSsrBoundaryProps<Props>): import("react").JSX.Element;
 /**
  * Defers creation of the native Module Federation component until React
  * actually renders that child. A workerd request with a verified distributed

package/dist/types/module-federation/manifest-recovery-runtime-plugin.d.ts

@@ -20,6 +20,6 @@ export type ModuleFederationManifestRecoveryPluginOptions = {
  */
 export declare const createModuleFederationManifestRecoveryPlugin: (options?: ModuleFederationManifestRecoveryPluginOptions) => {
     name: string;
-    errorLoadRemote(args: ErrorLoadRemoteArgs): Promise<any>;
+    errorLoadRemote(args: ErrorLoadRemoteArgs): Promise<unknown>;
 };
 export default createModuleFederationManifestRecoveryPlugin;

package/dist/types/router/cli/code/index.d.ts

@@ -5,6 +5,11 @@ import type { Entrypoint, NestedRouteForCli, PageRoute } from '@modern-js/types'
  * Generate routing information for a single entry point (can be reused by the routes inspect feature)
  */
 export declare function generateRoutesForEntry(entrypoint: Entrypoint, appContext: AppToolsContext): Promise<NestedRouteForCli[]>;
-export declare const generateCode: (appContext: AppToolsContext, config: AppNormalizedConfig, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools>) => Promise<Record<string, (NestedRouteForCli | PageRoute)[]>>;
+export declare const generateCode: (appContext: AppToolsContext, config: AppNormalizedConfig, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools>, options?: {
+    hydrateRscClientRoutes?: boolean;
+    includeRouteServerLoadersInSsrEntry?: boolean;
+    isolateRouteDataInRscLayer?: boolean;
+    serverRoutesFileName?: string;
+}) => Promise<Record<string, (NestedRouteForCli | PageRoute)[]>>;
 export declare function generatorRegisterCode(internalDirectory: string, entryName: string, code: string): void;
 export declare function generatorServerRegisterCode(internalDirectory: string, entryName: string, code: string): void;

package/dist/types/router/cli/code/templates.d.ts

@@ -3,7 +3,7 @@ import type { Entrypoint, NestedRouteForCli, PageRoute, RouteLegacy, SSRMode } f
 export declare const routesForServer: ({ routesForServerLoaderMatches, }: {
     routesForServerLoaderMatches: (NestedRouteForCli | PageRoute)[];
 }) => string;
-export declare const fileSystemRoutes: ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks, isRscClientBundle, srcDirectory, internalSrcAlias, }: {
+export declare const fileSystemRoutes: ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks, isRscClientBundle, hydrateRscClientRoutes, isolateRouteDataInRscLayer, srcDirectory, internalSrcAlias, }: {
     metaName: string;
     routes: RouteLegacy[] | (NestedRouteForCli | PageRoute)[];
     ssrMode?: SSRMode;
@@ -12,11 +12,15 @@ export declare const fileSystemRoutes: ({ metaName, routes, ssrMode, nestedRoute
     internalDirectory: string;
     splitRouteChunks?: boolean;
     isRscClientBundle?: boolean;
+    hydrateRscClientRoutes?: boolean;
+    isolateRouteDataInRscLayer?: boolean;
     srcDirectory?: string;
     internalSrcAlias?: string;
 }) => Promise<string>;
-export declare function ssrLoaderCombinedModule(entrypoints: Entrypoint[], entrypoint: Entrypoint, config: AppNormalizedConfig, appContext: AppToolsContext): string | null;
-export declare const runtimeGlobalContext: ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType, basename, }: {
+export declare function ssrLoaderCombinedModule(entrypoints: Entrypoint[], entrypoint: Entrypoint, config: AppNormalizedConfig, appContext: AppToolsContext, options?: {
+    includeRouteServerLoaders?: boolean;
+}): string | null;
+export declare const runtimeGlobalContext: ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType, routesImportPath, basename, }: {
     entryName: string;
     metaName: string;
     srcDirectory: string;
@@ -24,5 +28,6 @@ export declare const runtimeGlobalContext: ({ entryName, metaName, srcDirectory,
     internalSrcAlias: string;
     globalApp?: string | false;
     rscType?: 'server' | 'client' | false;
+    routesImportPath?: string;
     basename?: string;
 }) => Promise<string>;

package/dist/types/router/cli/handler.d.ts

@@ -10,6 +10,10 @@ type RegenerateRoutesFn = (params: {
 }) => Promise<void>;
 type HandleGeneratorEntryCodeOptions = {
     entrypointsKey?: string;
+    hydrateRscClientRoutes?: boolean;
+    includeRouteServerLoadersInSsrEntry?: boolean;
+    isolateRouteDataInRscLayer?: boolean;
+    serverRoutesFileName?: string;
 };
 type HandleFileChangeOptions = {
     includeEntry?: (entrypoint: Entrypoint) => boolean;

package/dist/types/router/runtime/redirect.d.ts

@@ -0,0 +1 @@
+export declare const handleRSCRedirect: (headers: Headers, basename: string, status: number) => Response;

package/dist/types/router/runtime/routerHelper.d.ts

@@ -1,5 +1,12 @@
 import type { ShouldRevalidateFunction } from '@modern-js/runtime-utils/router';
 import type { ElementType } from 'react';
+export type ModernRouteErrorResponse = {
+    status: number;
+    statusText: string;
+    internal: boolean;
+    data: unknown;
+};
+export declare const isRouteErrorResponse: (error: unknown) => error is ModernRouteErrorResponse;
 export declare const createShouldRevalidate: (routeId: string) => ShouldRevalidateFunction;
 export declare const resolveRouteComponent: (routeModule: unknown) => ElementType<Record<string, unknown>>;
 export declare const handleRouteModule: (routeModule: unknown, routeId: string) => unknown;

package/dist/types/router/runtime/rsc-router.d.ts

@@ -2,6 +2,7 @@ import { type RouteObject, type StaticHandlerContext } from '@modern-js/runtime-
 import React from 'react';
 import type { ServerPayload } from '../../core/context';
 import type { RouteManifest } from './types';
+export { handleRSCRedirect } from './redirect';
 declare global {
     interface Window {
         _MODERNJS_ROUTE_MANIFEST?: RouteManifest;
@@ -9,7 +10,6 @@ declare global {
     }
 }
 export declare const createServerPayload: (routerContext: StaticHandlerContext, routes: RouteObject[]) => ServerPayload;
-export declare const handleRSCRedirect: (headers: Headers, basename: string, status: number) => Response;
 export declare const prepareRSCRoutes: (routes: RouteObject[]) => Promise<void>;
 export declare const createClientRouterFromPayload: (payload: ServerPayload, originalRoutes: RouteObject[], basename?: string) => import("react-router").DataRouter;
 interface RSCStaticRouterProps {
@@ -17,4 +17,3 @@ interface RSCStaticRouterProps {
     useJsonScript?: boolean;
 }
 export declare const RSCStaticRouter: React.FC<RSCStaticRouterProps>;
-export {};

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.99",
+  "version": "3.8.1-ultramodern.2",
   "engines": {
     "node": ">=20"
   },
@@ -246,12 +246,12 @@
   "dependencies": {
     "@loadable/component": "5.16.7",
     "@loadable/server": "5.16.7",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.99",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.5.0-ultramodern.99",
-    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.5.0-ultramodern.99",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.99",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.99",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.99",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.8.1-ultramodern.2",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.8.1-ultramodern.2",
+    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.8.1-ultramodern.2",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.8.1-ultramodern.2",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.8.1-ultramodern.2",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.8.1-ultramodern.2",
     "@swc/core": "1.15.43",
     "@swc/helpers": "^0.5.23",
     "@swc/plugin-loadable-components": "^11.15.0",
@@ -265,14 +265,14 @@
     "isbot": "5.2.0",
     "react-helmet": "^6.1.0",
     "react-helmet-async": "3.0.0",
-    "react-is": "^19.2.7"
+    "react-is": "^19.2.8"
   },
   "peerDependencies": {
-    "react": "^19.2.7",
-    "react-dom": "^19.2.7"
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8"
   },
   "devDependencies": {
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.99",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.8.1-ultramodern.2",
     "@remix-run/web-fetch": "^4.4.2",
     "@rsbuild/core": "2.1.5",
     "@rslib/core": "0.23.2",
@@ -282,10 +282,10 @@
     "@types/cookie": "0.6.0",
     "@types/invariant": "^2.2.37",
     "@types/loadable__server": "5.12.11",
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.2.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "react": "^19.2.7",
-    "react-dom": "^19.2.7",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
     "ts-node": "^10.9.2",
     "typescript": "^7.0.2"
   },

package/rstest.config.mts

@@ -24,6 +24,7 @@ export default {
       testEnvironment: 'node',
       exclude: [
         'tests/boundary-debugger/client.test.tsx',
+        'tests/router/plugin.client.test.tsx',
         'tests/router/prefetch.test.tsx',
       ],
       extends: commonConfig,
@@ -51,6 +52,7 @@ export default {
       testEnvironment: 'happy-dom',
       include: [
         'tests/boundary-debugger/client.test.tsx',
+        'tests/router/plugin.client.test.tsx',
         'tests/router/prefetch.test.tsx',
       ],
       extends: commonConfig,