@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

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

@@ -8,12 +8,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 = {})=>{
@@ -35,6 +37,9 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     routeConfig
                 });
                 if (!modifiedRouteObjects.length) return;
+                context.router = {
+                    Link: Link
+                };
                 const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
                 const _basename = '/' === baseUrl ? joinBasename(baseUrl, basename || '') : baseUrl;
                 const rawRequest = request.raw;
@@ -57,7 +62,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         initialHref
                     ]
                 });
-                const rewrite = createModernBasepathRewrite(_basename);
+                const rewrite = createModernBasepathRewrite(_basename, false, modifiedRouteObjects);
                 const routerLifecycleContext = {
                     framework: 'tanstack',
                     phase: 'ssr-prepare',
@@ -83,76 +88,93 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 });
                 const serverRouter = tanstackRouter;
                 if (enableRsc) setTanstackRscRouter(serverRouter);
-                await attachServerSsrUtils(serverRouter);
-                const end = time();
+                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,
+                    instance: serverRouter,
+                    cleanup
+                });
+                rawRequest.signal.addEventListener('abort', onAbort, {
+                    once: true
+                });
                 try {
-                    await tanstackRouter.load({
-                        sync: true
-                    });
-                } finally{
-                    const cost = end();
-                    context.ssrContext?.onTiming?.(LOADER_REPORTER_NAME, cost);
-                }
-                const serverLoadResult = serverRouter._serverResult;
-                if (!serverLoadResult) {
+                    rawRequest.signal.throwIfAborted();
+                    await attachServerSsrUtils(serverRouter);
+                    rawRequest.signal.throwIfAborted();
+                    const end = time();
                     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, {
+                        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
                     }));
-                }
-                const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
-                const hydrationScripts = routerManagedTagsToHtml(ssrScriptTags);
-                const matchedRouteIds = getModernRouteIdsFromMatches(serverRouter);
-                const routerServerSnapshot = createRouterServerSnapshot({
-                    framework: 'tanstack',
-                    basename: _basename,
-                    statusCode: serverLoadResult.status,
-                    errors: routerErrors,
-                    matchedRouteIds,
-                    hydrationScripts
-                });
-                const runtimeContext = applyRouterServerPrepareResult(context, {
-                    snapshot: routerServerSnapshot,
-                    cleanup: ()=>serverRouter.serverSsr?.cleanup?.(),
-                    state: {
+                    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/prefetchLink.mjs

@@ -1,11 +1,6 @@
 import { jsx } from "react/jsx-runtime";
+import { resolvePreloadFromPrefetch } from "@modern-js/runtime-extensions";
 import { useLinkProps } from "@tanstack/react-router";
-function resolvePreloadFromPrefetch(prefetch, preload) {
-    if (void 0 !== preload) return preload;
-    if ('none' === prefetch) return false;
-    if ('intent' === prefetch || 'render' === prefetch || 'viewport' === prefetch) return prefetch;
-    return 'viewport';
-}
 const LinkComponentImpl = (props)=>{
     const { prefetch, preload, 'aria-current': ariaCurrentProp, ref, children, ...rest } = props;
     const hasAriaCurrentOverride = 'aria-current' in props;

package/dist/esm/runtime/register.mjs

@@ -1,5 +1,3 @@
-import { registerRouterProvider } from "@modern-js/runtime/context";
 import { tanstackRouterPlugin } from "./plugin.mjs";
 const tanstackRouterProviderFactory = (userConfig)=>tanstackRouterPlugin(userConfig);
-registerRouterProvider('tanstack', tanstackRouterProviderFactory);
 export { tanstackRouterProviderFactory };

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

@@ -1,22 +1,19 @@
 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),
@@ -37,66 +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 = {}) {
-    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/router.mjs

@@ -1,16 +1,32 @@
-import * as __rspack_external__modern_js_runtime_router_internal_8b8183c5 from "@modern-js/runtime/router/internal";
+import { routerProviderRegistryHooks } from "@modern-js/runtime/context";
+import { routerPlugin } from "@modern-js/runtime/router/internal";
+import { createRouterPlugin } from "@modern-js/runtime-extensions/router-provider";
+import { createRouterStatePlugin } from "@modern-js/runtime-extensions/router-state-plugin";
 import { tanstackRouterProviderFactory } from "./register.mjs";
-function getRouterPlugin() {
-    const createRouterPlugin = Reflect.get(__rspack_external__modern_js_runtime_router_internal_8b8183c5, 'createRouterPlugin');
-    if ('function' == typeof createRouterPlugin) return createRouterPlugin([
+const createProviderPlugin = createRouterPlugin({
+    defaultProvider: {
+        name: 'react-router',
+        factory: routerPlugin
+    },
+    registryHooks: routerProviderRegistryHooks,
+    localProviders: [
         {
             name: 'tanstack',
             factory: tanstackRouterProviderFactory
         }
-    ]);
-    const legacyRouterPlugin = Reflect.get(__rspack_external__modern_js_runtime_router_internal_8b8183c5, 'routerPlugin');
-    if ('function' == typeof legacyRouterPlugin) return tanstackRouterProviderFactory;
-    throw new Error('[@modern-js/plugin-tanstack] The installed @modern-js/runtime/router/internal exports neither createRouterPlugin nor routerPlugin. Install a compatible @modern-js/runtime version.');
-}
-const routerPlugin = getRouterPlugin();
-export { routerPlugin };
+    ]
+});
+const statePlugin = createRouterStatePlugin({
+    registryHooks: routerProviderRegistryHooks
+});
+const router_routerPlugin = (userConfig = {})=>{
+    const providerPlugin = createProviderPlugin(userConfig);
+    return {
+        ...providerPlugin,
+        setup (api) {
+            statePlugin.setup(api);
+            providerPlugin.setup(api);
+        }
+    };
+};
+export { router_routerPlugin as routerPlugin };

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/state.mjs

@@ -1,4 +1,4 @@
-import { getRouterRuntimeState } from "@modern-js/runtime/context";
+import { getRouterRuntimeState } from "@modern-js/runtime-extensions/router-state";
 function getTanstackRouterState(context) {
     const state = getRouterRuntimeState(context);
     if (void 0 === state || 'tanstack' !== state.framework || void 0 === state.instance) return;

package/dist/esm/runtime/utils.mjs

@@ -13,6 +13,8 @@ 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,
@@ -37,6 +39,7 @@ function toTanstackRouteObject(route, globalApp) {
     if ('function' != typeof route.component && 'object' != typeof route.component) return null;
     const LayoutComponent = withGlobalLayout(route.component, globalApp);
     return {
+        modernLocalisedRoute: Reflect.get(route, 'modernLocalisedRoute'),
         path: route.path,
         element: /*#__PURE__*/ react.createElement(LayoutComponent)
     };

package/dist/esm/shared/routeDescriptor.mjs

@@ -0,0 +1,22 @@
+import { toTanstackPath } from "../runtime/routeTree/paths.mjs";
+function describeRouteTree(routes) {
+    const root = routes.find((route)=>true === route.isRoot || '/' === route.path && true !== route.index);
+    const describe = (route, index)=>({
+            source: route,
+            location: 0 === (route.path ?? '').length && true !== route.index ? {
+                id: route.id || route.file || `pathless-${index}`
+            } : {
+                path: true === route.index ? '/' : toTanstackPath(route.path || '')
+            },
+            hasSplat: Boolean(route.path?.includes('*')),
+            children: (route.children ?? []).map(describe)
+        });
+    return {
+        root,
+        children: (void 0 !== root ? [
+            ...root.children ?? [],
+            ...routes.filter((route)=>route !== root)
+        ] : routes).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,20 @@
 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 { 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;
@@ -37,6 +31,15 @@ function tanstackRouterPlugin(options = {}) {
             '@modern-js/runtime'
         ],
         setup: (api)=>{
+            const { srcDirectory, serverCompileExcludedFiles = [] } = api.getAppContext();
+            api.updateAppContext({
+                serverCompileExcludedFiles: [
+                    ...new Set([
+                        ...serverCompileExcludedFiles,
+                        node_path.join(srcDirectory, generatedDirName, 'register.gen.d.ts')
+                    ])
+                ]
+            });
             const nestedRoutesForServer = {};
             const isTanstackEntrypoint = (entrypoint)=>{
                 const { getEntrypointRoutesDir } = getRuntimeRouterCli();
@@ -179,4 +182,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 };