@tanstack/router-generator 1.163.3 → 1.163.5

package/src/filesystem/physical/getRouteNodes.ts

@@ -132,6 +132,11 @@ export async function getRouteNodes(
           node.originalRoutePath = `/${dir}${node.originalRoutePath}`
         }
         node.filePath = filePath
+        // Virtual subtree nodes (from __virtual.ts) are embedded in a
+        // physical directory tree. They should use path-based parent
+        // inference, not the explicit virtual parent tracking. Clear any
+        // _virtualParentRoutePath that was set at construction time.
+        delete node._virtualParentRoutePath
       })
 
       routeNodes.push(...virtualRouteNodes)

package/src/filesystem/virtual/getRouteNodes.ts

@@ -26,25 +26,12 @@ function ensureLeadingUnderScore(id: string) {
   return `_${id}`
 }
 
-function flattenTree(
-  node: RouteNode,
-  parentRoutePath?: string,
-): Array<RouteNode> {
-  // Store the explicit parent's routePath for virtual routes.
-  // This prevents the generator from auto-nesting based on path matching (#5822).
-  //
-  // Skip when the parent is the synthetic virtual root (`/${rootPathId}`).
-  // Root-level nodes should use path-based inference to find their parent.
-  const isRootParent = parentRoutePath === `/${rootPathId}`
-  if (parentRoutePath !== undefined && !isRootParent) {
-    node._virtualParentRoutePath = parentRoutePath
-  }
-
+function flattenTree(node: RouteNode): Array<RouteNode> {
   const result = [node]
 
   if (node.children) {
     for (const child of node.children) {
-      result.push(...flattenTree(child, node.routePath))
+      result.push(...flattenTree(child))
     }
   }
   delete node.children
@@ -194,6 +181,7 @@ export async function getRouteNodesRecursive(
         return { filePath, variableName, fullPath }
       }
       const parentRoutePath = removeTrailingSlash(parent?.routePath ?? '/')
+      const virtualParentRoutePath = parent?.routePath ?? `/${rootPathId}`
 
       switch (node.type) {
         case 'index': {
@@ -205,6 +193,7 @@ export async function getRouteNodesRecursive(
             variableName,
             routePath,
             _fsRouteType: 'static',
+            _virtualParentRoutePath: virtualParentRoutePath,
           } satisfies RouteNode
         }
 
@@ -230,6 +219,7 @@ export async function getRouteNodesRecursive(
               routePath,
               originalRoutePath,
               _fsRouteType: 'static',
+              _virtualParentRoutePath: virtualParentRoutePath,
             }
           } else {
             routeNode = {
@@ -240,6 +230,7 @@ export async function getRouteNodesRecursive(
               originalRoutePath,
               isVirtual: true,
               _fsRouteType: 'static',
+              _virtualParentRoutePath: virtualParentRoutePath,
             }
           }
 
@@ -288,6 +279,7 @@ export async function getRouteNodesRecursive(
             routePath,
             originalRoutePath,
             _fsRouteType: 'pathless_layout',
+            _virtualParentRoutePath: virtualParentRoutePath,
           }
 
           if (node.children !== undefined) {

package/src/generator.ts

@@ -1470,17 +1470,20 @@ ${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${getResolved
 
     // Virtual routes may have an explicit parent from virtual config.
     // If we can find that exact parent, use it to prevent auto-nesting siblings
-    // based on path prefix matching. If the explicit parent is not found (e.g.,
-    // it was a virtual file-less route that got filtered out), keep using the
-    // path-based parent we already computed above.
+    // based on path prefix matching (#5822, #5431).
     if (node._virtualParentRoutePath !== undefined) {
-      const explicitParent =
-        acc.routeNodesByPath.get(node._virtualParentRoutePath) ??
-        prefixMap.get(node._virtualParentRoutePath)
+      const explicitParent = acc.routeNodesByPath.get(
+        node._virtualParentRoutePath,
+      )
       if (explicitParent) {
         parentRoute = explicitParent
+      } else if (node._virtualParentRoutePath === `/${rootPathId}`) {
+        // The explicit parent is the root route (handled separately).
+        // Override path-based inference so this node stays at root level.
+        parentRoute = null
       }
-      // If not found, parentRoute stays as the path-based result (fallback)
+      // Otherwise the explicit parent was a virtual file-less route that got
+      // filtered out. Fall back to the path-based parentRoute already computed.
     }
 
     if (parentRoute) node.parent = parentRoute

package/src/types.ts

@@ -15,7 +15,7 @@ export type RouteNode = {
   createFileRouteProps?: Set<string>
   /**
    * For virtual routes: the routePath of the explicit parent from virtual config.
-   * Used to prevent auto-nesting siblings based on path prefix matching (#5822).
+   * Used to prevent auto-nesting siblings based on path prefix matching (#5822, #5431).
    * Falls back to path-based inference if the explicit parent is not found
    * (e.g., when the parent is a virtual file-less route that gets filtered out).
    */