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

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

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

@@ -1,4 +1,5 @@
-import type { AppToolsContext } from '@modern-js/app-tools';
+import type { AppTools } from '@modern-js/app-tools/cli-config';
+import type { CLIPluginAPI } from '@modern-js/plugin';
 import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
 export declare function writeTanstackRegisterFile(opts: {
     entries: string[];
@@ -9,7 +10,7 @@ export declare function writeTanstackRegisterFile(opts: {
     i18nRuntimeModule?: string;
 }): Promise<void>;
 export declare function writeTanstackRouterTypesForEntries(opts: {
-    appContext: AppToolsContext;
+    appContext: Pick<ReturnType<CLIPluginAPI<AppTools>['getAppContext']>, 'srcDirectory' | 'internalSrcAlias' | 'entrypoints'>;
     generatedDirName?: string;
     routesByEntry: Record<string, (NestedRouteForCli | PageRoute)[]>;
     /**
@@ -21,11 +22,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/rscRouteLayer.d.ts

@@ -0,0 +1,11 @@
+import type { AppNormalizedConfig } from '@modern-js/app-tools/cli-config';
+type BuilderPlugin = NonNullable<AppNormalizedConfig['builderPlugins']>[number];
+export declare const TANSTACK_SERVER_ROUTES_FILE = "tanstack-routes.server.js";
+type RouteLayerContext = {
+    entryNames: readonly string[];
+    internalDirectory: string;
+    rsc: AppNormalizedConfig['server']['rsc'];
+};
+/** The HTML router consumes executable components, while route data stays in Flight. */
+export declare function createTanstackRscRouteLayerPlugin(getContext: () => RouteLayerContext): BuilderPlugin;
+export {};

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/cli/tanstackTypes/source.d.ts

@@ -1,8 +1,9 @@
-import type { AppToolsContext } from '@modern-js/app-tools';
+import type { AppTools } from '@modern-js/app-tools/cli-config';
+import type { CLIPluginAPI } from '@modern-js/plugin';
 import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
 type RouteForCli = NestedRouteForCli | PageRoute;
 export declare function generateTanstackRouterTypesSourceForEntry(opts: {
-    appContext: AppToolsContext;
+    appContext: Pick<ReturnType<CLIPluginAPI<AppTools>['getAppContext']>, 'srcDirectory' | 'internalSrcAlias'>;
     entryName: string;
     generatedDirName?: string;
     routes: RouteForCli[];

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

@@ -1,6 +1,8 @@
+import type { OnRenderPreparedFn, OnRequestEndFn } from '@modern-js/plugin/runtime';
 import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type { RouterExtendsHooks } from './hooks.js';
+import type { RouterLifecycleContext } from './lifecycle.js';
 import type { RouterConfig } from './types.js';
 type TanstackRouterRuntimeConfig = {
     plugins?: TanstackRouterRuntimePlugin[];
@@ -12,6 +14,9 @@ export type TanstackRouterPluginAPI = {
     getRuntimeConfig: () => TanstackRouterRuntimeConfig;
     getHooks: () => RouterExtendsHooks;
     onBeforeRender: (listener: (context: TInternalRuntimeContext, interrupt: RuntimeInterrupt) => unknown) => void;
+    onRenderPrepared: (listener: OnRenderPreparedFn<TInternalRuntimeContext>) => void;
+    onRequestEnd: (listener: OnRequestEndFn<TInternalRuntimeContext>) => void;
+    onAfterCreateRouter: (listener: (event: RouterLifecycleContext) => void) => void;
     wrapRoot: (listener: (App: any) => any) => void;
     [key: string]: any;
 };

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/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/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

@@ -1,13 +1,13 @@
 {
   "name": "@bleedingdev/modern-js-plugin-tanstack",
   "description": "TanStack Router integration for Modern.js.",
-  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "homepage": "https://github.com/ultramodernjs/ultramodern.js#readme",
   "bugs": {
-    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+    "url": "https://github.com/ultramodernjs/ultramodern.js/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "url": "git+https://github.com/ultramodernjs/ultramodern.js.git",
     "directory": "packages/runtime/plugin-tanstack"
   },
   "license": "MIT",
@@ -18,7 +18,7 @@
     "modern.js",
     "tanstack-router"
   ],
-  "version": "3.9.0-ultramodern.9",
+  "version": "3.9.3-ultramodern.10",
   "engines": {
     "node": ">=20"
   },
@@ -94,21 +94,21 @@
     }
   },
   "dependencies": {
-    "@modern-js/i18n-runtime-extensions": "npm:@bleedingdev/modern-js-i18n-runtime-extensions@3.9.0-ultramodern.9",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.9",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.9",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.9",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.9",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.9",
+    "@modern-js/i18n-runtime-extensions": "npm:@bleedingdev/modern-js-i18n-runtime-extensions@3.9.3-ultramodern.10",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.3-ultramodern.10",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.3-ultramodern.10",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.3-ultramodern.10",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.3-ultramodern.10",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.3-ultramodern.10",
     "@swc/helpers": "^0.5.23",
-    "@tanstack/react-router": "1.170.33",
-    "@tanstack/router-core": "1.171.28"
+    "@tanstack/react-router": "1.170.44",
+    "@tanstack/router-core": "1.171.37"
   },
   "peerDependencies": {
-    "@modern-js/app-tools": "3.9.0-ultramodern.9",
-    "@modern-js/runtime": "3.9.0-ultramodern.9",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "@modern-js/app-tools": "3.9.3-ultramodern.10",
+    "@modern-js/runtime": "3.9.3-ultramodern.10",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
     "react-server-dom-rspack": "0.1.0"
   },
   "peerDependenciesMeta": {
@@ -117,20 +117,19 @@
     }
   },
   "devDependencies": {
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.9",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.9",
-    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.9",
-    "@rslib/core": "1.0.0",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.3-ultramodern.10",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.3-ultramodern.10",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.3-ultramodern.10",
+    "@rslib/core": "1.0.3",
     "@scripts/rstest-config": "2.66.0",
-    "@tanstack/history": "1.162.2",
+    "@tanstack/history": "1.162.5",
     "@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",
-    "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "@types/node": "^26.6.5",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
     "react-server-dom-rspack": "0.1.0"
   },
   "sideEffects": [
@@ -150,9 +149,16 @@
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist",
+    "src"
+  ],
   "scripts": {
     "dev": "rslib build --watch",
     "build": "rslib build",
-    "test": "rstest --passWithNoTests"
+    "test": "rstest"
+  },
+  "ultramodern": {
+    "sourceName": "@modern-js/plugin-tanstack"
   }
 }

package/src/cli/artifacts.ts

@@ -1,10 +1,17 @@
 // @effect-diagnostics asyncFunction:off nodeBuiltinImport:off strictBooleanExpressions:off processEnv:off processEnvInEffect:off
 
 import path from 'node:path';
-import type { AppToolsContext } from '@modern-js/app-tools';
+import type { AppTools } from '@modern-js/app-tools/cli-config';
+import type { CLIPluginAPI } from '@modern-js/plugin';
 import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
 import { fs } from '@modern-js/utils';
 
+import {
+  findRouteMetaFiles,
+  ROUTE_METADATA_MANIFEST_FILE_NAME,
+  ROUTE_METADATA_MANIFEST_HEADER,
+  renderRouteMetadataManifest,
+} from './routeMetadata';
 import {
   collectCanonicalRoutesForEntry,
   generateTanstackRouterTypesSourceForEntry,
@@ -108,7 +115,10 @@ export async function writeTanstackRegisterFile(opts: {
 }
 
 export async function writeTanstackRouterTypesForEntries(opts: {
-  appContext: AppToolsContext;
+  appContext: Pick<
+    ReturnType<CLIPluginAPI<AppTools>['getAppContext']>,
+    'srcDirectory' | 'internalSrcAlias' | 'entrypoints'
+  >;
   generatedDirName?: string;
   routesByEntry: Record<string, (NestedRouteForCli | PageRoute)[]>;
   /**
@@ -193,16 +203,52 @@ export async function writeTanstackRouterTypesForEntries(opts: {
 }
 
 /**
- * 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 async function writeRouteMetadataManifest(opts: {
+  appDirectory: string;
+}): Promise<void> {
+  const routesDirectory = path.join(opts.appDirectory, 'src', 'routes');
+  const manifestPath = path.join(
+    routesDirectory,
+    ROUTE_METADATA_MANIFEST_FILE_NAME,
+  );
+  const manifest = renderRouteMetadataManifest(
+    await findRouteMetaFiles(routesDirectory),
+  );
+  if (manifest !== null) {
+    await writeFileIfChanged(manifestPath, manifest);
+    return;
+  }
+  const previous = (await fs.pathExists(manifestPath))
+    ? await fs.readFile(manifestPath, 'utf-8')
+    : null;
+  // No valid manifest exists without routes (its namespace comes from them),
+  // and the app config imports it, so the app cannot load in this state.
+  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.',
+    );
+  }
+}
+
+/**
+ * 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 async function generateTanstackRouteArtifacts(opts: {
   appDirectory: string;
   version?: string;
 }): Promise<void> {
+  // The app config imports the manifest. Writing it first means a manifest
+  // that still imports a deleted route.meta.ts cannot fail the config load.
+  await writeRouteMetadataManifest(opts);
   const [{ createRunOptions }, { cli }, utils] = await Promise.all([
     import('@modern-js/app-tools/cli/run'),
     import('@modern-js/plugin/cli'),
@@ -251,5 +297,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();
 }