@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

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

@@ -1,5 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { InternalRuntimeContext, getGlobalEnableRsc } from "@modern-js/runtime/context";
+import { createRouterStatePlugin } from "@modern-js/runtime-extensions/router-state-plugin";
 import { createRequestContext } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
@@ -8,13 +9,14 @@ import { useContext } from "react";
 import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
 import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
-import { applyRouterServerPrepareResult, createRouterServerSnapshot, getRouterRuntimeState } from "./lifecycle.mjs";
+import { applyRouterRuntimeState, applyRouterServerPrepareResult, getRouterRuntimeState, getRouterServerSnapshot } from "./lifecycle.mjs";
+import { createTanstackNavigation } from "./navigation.mjs";
 import { createTanstackRouteObjects, getTanstackRouteConfig, joinBasename } from "./pluginShared.mjs";
 import { Link } from "./prefetchLink.mjs";
 import { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./routeTree/index.mjs";
 import { createTanstackRscServerPayload, handleTanstackRscRedirect } from "./rsc/payloadRouter.mjs";
 import { getTanstackRscRouter, setTanstackRscRouter, setTanstackRscServerPayload } from "./rsc/payloadStorage.mjs";
-import { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization } from "./ssrManagedTags.mjs";
+import { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml } from "./ssrManagedTags.mjs";
 import { preloadMatchedRouteComponents } from "./ssrPreload.mjs";
 import { getModernTanstackRouterFastDefaults } from "./types.mjs";
 const tanstackRouterPlugin = (userConfig = {})=>{
@@ -22,6 +24,9 @@ const tanstackRouterPlugin = (userConfig = {})=>{
         name: '@modern-js/plugin-router-tanstack',
         registryHooks: routerProviderRegistryHooks,
         setup: (api)=>{
+            createRouterStatePlugin({
+                registryHooks: routerProviderRegistryHooks
+            }).setup(api);
             api.onBeforeRender(async (context, interrupt)=>{
                 const routeConfig = getTanstackRouteConfig(api, userConfig);
                 const { mergedConfig } = routeConfig;
@@ -87,76 +92,96 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 });
                 const serverRouter = tanstackRouter;
                 if (enableRsc) setTanstackRscRouter(serverRouter);
-                await attachServerSsrUtils(serverRouter);
-                const end = time();
-                try {
-                    await tanstackRouter.load({
-                        sync: true
-                    });
-                } finally{
-                    const cost = end();
-                    context.ssrContext?.onTiming?.(LOADER_REPORTER_NAME, cost);
-                }
-                const serverLoadResult = serverRouter._serverResult;
-                if (!serverLoadResult) {
-                    try {
-                        serverRouter.serverSsr?.cleanup?.();
-                    } catch  {}
-                    throw new Error('TanStack Router completed an SSR load without a server result.');
-                }
-                if ('redirect' === serverLoadResult.type) {
-                    const { redirect } = serverLoadResult;
-                    try {
-                        serverRouter.serverSsr?.cleanup?.();
-                    } catch  {}
-                    return interrupt(isRSCNavigation ? handleTanstackRscRedirect(redirect.headers, _basename, redirect.status) : redirect);
-                }
-                const routerErrors = collectRouterErrors(tanstackRouter);
-                if (routerErrors && 'clientRender' === loaderFailureMode) {
-                    context.ssrContext?.response?.status(200);
-                    try {
-                        serverRouter.serverSsr?.cleanup?.();
-                    } catch  {}
-                    throw Object.values(routerErrors)[0];
-                }
-                await preloadMatchedRouteComponents(serverRouter);
-                context.ssrContext?.response?.status(serverLoadResult.status);
-                await serverRouter.serverSsr?.dehydrate?.();
-                if (enableRsc) {
-                    if (isRSCNavigation) await waitForRouterSerialization(serverRouter);
-                    setTanstackRscServerPayload(createTanstackRscServerPayload(serverRouter, {
-                        omitClientLoaderData: isRSCNavigation
-                    }));
-                }
-                const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
-                const hydrationScripts = routerManagedTagsToHtml(ssrScriptTags);
-                const matchedRouteIds = getModernRouteIdsFromMatches(serverRouter);
-                const routerServerSnapshot = createRouterServerSnapshot({
+                let disposed = false;
+                let prepared = false;
+                const onAbort = ()=>controller.abort(rawRequest.signal.reason);
+                const cleanup = ()=>{
+                    if (disposed) return;
+                    disposed = true;
+                    rawRequest.signal.removeEventListener('abort', onAbort);
+                    controller.abort();
+                    serverRouter.serverSsr?.cleanup();
+                };
+                applyRouterRuntimeState(context, {
                     framework: 'tanstack',
                     basename: _basename,
-                    statusCode: serverLoadResult.status,
-                    errors: routerErrors,
-                    matchedRouteIds,
-                    hydrationScripts
+                    instance: serverRouter,
+                    cleanup
+                });
+                rawRequest.signal.addEventListener('abort', onAbort, {
+                    once: true
                 });
-                const runtimeContext = applyRouterServerPrepareResult(context, {
-                    snapshot: routerServerSnapshot,
-                    cleanup: ()=>serverRouter.serverSsr?.cleanup?.(),
-                    state: {
+                try {
+                    rawRequest.signal.throwIfAborted();
+                    await attachServerSsrUtils(serverRouter);
+                    rawRequest.signal.throwIfAborted();
+                    const end = time();
+                    try {
+                        await tanstackRouter.load({
+                            sync: true
+                        });
+                    } finally{
+                        const cost = end();
+                        context.ssrContext?.onTiming?.(LOADER_REPORTER_NAME, cost);
+                    }
+                    rawRequest.signal.throwIfAborted();
+                    const serverLoadResult = serverRouter._serverResult;
+                    if (!serverLoadResult) throw new Error('TanStack Router completed an SSR load without a server result.');
+                    if ('redirect' === serverLoadResult.type) {
+                        const { redirect } = serverLoadResult;
+                        return interrupt(isRSCNavigation ? handleTanstackRscRedirect(redirect.headers, _basename, redirect.status) : redirect);
+                    }
+                    const routerErrors = collectRouterErrors(tanstackRouter);
+                    if (routerErrors && 'clientRender' === loaderFailureMode) {
+                        context.ssrContext?.response?.status(200);
+                        throw Object.values(routerErrors)[0];
+                    }
+                    await preloadMatchedRouteComponents(serverRouter);
+                    context.ssrContext?.response?.status(serverLoadResult.status);
+                    await serverRouter.serverSsr?.dehydrate();
+                    if (enableRsc) {
+                        setTanstackRscServerPayload(createTanstackRscServerPayload(serverRouter, {
+                            omitClientLoaderData: isRSCNavigation
+                        }));
+                        if (isRSCNavigation) context.ssrContext.response.setHeader('Content-Type', 'text/x-component');
+                    }
+                    const initialScriptTags = serverRouter.serverSsr?.takeInitialHydrationScriptTags();
+                    const hydrationScripts = initialScriptTags ? routerManagedTagsToHtml([
+                        ...initialScriptTags.before,
+                        initialScriptTags.boundary
+                    ]) : [];
+                    const matchedRouteIds = getModernRouteIdsFromMatches(serverRouter);
+                    const routerServerSnapshot = {
                         framework: 'tanstack',
                         basename: _basename,
-                        instance: serverRouter,
-                        hydrationScripts,
+                        statusCode: serverLoadResult.status,
+                        errors: routerErrors,
                         matchedRouteIds,
-                        serverSnapshot: routerServerSnapshot
-                    }
-                });
-                hooks.onAfterCreateRouter.call({
-                    ...routerLifecycleContext,
-                    router: serverRouter,
-                    serverSnapshot: routerServerSnapshot,
-                    runtimeContext
-                });
+                        hydrationScripts
+                    };
+                    const runtimeContext = applyRouterServerPrepareResult(context, {
+                        snapshot: routerServerSnapshot,
+                        cleanup,
+                        state: {
+                            framework: 'tanstack',
+                            basename: _basename,
+                            instance: serverRouter,
+                            navigation: createTanstackNavigation(tanstackRouter)
+                        }
+                    });
+                    rawRequest.signal.throwIfAborted();
+                    hooks.onAfterCreateRouter.call({
+                        ...routerLifecycleContext,
+                        router: serverRouter,
+                        serverSnapshot: getRouterServerSnapshot(runtimeContext),
+                        runtimeContext
+                    });
+                    prepared = true;
+                } finally{
+                    if (!prepared) try {
+                        cleanup();
+                    } catch  {}
+                }
             });
             api.wrapRoot((App)=>{
                 const getRouteApp = ()=>{

package/dist/esm/runtime/routeTree/construction.mjs

@@ -1,23 +1,19 @@
-import { canonicaliseLocalisedRoutes } from "@modern-js/i18n-runtime-extensions";
 import { DefaultNotFound } from "@modern-js/runtime/context";
 import { rootRouteId } from "@tanstack/react-router";
+import { describeRouteTree } from "../../shared/routeDescriptor.mjs";
 import { createRouteStaticData } from "../../shared/routeStaticData.mjs";
 import { withModernRouteMatchContext } from "../outlet.mjs";
 import { toErrorComponent, toPendingComponent, toRouteComponent } from "./components.mjs";
 import { createModernShouldReload, wrapRouteObjectLoader } from "./loaders.mjs";
-import { isRouteObjectPathlessLayout, toTanstackPath } from "./paths.mjs";
 import { mergeModernRouteHandle } from "./staticData.mjs";
 import { createTanstackRootRoute, createTanstackRoute, wrapRouteComponentWithModernContext } from "./tanstackRoutes.mjs";
-function createRouteFromRouteObject(opts) {
-    const { options = {}, parent, pathlessFallbackId = 'pathless', routeObject } = opts;
+function createRouteOptions(routeObject, options) {
     const modernRouteObject = routeObject;
     const revalidationState = {};
     const shouldRevalidate = modernRouteObject.shouldRevalidate;
     const shouldReload = createModernShouldReload(shouldRevalidate, revalidationState);
-    const stableFallbackId = routeObject.id || modernRouteObject.file || pathlessFallbackId;
     const component = toRouteComponent(routeObject);
     const base = {
-        getParentRoute: ()=>parent,
         component,
         pendingComponent: toPendingComponent(routeObject),
         errorComponent: toErrorComponent(routeObject),
@@ -38,67 +34,29 @@ function createRouteFromRouteObject(opts) {
     };
     if (modernRouteObject.inValidSSRRoute) base.ssr = false;
     if (shouldReload) base.shouldReload = shouldReload;
-    if (isRouteObjectPathlessLayout(routeObject)) base.id = stableFallbackId;
-    else base.path = routeObject.index ? '/' : toTanstackPath(routeObject.path || '');
-    const route = createTanstackRoute(base);
-    wrapRouteComponentWithModernContext(route, component, routeObject.id);
-    const children = routeObject.children;
-    if (children && children.length > 0) {
-        const childRoutes = children.map((child, index)=>createRouteFromRouteObject({
-                options,
-                parent: route,
-                pathlessFallbackId: `pathless-${index}`,
-                routeObject: child
-            }));
-        route.addChildren(childRoutes);
-    }
-    return route;
+    return base;
 }
-function getRootLikeRouteObject(routes) {
-    return routes.find((route)=>'/' === route.path && !route.index);
+function createRouteFromDescriptor(descriptor, parent, options) {
+    const { source, location, children } = descriptor;
+    const routeOptions = createRouteOptions(source, options);
+    const route = createTanstackRoute({
+        ...routeOptions,
+        ...location,
+        getParentRoute: ()=>parent
+    });
+    wrapRouteComponentWithModernContext(route, routeOptions.component, source.id);
+    if (children.length) route.addChildren(children.map((child)=>createRouteFromDescriptor(child, route, options)));
+    return route;
 }
 function createRouteTreeFromRouteObjects(routes, options = {}) {
-    routes = canonicaliseLocalisedRoutes(routes);
-    const rootLikeRoute = getRootLikeRouteObject(routes);
-    const rootRevalidationState = {};
-    const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
-    const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
-    const rootComponent = rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0;
+    const { root, children } = describeRouteTree(routes);
     const rootRouteOptions = {
-        component: rootComponent,
-        pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
-        errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
-        validateSearch: rootLikeRoute?.validateSearch,
-        loaderDeps: rootLikeRoute?.loaderDeps,
-        notFoundComponent: DefaultNotFound,
-        staticData: createRouteStaticData({
-            modernRouteId: rootLikeRoute?.id,
-            modernRouteAction: rootLikeRoute?.action,
-            modernRouteHandle: rootLikeRoute ? mergeModernRouteHandle(rootLikeRoute) : void 0,
-            modernRouteHasAction: rootLikeRoute?.hasAction || Boolean(rootLikeRoute?.action),
-            modernRouteHasClientLoader: rootLikeRoute?.hasClientLoader || void 0 !== rootLikeRoute?.clientData,
-            modernRouteHasLoader: rootLikeRoute?.hasLoader || 'function' == typeof rootLikeRoute?.loader,
-            modernRouteIsClientComponent: rootLikeRoute?.isClientComponent,
-            modernRouteLoader: rootLikeRoute?.loader,
-            modernRouteShouldRevalidate: rootShouldRevalidate
-        }),
-        loader: rootLikeRoute ? wrapRouteObjectLoader(rootLikeRoute, rootRevalidationState, options) : void 0
+        ...root ? createRouteOptions(root, options) : {},
+        notFoundComponent: DefaultNotFound
     };
-    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
-    if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
     const rootRoute = createTanstackRootRoute(rootRouteOptions);
-    if (rootComponent) rootRoute.options.component = withModernRouteMatchContext(rootComponent, rootRouteId);
-    const topLevel = rootLikeRoute ? [
-        ...rootLikeRoute.children || [],
-        ...routes.filter((route)=>route !== rootLikeRoute)
-    ] : routes;
-    const childRoutes = topLevel.map((routeObject, index)=>createRouteFromRouteObject({
-            options,
-            parent: rootRoute,
-            pathlessFallbackId: `pathless-${index}`,
-            routeObject
-        }));
-    rootRoute.addChildren(childRoutes);
+    if (rootRouteOptions.component) rootRoute.options.component = withModernRouteMatchContext(rootRouteOptions.component, rootRouteId);
+    rootRoute.addChildren(children.map((child)=>createRouteFromDescriptor(child, rootRoute, options)));
     return rootRoute;
 }
 function getModernRouteIdsFromMatches(router) {

package/dist/esm/runtime/routeTree/loaders.mjs

@@ -1,4 +1,4 @@
-import { getLoaderHref, handleModernLoaderError, handleModernLoaderResult, mapSplatParamsForModernLoader } from "../loaderBridge.mjs";
+import { getLoaderHref, getLoaderSignal, handleModernLoaderError, handleModernLoaderResult, mapSplatParamsForModernLoader } from "../loaderBridge.mjs";
 import { isTanstackRscPayloadNavigationEnabled, loadTanstackRscRouteData } from "../rsc/payloadRouter.mjs";
 function isModernDeferredData(value) {
     if (!value || 'object' != typeof value) return false;
@@ -49,7 +49,7 @@ function wrapRouteObjectLoader(route, revalidationState, options = {}) {
             if ('function' == typeof modernRoute.lazyImport) try {
                 await modernRoute.lazyImport();
             } catch  {}
-            const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
+            const signal = getLoaderSignal(ctx);
             const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
             const href = getLoaderHref(ctx);
             const request = void 0 !== baseRequest ? new Request(baseRequest, {

package/dist/esm/runtime/routeTree/paths.mjs

@@ -10,7 +10,4 @@ function toTanstackPath(pathname) {
         return segment;
     }).join('/');
 }
-function isRouteObjectPathlessLayout(route) {
-    return !route.path && !route.index;
-}
-export { isRouteObjectPathlessLayout, toTanstackPath };
+export { toTanstackPath };

package/dist/esm/runtime/ssrManagedTags.mjs

@@ -1,10 +1,3 @@
-async function waitForRouterSerialization(tanstackRouter) {
-    const serverSsr = tanstackRouter.serverSsr;
-    if (!serverSsr || 'function' != typeof serverSsr.onSerializationFinished || serverSsr.isSerializationFinished?.()) return;
-    await new Promise((resolve)=>{
-        serverSsr.onSerializationFinished?.(resolve);
-    });
-}
 function htmlEscapeAttr(value) {
     return value.replace(/&/g, '&').replace(/"/g, '"');
 }
@@ -50,4 +43,4 @@ async function attachServerSsrUtils(router) {
         manifest: void 0
     });
 }
-export { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization };
+export { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml };

package/dist/esm/runtime/utils.mjs

@@ -14,6 +14,7 @@ function withGlobalLayout(Component, globalApp) {
 function toTanstackRouteObject(route, globalApp) {
     if ('nested' === route.type) return {
         modernLocalisedRoute: Reflect.get(route, 'modernLocalisedRoute'),
+        isRoot: Reflect.get(route, 'isRoot'),
         path: route.path,
         id: route.id,
         loader: route.loader,

package/dist/esm/shared/routeDescriptor.mjs

@@ -0,0 +1,50 @@
+import { toTanstackPath } from "../runtime/routeTree/paths.mjs";
+const isPathless = (route)=>0 === (route.path ?? '').length && true !== route.index;
+const toLocationPath = (route)=>true === route.index ? '/' : toTanstackPath(route.path || '');
+const joinPath = (parent, path)=>`${parent}/${path}`.replace(/\/{2,}/g, '/');
+function collectFullPaths(routes, parentPath, fullPaths) {
+    for (const route of routes){
+        let fullPath = parentPath;
+        if (!isPathless(route)) {
+            fullPath = joinPath(parentPath, toLocationPath(route));
+            fullPaths.push(fullPath);
+        }
+        collectFullPaths(route.children ?? [], fullPath, fullPaths);
+    }
+}
+const isPrefixIndex = (fullPath, fullPaths)=>!fullPath.endsWith('/') && fullPaths.some((other)=>other.startsWith(`${fullPath}/`) && other.length > fullPath.length + 1);
+function describeRouteTree(routes) {
+    const root = routes.find((route)=>true === route.isRoot || '/' === route.path && true !== route.index);
+    const topLevel = void 0 !== root ? [
+        ...root.children ?? [],
+        ...routes.filter((route)=>route !== root)
+    ] : routes;
+    const fullPaths = [];
+    collectFullPaths(topLevel, '', fullPaths);
+    const describe = (parentPath)=>(route, index)=>{
+            const children = route.children ?? [];
+            if (isPathless(route)) return {
+                source: route,
+                location: {
+                    id: route.id || route.file || `pathless-${index}`
+                },
+                hasSplat: false,
+                children: children.map(describe(parentPath))
+            };
+            const path = toLocationPath(route);
+            const fullPath = joinPath(parentPath, path);
+            return {
+                source: route,
+                location: {
+                    path: 0 === children.length && isPrefixIndex(fullPath, fullPaths) ? `${path}/` : path
+                },
+                hasSplat: Boolean(route.path?.includes('*')),
+                children: children.map(describe(fullPath))
+            };
+        };
+    return {
+        root,
+        children: topLevel.map(describe(''))
+    };
+}
+export { describeRouteTree };

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

@@ -1,6 +1,7 @@
 import "node:module";
 import node_path from "node:path";
 import { fs } from "@modern-js/utils";
+import { ROUTE_METADATA_MANIFEST_FILE_NAME, ROUTE_METADATA_MANIFEST_HEADER, findRouteMetaFiles, renderRouteMetadataManifest } from "./routeMetadata.mjs";
 import { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes.mjs";
 const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
 async function writeFileIfChanged(filePath, content) {
@@ -78,7 +79,16 @@ async function writeTanstackRouterTypesForEntries(opts) {
         canonicalRoutes
     });
 }
+async function writeRouteMetadataManifest(opts) {
+    const routesDirectory = node_path.join(opts.appDirectory, 'src', 'routes');
+    const manifestPath = node_path.join(routesDirectory, ROUTE_METADATA_MANIFEST_FILE_NAME);
+    const manifest = renderRouteMetadataManifest(await findRouteMetaFiles(routesDirectory));
+    if (null !== manifest) return void await writeFileIfChanged(manifestPath, manifest);
+    const previous = await fs.pathExists(manifestPath) ? await fs.readFile(manifestPath, 'utf-8') : null;
+    if (previous?.startsWith(`${ROUTE_METADATA_MANIFEST_HEADER}\n`)) throw new Error(`[plugin-tanstack] ${manifestPath} is generated from route.meta.ts files, but none remain below ${routesDirectory}. Restore at least one route.meta.ts that exports routeMeta, or delete the manifest together with its imports.`);
+}
 async function generateTanstackRouteArtifacts(opts) {
+    await writeRouteMetadataManifest(opts);
     const [{ createRunOptions }, { cli }, utils] = await Promise.all([
         import("@modern-js/app-tools/cli/run"),
         import("@modern-js/plugin/cli"),
@@ -96,9 +106,10 @@ async function generateTanstackRouteArtifacts(opts) {
         version: opts.version || process.env.MODERN_JS_VERSION || '0.0.0-routes-generate',
         internalPlugins: utils.INTERNAL_RUNTIME_PLUGINS
     });
-    await cli.init({
+    const { appContext } = await cli.init({
         ...runOptions,
         command: 'build'
     });
+    await appContext.hooks.onBeforeExit.call();
 }
-export { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { generateTanstackRouteArtifacts, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

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

@@ -1,26 +1,21 @@
 import "node:module";
 import node_path from "node:path";
 import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer } from "@modern-js/utils";
-import { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries } from "./artifacts.mjs";
+import { generateTanstackRouteArtifacts, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries } from "./artifacts.mjs";
 import { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled } from "./routeSplitting.mjs";
-import { __webpack_require__ } from "../rslib-runtime~0.mjs";
+import { TANSTACK_SERVER_ROUTES_FILE, createTanstackRscRouteLayerPlugin } from "./rscRouteLayer.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 import { createRequire as __rspack_createRequire } from "node:module";
 const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
-__webpack_require__.add({
-    "@modern-js/runtime/cli?667f" (module) {
-        module.exports = __rspack_createRequire_require("@modern-js/runtime/cli");
-    }
-});
 const DEFAULT_ROUTES_DIR = 'routes';
 const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
 const ENTRYPOINTS_KEY = '@modern-js/plugin-tanstack';
 let runtimeRouterCli;
 function getRuntimeRouterCli() {
     if (runtimeRouterCli) return runtimeRouterCli;
-    const cli = __webpack_require__("@modern-js/runtime/cli?667f");
+    const cli = __rspack_createRequire_require("@modern-js/runtime/cli");
     if (cli.handleGeneratorEntryCode && cli.getEntrypointRoutesDir && cli.getEntrypointRoutesOwner && cli.updateNestedRoutesSpec) {
         runtimeRouterCli = cli;
         return runtimeRouterCli;
@@ -102,6 +97,13 @@ function tanstackRouterPlugin(options = {}) {
                 }));
             api.config(()=>({
                     ...routeSplittingProfile.defaultConfig,
+                    builderPlugins: [
+                        createTanstackRscRouteLayerPlugin(()=>({
+                                entryNames: api.getAppContext().entrypoints.filter(isTanstackEntrypoint).map((entrypoint)=>entrypoint.entryName),
+                                internalDirectory: api.getAppContext().internalDirectory,
+                                rsc: api.getNormalizedConfig().server.rsc
+                            }))
+                    ],
                     source: {
                         include: [
                             /[\\/]node_modules[\\/]@tanstack[\\/]react-router[\\/]/,
@@ -128,7 +130,7 @@ function tanstackRouterPlugin(options = {}) {
                     hydrateRscClientRoutes: true,
                     includeRouteServerLoadersInSsrEntry: false,
                     isolateRouteDataInRscLayer: true,
-                    serverRoutesFileName: 'tanstack-routes.server.js'
+                    serverRoutesFileName: TANSTACK_SERVER_ROUTES_FILE
                 });
                 await writeTanstackRouterTypesForEntries({
                     appContext: api.getAppContext(),
@@ -152,7 +154,7 @@ function tanstackRouterPlugin(options = {}) {
                             hydrateRscClientRoutes: true,
                             includeRouteServerLoadersInSsrEntry: false,
                             isolateRouteDataInRscLayer: true,
-                            serverRoutesFileName: 'tanstack-routes.server.js'
+                            serverRoutesFileName: TANSTACK_SERVER_ROUTES_FILE
                         });
                         await writeTanstackRouterTypesForEntries({
                             appContext: api.getAppContext(),
@@ -188,4 +190,4 @@ function tanstackRouterPlugin(options = {}) {
 const src_cli = tanstackRouterPlugin;
 export { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes.mjs";
 export default src_cli;
-export { createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

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

@@ -0,0 +1,72 @@
+import "node:module";
+import { readdir } from "node:fs/promises";
+import node_path from "node:path";
+const ROUTE_META_FILE_NAME = 'route.meta.ts';
+const ROUTE_METADATA_MANIFEST_FILE_NAME = 'ultramodern-route-metadata.ts';
+const ROUTE_METADATA_MANIFEST_HEADER = `// @generated by @modern-js/plugin-tanstack from ${ROUTE_META_FILE_NAME} files. Run routes-generate; do not edit.`;
+const PRINT_WIDTH = 120;
+const MANIFEST_BODY = `export const ultramodernLocalisedUrls = Object.fromEntries(
+  ultramodernRouteMetadata
+    .filter((route: { canonicalPath: string }) => route.canonicalPath !== '/')
+    .map((route) => [route.canonicalPath, route.localisedPaths]),
+);
+export const ultramodernPublicRoutes = ultramodernRouteMetadata
+  .filter((route) => route.public && route.indexable)
+  .map((route) => ({
+    canonicalPath: route.canonicalPath,
+    descriptionKey: route.descriptionKey,
+    id: route.id,
+    localisedPaths: route.localisedPaths,
+    namespace: route.namespace,
+    ownerAppId: route.ownerAppId,
+    titleKey: route.titleKey,
+    ...('jsonLd' in route ? { jsonLd: route.jsonLd } : {}),
+  }));
+export const ultramodernRouteConfig = {
+  authoring: 'colocated-route-meta',
+  generatedManifest: true,
+  localisedUrls: ultramodernLocalisedUrls,
+  namespace: ultramodernRouteNamespace,
+  publicRoutes: ultramodernPublicRoutes,
+  routes: ultramodernRouteMetadata,
+  source: 'route-owned',
+} as const;
+`;
+const compareCodeUnits = (left, right)=>left < right ? -1 : left > right ? 1 : 0;
+const quoteSpecifier = (specifier)=>specifier.includes("'") ? JSON.stringify(specifier) : `'${specifier}'`;
+function renderRouteMetadataManifest(routeMetaFiles) {
+    const specifiers = routeMetaFiles.map((file)=>`./${file.replaceAll('\\', '/').replace(/\.ts$/u, '')}`).sort(compareCodeUnits);
+    if (0 === specifiers.length) return null;
+    const bindings = specifiers.map((_, index)=>`route${index}`);
+    const imports = specifiers.map((specifier, index)=>`import { routeMeta as ${bindings[index]} } from ${quoteSpecifier(specifier)};`);
+    const inlineRoutes = `export const ultramodernRouteMetadata = [${bindings.join(', ')}] as const;`;
+    const routes = inlineRoutes.length <= PRINT_WIDTH ? inlineRoutes : `export const ultramodernRouteMetadata = [\n${bindings.map((binding)=>`  ${binding},\n`).join('')}] as const;`;
+    return `${ROUTE_METADATA_MANIFEST_HEADER}
+${imports.join('\n')}
+
+export const ultramodernRouteNamespace = route0.namespace;
+${routes}
+${MANIFEST_BODY}`;
+}
+async function findRouteMetaFiles(routesDirectory) {
+    const files = [];
+    const visit = async (relativeDirectory)=>{
+        const entries = await readdir(node_path.join(routesDirectory, relativeDirectory), {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            const relativePath = node_path.join(relativeDirectory, entry.name);
+            if (entry.isDirectory()) await visit(relativePath);
+            else if (entry.isFile() && entry.name === ROUTE_META_FILE_NAME) files.push(relativePath);
+        }
+    };
+    try {
+        await visit('');
+    } catch (error) {
+        const { code, path: missingPath } = error;
+        if ('ENOENT' === code && missingPath === routesDirectory) return [];
+        throw error;
+    }
+    return files;
+}
+export { ROUTE_METADATA_MANIFEST_FILE_NAME, ROUTE_METADATA_MANIFEST_HEADER, ROUTE_META_FILE_NAME, findRouteMetaFiles, renderRouteMetadataManifest };

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

@@ -0,0 +1,36 @@
+import "node:module";
+import node_path from "node:path";
+const TANSTACK_SERVER_ROUTES_FILE = 'tanstack-routes.server.js';
+function exactResource(...filenames) {
+    const escaped = filenames.map((filename)=>filename.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&'));
+    return new RegExp(`^(?:${escaped.join('|')})(?:\\?.*)?$`, 'u');
+}
+function createTanstackRscRouteLayerPlugin(getContext) {
+    return {
+        name: 'modern:tanstack:rsc-route-layer',
+        setup (api) {
+            api.modifyRspackConfig({
+                order: 'post',
+                handler (config, { environment, rspack, target }) {
+                    const { entryNames, internalDirectory, rsc } = getContext();
+                    if (false === rsc || void 0 === rsc || 0 === entryNames.length) return;
+                    const rscServerEnvironment = 'object' == typeof rsc ? rsc.environments?.server ?? 'server' : 'server';
+                    if ('node' !== target && 'node' !== config.target && environment.name !== rscServerEnvironment) return;
+                    config.module ??= {};
+                    config.module.rules ??= [];
+                    config.plugins ??= [];
+                    for (const entryName of entryNames){
+                        const routes = node_path.resolve(internalDirectory, entryName, 'routes.js');
+                        const serverRoutes = node_path.resolve(internalDirectory, entryName, TANSTACK_SERVER_ROUTES_FILE);
+                        config.plugins.push(new rspack.NormalModuleReplacementPlugin(exactResource(routes), serverRoutes));
+                        config.module.rules.push({
+                            resource: exactResource(routes, serverRoutes),
+                            layer: 'server-side-rendering'
+                        });
+                    }
+                }
+            });
+        }
+    };
+}
+export { TANSTACK_SERVER_ROUTES_FILE, createTanstackRscRouteLayerPlugin };