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

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

@@ -1,23 +1,20 @@
 import "node:module";
 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,66 +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 = {}) {
-    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/router.mjs

@@ -1,17 +1,33 @@
 import "node:module";
-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-node/runtime/ssrManagedTags.mjs

@@ -1,11 +1,4 @@
 import "node:module";
-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, '"');
 }
@@ -51,4 +44,4 @@ async function attachServerSsrUtils(router) {
         manifest: void 0
     });
 }
-export { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization };
+export { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml };

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

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

@@ -14,6 +14,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,
@@ -38,6 +40,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-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/artifacts.d.ts

@@ -21,11 +21,19 @@ export declare function writeTanstackRouterTypesForEntries(opts: {
     i18nPluginInstalled?: boolean;
 }): Promise<void>;
 /**
- * Headless regeneration of `router.gen.ts` / `register.gen.d.ts` for a generated
- * app, without running a full dev/build. Drives the app-tools analyze `onPrepare`
- * (which fires `generateEntryCode`) and returns before any bundling — the app's
- * own registered plugin-tanstack writes the artifacts via its `generateEntryCode`
- * subscriber. Reuses the exact hook dev/build use, so there is no scanning drift.
+ * Writes `src/routes/ultramodern-route-metadata.ts` from the `route.meta.ts`
+ * files below `src/routes`. Reads only the file system, never the app config.
+ */
+export declare function writeRouteMetadataManifest(opts: {
+    appDirectory: string;
+}): Promise<void>;
+/**
+ * Headless regeneration of the route metadata manifest and of `router.gen.ts` /
+ * `register.gen.d.ts` for a generated app, without running a full dev/build.
+ * Drives the app-tools analyze `onPrepare` (which fires `generateEntryCode`)
+ * and returns before any bundling — the app's own registered plugin-tanstack
+ * writes the router artifacts via its `generateEntryCode` subscriber. Reuses
+ * the exact hook dev/build use, so there is no scanning drift.
  */
 export declare function generateTanstackRouteArtifacts(opts: {
     appDirectory: string;

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

@@ -1,6 +1,6 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import { type TanstackRouteCodeSplittingOption } from './routeSplitting.js';
-export { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries, } from './artifacts.js';
+export { generateTanstackRouteArtifacts, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries, } from './artifacts.js';
 export type { TanstackRouteCodeSplittingOption, TanstackRsbuildRouteSplittingProfile, } from './routeSplitting.js';
 export { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled, } from './routeSplitting.js';
 export { type CollectCanonicalRoutesOptions, collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry, } from './tanstackTypes.js';

package/dist/types/cli/routeMetadata.d.ts

@@ -0,0 +1,18 @@
+export declare const ROUTE_META_FILE_NAME = "route.meta.ts";
+export declare const ROUTE_METADATA_MANIFEST_FILE_NAME = "ultramodern-route-metadata.ts";
+export declare const ROUTE_METADATA_MANIFEST_HEADER = "// @generated by @modern-js/plugin-tanstack from route.meta.ts files. Run routes-generate; do not edit.";
+/**
+ * Renders the route metadata manifest for the `route.meta.ts` files of one
+ * routes directory. Each path is relative to that directory (either separator).
+ * Every `route.meta.ts` must export `routeMeta`; the manifest imports it
+ * statically, so the metadata is never evaluated while generating. Returns
+ * `null` when there are no route metadata files. Output depends only on the
+ * set of paths, never on their order or on the file system.
+ */
+export declare function renderRouteMetadataManifest(routeMetaFiles: readonly string[]): string | null;
+/**
+ * Lists the `route.meta.ts` files below `routesDirectory`, relative to it.
+ * Symbolic links are not followed: linked metadata belongs to the tree it
+ * lives in. A missing directory has no route metadata.
+ */
+export declare function findRouteMetaFiles(routesDirectory: string): Promise<string[]>;

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/basepathRewrite.d.ts

@@ -1,4 +1,5 @@
-export declare function createModernBasepathRewrite(basepath: string, caseSensitive?: boolean): {
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+export declare function createModernBasepathRewrite(basepath: string, caseSensitive?: boolean, routes?: RouteObject[]): {
     input: ({ url }: {
         url: URL;
     }) => URL;

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

@@ -1,7 +1,14 @@
 /**
- * The router runtime state helpers are owned by @modern-js/runtime (the same
+ * The router runtime state helpers are owned by @modern-js/runtime-extensions (the same
  * implementation backs the built-in react-router provider and the SSR
  * pipeline). This module only re-exports them so every router provider
  * writes to the exact same runtime-context extension slot.
  */
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterRuntimeState, createRouterServerSnapshot, getRouterRuntimeState, getRouterServerSnapshot, type RouterLifecycleContext, type RouterLifecyclePhase, } from '@modern-js/runtime/context';
+import type { RouterLifecycleContext as NativeRouterLifecycleContext } from '@modern-js/runtime/context';
+import type { InternalRouterServerSnapshot, RouterRouteMatchSnapshot } from '@modern-js/runtime-extensions/router-state';
+export type RouterLifecycleContext = NativeRouterLifecycleContext & {
+    matches?: RouterRouteMatchSnapshot[];
+    cleanup?: () => void | Promise<void>;
+    serverSnapshot?: InternalRouterServerSnapshot;
+};
+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/register.d.ts

@@ -1,10 +1,2 @@
-/**
- * Registers TanStack in the @modern-js/runtime compatibility registry.
- * Runtime entries bind the exported local factory into their own provider
- * realm; registration remains for older runtime wrappers and mixed cohorts.
- *
- * This module is intentionally side-effectful (see `sideEffects` in
- * package.json).
- */
-import { type RouterProviderFactory } from '@modern-js/runtime/context';
+import { type RouterProviderFactory } from '@modern-js/runtime-extensions/router-provider';
 export declare const tanstackRouterProviderFactory: RouterProviderFactory;

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/runtime/router.d.ts

@@ -1,13 +1,2 @@
-/**
- * Entry-injected router module for entrypoints that are NOT TanStack
- * file-route entrypoints (e.g. apps configuring
- * `router: { framework: 'tanstack', createRoutes }` in modern.runtime.ts).
- *
- * The CLI plugin injects `{ name: 'router', path: '<pkg>/runtime/router' }`
- * for those entries. This module creates a framework-resolving wrapper whose
- * app-owned provider realm contains this module graph's TanStack factory.
- */
-import * as runtimeRouter from '@modern-js/runtime/router/internal';
-type LegacyRouterPlugin = (typeof runtimeRouter)['routerPlugin'];
-export declare const routerPlugin: LegacyRouterPlugin;
-export {};
+import { routerPlugin as nativeRouterPlugin } from '@modern-js/runtime/router/internal';
+export declare const routerPlugin: typeof nativeRouterPlugin;

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

@@ -1,6 +1,5 @@
 import type { AnyRouter } from '@tanstack/react-router';
 import type { TanstackRouterWithServerSsr } from './ssrTypes.js';
-export declare function waitForRouterSerialization(tanstackRouter: TanstackRouterWithServerSsr): Promise<void>;
 export declare function routerManagedTagsToHtml(tags: unknown): string[];
 export declare function createGetSsrHref(request: Request): string;
 export declare function collectRouterErrors(tanstackRouter: AnyRouter): Record<string, unknown> | undefined;

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

@@ -28,13 +28,6 @@ type RouterRouteWithOptions = {
 };
 export type TanstackRouterWithServerSsr = AnyRouter & {
     routesById?: Record<string, RouterRouteWithOptions>;
-    serverSsr?: {
-        cleanup?: () => void;
-        dehydrate?: () => Promise<void> | void;
-        isSerializationFinished?: () => boolean;
-        onSerializationFinished?: (listener: () => void) => void;
-        takeBufferedScripts?: () => unknown;
-    };
     state: AnyRouter['state'] & {
         matches?: unknown;
     };

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

@@ -1,4 +1,4 @@
-import { type InternalRouterRuntimeState } from '@modern-js/runtime/context';
+import { type InternalRouterRuntimeState } from '@modern-js/runtime-extensions/router-state';
 import type { AnyRouter } from '@tanstack/react-router';
 /**
  * Router runtime state as published by the TanStack router provider into the

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

@@ -1,7 +1,8 @@
 import type { ModernRoute } from '@modern-js/runtime/context';
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type React from 'react';
-export type { InternalRouterServerSnapshot, ModernRoute, RouterFramework, } from '@modern-js/runtime/context';
+export type { ModernRoute } from '@modern-js/runtime/context';
+export type { InternalRouterServerSnapshot, RouterFramework, } from '@modern-js/runtime-extensions/router-state';
 /** TanStack-specific router config. */
 export type RouterConfig = {
     routesConfig: {

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.2",
+  "version": "3.9.0-ultramodern.21",
   "engines": {
     "node": ">=20"
   },
@@ -94,17 +94,19 @@
     }
   },
   "dependencies": {
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.2",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.2",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.2",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.2",
+    "@modern-js/i18n-runtime-extensions": "npm:@bleedingdev/modern-js-i18n-runtime-extensions@3.9.0-ultramodern.21",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.21",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.21",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.21",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.21",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.21",
     "@swc/helpers": "^0.5.23",
-    "@tanstack/react-router": "1.170.33",
-    "@tanstack/router-core": "1.171.28"
+    "@tanstack/react-router": "1.170.39",
+    "@tanstack/router-core": "1.171.32"
   },
   "peerDependencies": {
-    "@modern-js/app-tools": "3.9.0-ultramodern.2",
-    "@modern-js/runtime": "3.9.0-ultramodern.2",
+    "@modern-js/app-tools": "3.9.0-ultramodern.21",
+    "@modern-js/runtime": "3.9.0-ultramodern.21",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "react-server-dom-rspack": "0.1.0"
@@ -115,19 +117,20 @@
     }
   },
   "devDependencies": {
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.2",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.2",
-    "@rslib/core": "1.0.0",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.21",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.21",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.21",
+    "@rslib/core": "1.0.2",
     "@scripts/rstest-config": "2.66.0",
-    "@tanstack/history": "1.162.2",
+    "@tanstack/history": "1.162.4",
     "@testing-library/react": "^16.3.3",
     "@tsconfig/strictest": "2.0.8",
-    "@types/node": "^26.4.1",
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.7",
+    "@types/node": "^26.6.2",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "react-server-dom-rspack": "0.1.0"
   },
   "sideEffects": [
@@ -150,6 +153,6 @@
   "scripts": {
     "dev": "rslib build --watch",
     "build": "rslib build",
-    "test": "rstest --passWithNoTests"
+    "test": "rstest"
   }
 }

package/rstest.config.mts

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import type { ProjectConfig } from '@rstest/core';
 import { withTestPreset } from '@scripts/rstest-config';
 
@@ -24,20 +23,14 @@ export default {
       name: 'plugin-tanstack-node',
       testEnvironment: 'node',
       include: [
-        'tests/realm-isolation.test.ts',
         'tests/router/cli.test.ts',
-        'tests/router/fastDefaults.test.ts',
         'tests/router/flightSerialization.roundtrip.test.tsx',
         'tests/router/generateRouteArtifacts.test.ts',
-        'tests/router/hooks.test.ts',
         'tests/router/loaderBridge.test.ts',
-        'tests/router/packageSurface.test.ts',
-        'tests/router/preloadRedirect.test.ts',
-        'tests/router/register.test.ts',
+        'tests/router/localisedIdentity.test.tsx',
         'tests/router/routeHooks.test.ts',
+        'tests/router/routeMetadata.test.ts',
         'tests/router/serverPlugin.test.ts',
-        'tests/router/rscDecoderSecurity.test.ts',
-        'tests/router/rscPayloadRouterMatrix.test.ts',
         'tests/router/rsc.test.tsx',
         'tests/router/slotUsageSanitizer.test.ts',
         'tests/router/ssrPreload.test.ts',
@@ -46,27 +39,12 @@ export default {
       ],
       extends: commonConfig,
     }),
-    withTestPreset({
-      name: 'plugin-tanstack-router-compatibility',
-      testEnvironment: 'node',
-      include: ['tests/router/routerCompatibility.test.ts'],
-      resolve: {
-        alias: {
-          '@modern-js/runtime/router/internal': path.resolve(
-            __dirname,
-            'tests/router/fixtures/legacyRuntimeRouter.ts',
-          ),
-        },
-      },
-      extends: commonConfig,
-    }),
     withTestPreset({
       name: 'plugin-tanstack-client',
       testEnvironment: 'happy-dom',
       include: [
         'tests/router/clientHydration.test.tsx',
         'tests/router/dataMutation.test.tsx',
-        'tests/router/hydrationBoundary.test.tsx',
         'tests/router/prefetchLink.test.tsx',
         'tests/router/prefetchLinkPreload.test.tsx',
       ],