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

package/dist/esm-node/runtime/navigation.mjs

@@ -0,0 +1,65 @@
+import "node:module";
+import { Link } from "./prefetchLink.mjs";
+function createTanstackNavigation(router) {
+    let location;
+    let matches;
+    let snapshot;
+    return {
+        Link: Link,
+        getSnapshot () {
+            const state = router.state;
+            if (location !== state.location || void 0 === matches || matches.length !== state.matches.length || matches.some((match, index)=>match.params !== state.matches[index]?.params)) {
+                location = state.location;
+                matches = state.matches;
+                snapshot = {
+                    location: {
+                        pathname: location.pathname,
+                        search: location.searchStr,
+                        hash: '' !== location.hash ? `#${location.hash.replace(/^#/, '')}` : ''
+                    },
+                    params: Object.assign({}, ...matches.map((match)=>match.params))
+                };
+            }
+            return snapshot;
+        },
+        subscribe (listener) {
+            const stops = [
+                'onBeforeNavigate',
+                'onBeforeLoad',
+                'onLoad',
+                'onResolved'
+            ].map((event)=>router.subscribe(event, listener));
+            return ()=>{
+                for (const stop of stops)stop();
+            };
+        },
+        navigate (href, options) {
+            return router.navigate({
+                to: href,
+                replace: options?.replace,
+                ...options?.state === void 0 ? {} : {
+                    state: options.state
+                }
+            });
+        },
+        createLinkProps (target) {
+            const preload = void 0 !== target.preload ? target.preload : 'none' === target.prefetch ? false : target.prefetch;
+            return {
+                to: target.pathname,
+                ...void 0 !== target.search ? {
+                    search: target.search
+                } : {},
+                ...void 0 !== target.hash && '' !== target.hash ? {
+                    hash: target.hash
+                } : {},
+                ...void 0 === target.hashScrollIntoView ? {} : {
+                    hashScrollIntoView: target.hashScrollIntoView
+                },
+                ...void 0 === preload ? {} : {
+                    preload
+                }
+            };
+        }
+    };
+}
+export { createTanstackNavigation };

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

@@ -11,6 +11,7 @@ import { ModernRouterClient, getTanstackSsrHydrationPromise, hasTanstackSsrHydra
 import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
 import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { createTanstackNavigation } from "./navigation.mjs";
 import { createTanstackRouteObjects, getMergedRouterConfig, getTanstackRouteConfig, joinBasename } from "./pluginShared.mjs";
 import { Link } from "./prefetchLink.mjs";
 import { useMatches } from "./routeHooks.mjs";
@@ -143,10 +144,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         runtimeContext
                     ]);
                     if (!router) return App ? /*#__PURE__*/ jsx(App, {}) : null;
+                    const navigation = useMemo(()=>createTanstackNavigation(router), [
+                        router
+                    ]);
                     const runtimeState = applyRouterRuntimeState(runtimeContext, {
                         framework: 'tanstack',
                         basename: _basename,
-                        instance: router
+                        instance: router,
+                        navigation
                     });
                     const lifecycleContext = {
                         framework: 'tanstack',

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

@@ -9,7 +9,8 @@ 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";
@@ -88,76 +89,93 @@ 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) {
+                        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 = {
                         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-node/runtime/routeTree/construction.mjs

@@ -1,24 +1,20 @@
 import "node:module";
-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),
@@ -39,67 +35,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-node/runtime/routeTree/loaders.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-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;
@@ -50,7 +50,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-node/runtime/routeTree/paths.mjs

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

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

@@ -15,6 +15,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-node/shared/routeDescriptor.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+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/types/cli/tanstackTypes/shared.d.ts

@@ -11,8 +11,6 @@ export declare function pickRouteSearchContractModules(route: NestedRouteForCli
     validateSearchPath: string | null;
     loaderDepsPath: string | null;
 };
-export declare function isPathlessLayout(route: NestedRouteForCli | PageRoute): boolean;
-export declare function isIndexRoute(route: NestedRouteForCli | PageRoute): boolean;
 export declare function createRouteStaticDataSnippet(opts: {
     modernRouteId?: string;
     loaderName?: string | null;

package/dist/types/runtime/lifecycle.d.ts

@@ -11,4 +11,4 @@ export type RouterLifecycleContext = NativeRouterLifecycleContext & {
     cleanup?: () => void | Promise<void>;
     serverSnapshot?: InternalRouterServerSnapshot;
 };
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterRuntimeState, createRouterServerSnapshot, getRouterRuntimeState, getRouterServerSnapshot, type RouterLifecyclePhase, } from '@modern-js/runtime-extensions/router-state';
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterServerSnapshot, getRouterRuntimeState, getRouterServerSnapshot, type RouterLifecyclePhase, } from '@modern-js/runtime-extensions/router-state';

package/dist/types/runtime/loaderBridge.d.ts

@@ -39,6 +39,7 @@ type LoaderLikeContext = {
     };
     params?: Record<string, string>;
 };
+export declare function getLoaderSignal(ctx: LoaderLikeContext | undefined): AbortSignal;
 export declare function getLoaderHref(ctx: LoaderLikeContext | undefined): string;
 export declare function handleModernLoaderResult<LoaderResult>(result: LoaderResult): LoaderResult;
 export declare function handleModernLoaderError(err: unknown): never;

package/dist/types/runtime/navigation.d.ts

@@ -0,0 +1,4 @@
+import type { RouterNavigationCapability } from '@modern-js/runtime-extensions/router-state';
+import type { AnyRouter } from '@tanstack/react-router';
+/** Native TanStack navigation, exposed through the provider contract. */
+export declare function createTanstackNavigation(router: AnyRouter): RouterNavigationCapability;

package/dist/types/runtime/routeTree/paths.d.ts

@@ -1,3 +1 @@
-import type { RouteObject } from '@modern-js/runtime-utils/router';
 export declare function toTanstackPath(pathname: string): string;
-export declare function isRouteObjectPathlessLayout(route: RouteObject): boolean;

package/dist/types/shared/routeDescriptor.d.ts

@@ -0,0 +1,26 @@
+type RouteShape = {
+    id?: string;
+    file?: string;
+    path?: string;
+    index?: boolean;
+    isRoot?: boolean;
+    children?: RouteShape[];
+};
+/** Browser-safe structure shared by the executable tree and concrete TS emitter. */
+export type RouteDescriptor<T extends RouteShape> = {
+    source: T;
+    location: {
+        id: string;
+        path?: never;
+    } | {
+        path: string;
+        id?: never;
+    };
+    hasSplat: boolean;
+    children: RouteDescriptor<T>[];
+};
+export declare function describeRouteTree<T extends RouteShape>(routes: T[]): {
+    root: T | undefined;
+    children: RouteDescriptor<T>[];
+};
+export {};

package/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "tanstack-router"
   ],
-  "version": "3.9.0-ultramodern.10",
+  "version": "3.9.0-ultramodern.12",
   "engines": {
     "node": ">=20"
   },
@@ -94,19 +94,19 @@
     }
   },
   "dependencies": {
-    "@modern-js/i18n-runtime-extensions": "npm:@bleedingdev/modern-js-i18n-runtime-extensions@3.9.0-ultramodern.10",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.10",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.10",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.10",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.10",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.10",
+    "@modern-js/i18n-runtime-extensions": "npm:@bleedingdev/modern-js-i18n-runtime-extensions@3.9.0-ultramodern.12",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.12",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.12",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.12",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.12",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.12",
     "@swc/helpers": "^0.5.23",
     "@tanstack/react-router": "1.170.33",
     "@tanstack/router-core": "1.171.28"
   },
   "peerDependencies": {
-    "@modern-js/app-tools": "3.9.0-ultramodern.10",
-    "@modern-js/runtime": "3.9.0-ultramodern.10",
+    "@modern-js/app-tools": "3.9.0-ultramodern.12",
+    "@modern-js/runtime": "3.9.0-ultramodern.12",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "react-server-dom-rspack": "0.1.0"
@@ -117,9 +117,9 @@
     }
   },
   "devDependencies": {
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.10",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.10",
-    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.10",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.12",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.12",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.12",
     "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
     "@tanstack/history": "1.162.2",

package/src/cli/artifacts.ts

@@ -251,5 +251,10 @@ export async function generateTanstackRouteArtifacts(opts: {
     internalPlugins: (utils as { INTERNAL_RUNTIME_PLUGINS: unknown })
       .INTERNAL_RUNTIME_PLUGINS as never,
   });
-  await cli.init({ ...runOptions, command: 'build' });
+  const { appContext } = await cli.init({ ...runOptions, command: 'build' });
+  // Preparation owns the artifact writes; there is no dev server or bundler
+  // phase after it. Release plugin resources before the headless caller exits.
+  // Failed initialization propagates unchanged: it has not returned a context
+  // whose lifecycle this caller can close.
+  await appContext.hooks.onBeforeExit.call();
 }

package/src/cli/tanstackTypes/canonicalRoutes.ts

@@ -1,7 +1,10 @@
 // @effect-diagnostics asyncFunction:off strictBooleanExpressions:off
 
 import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
-import { MAIN_ENTRY_NAME } from '@modern-js/utils';
+import {
+  describeRouteTree,
+  type RouteDescriptor,
+} from '../../shared/routeDescriptor';
 
 import { toTanstackPath } from './shared';
 
@@ -16,6 +19,7 @@ const LOCALE_PARAM_SEGMENTS = new Set([
 
 type CanonicalAwareRoute = (NestedRouteForCli | PageRoute) & {
   modernCanonicalPath?: string;
+  modernLocalisedRoute?: { canonicalPath: string };
   index?: boolean;
   isRoot?: boolean;
   children?: CanonicalAwareRoute[];
@@ -101,12 +105,18 @@ export function collectCanonicalRoutesForEntry(
     }
   };
 
-  const visit = (route: CanonicalAwareRoute, parentPath: string) => {
+  const visit = (
+    descriptor: RouteDescriptor<CanonicalAwareRoute>,
+    parentPath: string,
+  ) => {
+    const { source: route, children } = descriptor;
     let currentPath = parentPath;
 
-    if (typeof route.modernCanonicalPath === 'string') {
+    const canonicalPath =
+      route.modernLocalisedRoute?.canonicalPath ?? route.modernCanonicalPath;
+    if (typeof canonicalPath === 'string') {
       hasI18nSurface = true;
-      currentPath = normalizeJoined(route.modernCanonicalPath);
+      currentPath = canonicalPath ? normalizeJoined(canonicalPath) : '';
     } else if (typeof route.path === 'string' && route.path.length > 0) {
       const segments = route.path
         .replace(/\[(.+?)\]/g, ':$1')
@@ -125,7 +135,6 @@ export function collectCanonicalRoutesForEntry(
         : parentPath;
     }
 
-    const children = route.children;
     if (children && children.length > 0) {
       for (const child of children) {
         visit(child, currentPath);
@@ -137,13 +146,9 @@ export function collectCanonicalRoutesForEntry(
     record(currentPath || '/');
   };
 
-  const rootModern = routes.find(
-    route => (route as CanonicalAwareRoute).isRoot,
-  ) as CanonicalAwareRoute | undefined;
-  const topLevel = rootModern ? (rootModern.children ?? []) : routes;
-
-  for (const route of topLevel) {
-    visit(route as CanonicalAwareRoute, '');
+  for (const route of describeRouteTree(routes as CanonicalAwareRoute[])
+    .children) {
+    visit(route, '');
   }
 
   if (!hasI18nSurface || canonicalParams.size === 0) {

package/src/cli/tanstackTypes/shared.ts

@@ -71,20 +71,6 @@ export function pickRouteSearchContractModules(
   };
 }
 
-export function isPathlessLayout(route: NestedRouteForCli | PageRoute) {
-  const extras = route as RouteExtras;
-  return (
-    extras.type === 'nested' &&
-    typeof extras.index !== 'boolean' &&
-    typeof extras.path === 'undefined'
-  );
-}
-
-export function isIndexRoute(route: NestedRouteForCli | PageRoute) {
-  const extras = route as RouteExtras;
-  return extras.type === 'nested' && Boolean(extras.index);
-}
-
 export function createRouteStaticDataSnippet(opts: {
   modernRouteId?: string;
   loaderName?: string | null;