@remix-run/cli 0.2.0 → 0.3.0

package/src/lib/controller-ownership.ts

@@ -2,16 +2,18 @@ import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 
 import {
-  getActionOwnerCandidates,
   getControllerOwnerCandidates,
   getOwnerModuleBaseName,
   getPreferredOwnerDisplayPath,
   getRouteSubtreePath,
-  isActionFileName,
   isControllerEntryFileName,
   toDiskSegment,
 } from './controller-files.ts'
-import type { RouteOwnerKind, RouteTreeNodeKind } from './route-map.ts'
+import type { RouteTreeNodeKind } from './route-map.ts'
+
+const ACTIONS_PATH_PREFIX = 'app/actions/'
+
+export const ROOT_ROUTE_NAME = '<root>'
 
 export interface OwnershipRouteNode {
   children: OwnershipRouteNode[]
@@ -22,25 +24,24 @@ export interface OwnershipRouteNode {
 }
 
 export interface ControllerDirectoryScan {
-  actionEntryPaths: Set<string>
   controllerEntryPaths: Set<string>
-  rootDirectoryPaths: Set<string>
+  routeDirectoryPaths: Set<string>
   routeLocalFilePaths: Set<string>
 }
 
+export interface RouteDirectoryPlan {
+  directoryPath: string
+  routeName: string
+}
+
 export interface OwnedSubtreePlan {
-  alternateCandidates: string[]
-  alternateDisplayPath: string
   entryCandidates: string[]
   entryDisplayPath: string
-  kind: RouteOwnerKind
   routeName: string
   subtreePath: string
 }
 
 export interface OwnedSubtree extends OwnedSubtreePlan {
-  actualAlternatePath: string | null
-  actualAlternatePaths: string[]
   actualEntryPath: string | null
   actualEntryPaths: string[]
   claimedFilePaths: string[]
@@ -48,9 +49,9 @@ export interface OwnedSubtree extends OwnedSubtreePlan {
 }
 
 export interface ControllerOwnership {
-  orphanActionPaths: string[]
   orphanControllerPaths: string[]
   orphanRouteDirectoryPaths: string[]
+  routeDirectories: RouteDirectoryPlan[]
   scan: ControllerDirectoryScan
   subtrees: OwnedSubtree[]
 }
@@ -60,13 +61,14 @@ export async function inspectControllerOwnership(
   tree: OwnershipRouteNode[],
 ): Promise<ControllerOwnership> {
   let subtreePlans = buildOwnedSubtrees(tree)
+  let routeDirectories = buildRouteDirectories(tree)
   let scan = await scanControllersDirectory(appRoot)
   let subtrees = applyScanToSubtrees(subtreePlans, scan)
 
   return {
-    orphanActionPaths: getOrphanActionPaths(subtreePlans, scan),
     orphanControllerPaths: getOrphanControllerPaths(subtreePlans, scan),
-    orphanRouteDirectoryPaths: getOrphanRouteDirectoryPaths(subtreePlans, scan),
+    orphanRouteDirectoryPaths: getOrphanRouteDirectoryPaths(routeDirectories, scan),
+    routeDirectories,
     scan,
     subtrees,
   }
@@ -77,52 +79,69 @@ export function buildOwnedSubtrees(
   parentSegments: string[] = [],
   subtrees: OwnedSubtreePlan[] = [],
 ): OwnedSubtreePlan[] {
-  for (let node of tree) {
-    let segments = [...parentSegments, toDiskSegment(node.key)]
+  if (
+    parentSegments.length === 0 &&
+    subtrees.length === 0 &&
+    tree.some((node) => node.kind === 'route')
+  ) {
+    addSubtreePlan(ROOT_ROUTE_NAME, [], subtrees)
+  }
 
-    if (node.kind === 'group') {
-      let alternateCandidates = getActionOwnerCandidates(segments)
-      let entryCandidates = getControllerOwnerCandidates(segments)
-
-      subtrees.push({
-        alternateCandidates,
-        alternateDisplayPath: getPreferredOwnerDisplayPath(alternateCandidates),
-        entryCandidates,
-        entryDisplayPath: getPreferredOwnerDisplayPath(entryCandidates),
-        kind: 'controller',
-        routeName: node.name,
-        subtreePath: getRouteSubtreePath(segments),
-      })
-      buildOwnedSubtrees(node.children, segments, subtrees)
+  for (let node of tree) {
+    if (node.kind !== 'group') {
       continue
     }
 
-    if (parentSegments.length > 0) {
-      continue
+    let segments = [...parentSegments, toDiskSegment(node.key)]
+    if (hasDirectRouteLeaf(node.children)) {
+      addSubtreePlan(node.name, segments, subtrees)
     }
+    buildOwnedSubtrees(node.children, segments, subtrees)
+  }
+
+  return subtrees
+}
 
-    let alternateCandidates = getControllerOwnerCandidates(segments)
-    let entryCandidates = getActionOwnerCandidates(segments)
+export function buildRouteDirectories(
+  tree: OwnershipRouteNode[],
+  parentSegments: string[] = [],
+  directories: RouteDirectoryPlan[] = [],
+): RouteDirectoryPlan[] {
+  for (let node of tree) {
+    if (node.kind !== 'group') {
+      continue
+    }
 
-    subtrees.push({
-      alternateCandidates,
-      alternateDisplayPath: getPreferredOwnerDisplayPath(alternateCandidates),
-      entryCandidates,
-      entryDisplayPath: getPreferredOwnerDisplayPath(entryCandidates),
-      kind: 'action',
+    let segments = [...parentSegments, toDiskSegment(node.key)]
+    directories.push({
+      directoryPath: getRouteSubtreePath(segments),
       routeName: node.name,
-      subtreePath: getRouteSubtreePath(segments),
     })
+    buildRouteDirectories(node.children, segments, directories)
   }
 
-  return subtrees
+  return directories
+}
+
+function hasDirectRouteLeaf(tree: OwnershipRouteNode[]): boolean {
+  return tree.some((node) => node.kind === 'route')
+}
+
+function addSubtreePlan(routeName: string, segments: string[], subtrees: OwnedSubtreePlan[]): void {
+  let entryCandidates = getControllerOwnerCandidates(segments)
+
+  subtrees.push({
+    entryCandidates,
+    entryDisplayPath: getPreferredOwnerDisplayPath(entryCandidates),
+    routeName,
+    subtreePath: getRouteSubtreePath(segments),
+  })
 }
 
 async function scanControllersDirectory(appRoot: string): Promise<ControllerDirectoryScan> {
-  let controllersDir = path.join(appRoot, 'app', 'controllers')
+  let actionsDir = path.join(appRoot, 'app', 'actions')
   let controllerEntryPaths = new Set<string>()
-  let actionEntryPaths = new Set<string>()
-  let rootDirectoryPaths = new Set<string>()
+  let routeDirectoryPaths = new Set<string>()
   let routeLocalFilePaths = new Set<string>()
 
   async function walk(currentDir: string, isRoot: boolean): Promise<void> {
@@ -143,10 +162,7 @@ async function scanControllersDirectory(appRoot: string): Promise<ControllerDire
       let relativePath = normalizeRelativePath(path.relative(appRoot, entryPath))
 
       if (entry.isDirectory()) {
-        if (isRoot) {
-          rootDirectoryPaths.add(relativePath)
-        }
-
+        routeDirectoryPaths.add(relativePath)
         await walk(entryPath, false)
         continue
       }
@@ -160,23 +176,17 @@ async function scanControllersDirectory(appRoot: string): Promise<ControllerDire
         continue
       }
 
-      if (isRoot && isActionCandidate(entry.name)) {
-        actionEntryPaths.add(relativePath)
-        continue
-      }
-
-      if (!isRoot && isRouteLocalFileName(entry.name)) {
+      if (isRouteLocalFileName(entry.name)) {
         routeLocalFilePaths.add(relativePath)
       }
     }
   }
 
-  await walk(controllersDir, true)
+  await walk(actionsDir, true)
 
   return {
-    actionEntryPaths,
     controllerEntryPaths,
-    rootDirectoryPaths,
+    routeDirectoryPaths,
     routeLocalFilePaths,
   }
 }
@@ -192,17 +202,10 @@ function applyScanToSubtrees(
   let claimedContentPaths = claimFilesToDeepestSubtree(getNestedContentPaths(scan), subtreePlans)
 
   return subtreePlans.map((subtree) => {
-    let actualAlternatePaths = findOwnerPaths(
-      scan,
-      invertOwnerKind(subtree.kind),
-      subtree.alternateCandidates,
-    )
-    let actualEntryPaths = findOwnerPaths(scan, subtree.kind, subtree.entryCandidates)
+    let actualEntryPaths = findOwnerPaths(scan, subtree.entryCandidates)
 
     return {
       ...subtree,
-      actualAlternatePath: actualAlternatePaths[0] ?? null,
-      actualAlternatePaths,
       actualEntryPath: actualEntryPaths[0] ?? null,
       actualEntryPaths,
       claimedFilePaths: claimedContentPaths.get(subtree.routeName) ?? [],
@@ -253,61 +256,30 @@ function claimFilesToDeepestSubtree(
   return claims
 }
 
-function getOrphanActionPaths(
-  subtreePlans: OwnedSubtreePlan[],
-  scan: ControllerDirectoryScan,
-): string[] {
-  let expectedActionPaths = new Set(
-    subtreePlans
-      .filter((subtree) => subtree.kind === 'action')
-      .flatMap((subtree) => subtree.entryCandidates),
-  )
-  let alternateActionPaths = new Set(
-    subtreePlans
-      .filter((subtree) => subtree.kind === 'controller')
-      .flatMap((subtree) => subtree.alternateCandidates),
-  )
-
-  return [...scan.actionEntryPaths]
-    .filter((filePath) => !expectedActionPaths.has(filePath))
-    .filter((filePath) => !alternateActionPaths.has(filePath))
-    .sort()
-}
-
 function getOrphanControllerPaths(
   subtreePlans: OwnedSubtreePlan[],
   scan: ControllerDirectoryScan,
 ): string[] {
-  let expectedControllerPaths = new Set(
-    subtreePlans
-      .filter((subtree) => subtree.kind === 'controller')
-      .flatMap((subtree) => subtree.entryCandidates),
-  )
-  let alternateControllerPaths = new Set(
-    subtreePlans
-      .filter((subtree) => subtree.kind === 'action')
-      .flatMap((subtree) => subtree.alternateCandidates),
-  )
+  let expectedControllerPaths = new Set(subtreePlans.flatMap((subtree) => subtree.entryCandidates))
 
   return [...scan.controllerEntryPaths]
     .filter((filePath) => !expectedControllerPaths.has(filePath))
-    .filter((filePath) => !alternateControllerPaths.has(filePath))
     .sort()
 }
 
 function getOrphanRouteDirectoryPaths(
-  subtreePlans: OwnedSubtreePlan[],
+  routeDirectories: RouteDirectoryPlan[],
   scan: ControllerDirectoryScan,
 ): string[] {
-  let expectedRootDirectories = new Set(
-    subtreePlans.map((subtree) => getTopLevelSubtreePath(subtree.subtreePath)),
+  let expectedRouteDirectories = new Set(
+    routeDirectories.map((routeDirectory) => routeDirectory.directoryPath),
   )
   let actualControllerDirectories = [...scan.controllerEntryPaths].map((controllerPath) =>
     normalizeRelativePath(path.dirname(controllerPath)),
   )
 
-  return [...scan.rootDirectoryPaths]
-    .filter((directoryPath) => !expectedRootDirectories.has(directoryPath))
+  return [...scan.routeDirectoryPaths]
+    .filter((directoryPath) => !expectedRouteDirectories.has(directoryPath))
     .filter(
       (directoryPath) =>
         !actualControllerDirectories.some((controllerPath) =>
@@ -317,24 +289,6 @@ function getOrphanRouteDirectoryPaths(
     .sort()
 }
 
-function hasOwnerPath(
-  scan: ControllerDirectoryScan,
-  kind: RouteOwnerKind,
-  filePath: string,
-): boolean {
-  return kind === 'action'
-    ? scan.actionEntryPaths.has(filePath)
-    : scan.controllerEntryPaths.has(filePath)
-}
-
-function invertOwnerKind(kind: RouteOwnerKind): RouteOwnerKind {
-  return kind === 'action' ? 'controller' : 'action'
-}
-
-function isActionCandidate(fileName: string): boolean {
-  return isActionFileName(fileName)
-}
-
 function isRouteLocalFileName(fileName: string): boolean {
   let baseName = getOwnerModuleBaseName(fileName)
 
@@ -346,23 +300,11 @@ function isRouteLocalFileName(fileName: string): boolean {
   )
 }
 
-function findOwnerPath(
-  scan: ControllerDirectoryScan,
-  kind: RouteOwnerKind,
-  candidatePaths: string[],
-): string | null {
-  return findOwnerPaths(scan, kind, candidatePaths)[0] ?? null
-}
-
-function findOwnerPaths(
-  scan: ControllerDirectoryScan,
-  kind: RouteOwnerKind,
-  candidatePaths: string[],
-): string[] {
+function findOwnerPaths(scan: ControllerDirectoryScan, candidatePaths: string[]): string[] {
   let existingPaths: string[] = []
 
   for (let candidatePath of candidatePaths) {
-    if (hasOwnerPath(scan, kind, candidatePath)) {
+    if (scan.controllerEntryPaths.has(candidatePath)) {
       existingPaths.push(candidatePath)
     }
   }
@@ -372,8 +314,8 @@ function findOwnerPaths(
 
 function isNestedControllerPath(filePath: string): boolean {
   return (
-    filePath.startsWith('app/controllers/') &&
-    filePath.slice('app/controllers/'.length).includes('/')
+    filePath.startsWith(ACTIONS_PATH_PREFIX) &&
+    filePath.slice(ACTIONS_PATH_PREFIX.length).includes('/')
   )
 }
 
@@ -387,11 +329,6 @@ function isDirectoryWithinDirectory(directoryPath: string, parentDirectoryPath:
   )
 }
 
-function getTopLevelSubtreePath(subtreePath: string): string {
-  let subtreeSegments = subtreePath.slice('app/controllers/'.length).split('/')
-  return getRouteSubtreePath([subtreeSegments[0]])
-}
-
 function normalizeRelativePath(filePath: string): string {
   return filePath.split(path.sep).join('/')
 }

package/src/lib/doctor/controller-findings.ts

@@ -1,4 +1,8 @@
-import type { ControllerOwnership, OwnedSubtree } from '../controller-ownership.ts'
+import {
+  ROOT_ROUTE_NAME,
+  type ControllerOwnership,
+  type OwnedSubtree,
+} from '../controller-ownership.ts'
 import type { DoctorFinding, DoctorFixPlan } from './types.ts'
 
 export function getControllerFindings(
@@ -7,26 +11,19 @@ export function getControllerFindings(
 ): DoctorFinding[] {
   return [
     ...getSubtreeFindings(ownership.subtrees, fixPlans),
-    ...ownership.orphanActionPaths.map((actualPath) => ({
-      actualPath,
-      code: 'orphan-action' as const,
-      message: `Standalone action ${actualPath} does not match any top-level route.`,
-      severity: 'warn' as const,
-      suite: 'controllers' as const,
-    })),
     ...ownership.orphanControllerPaths.map((actualPath) => ({
       actualPath,
       code: 'orphan-controller' as const,
-      message: `Controller ${actualPath} does not match any route group.`,
+      message: `Action controller ${actualPath} does not match any route map.`,
       severity: 'warn' as const,
-      suite: 'controllers' as const,
+      suite: 'actions' as const,
     })),
     ...ownership.orphanRouteDirectoryPaths.map((actualPath) => ({
       actualPath,
       code: 'orphan-route-directory' as const,
-      message: `Directory ${actualPath} does not match any route subtree.`,
+      message: `Directory ${actualPath} does not match any route-map key path.`,
       severity: 'warn' as const,
-      suite: 'controllers' as const,
+      suite: 'actions' as const,
     })),
   ]
 }
@@ -38,71 +35,22 @@ function getSubtreeFindings(subtrees: OwnedSubtree[], fixPlans: DoctorFixPlan[])
   )
 
   for (let subtree of subtrees) {
-    let actualEntryPath = subtree.actualEntryPath ?? undefined
-    let actualAlternatePath = subtree.actualAlternatePath ?? undefined
+    let routeMapName = formatRouteMapName(subtree.routeName)
 
     if (subtree.actualEntryPaths.length > 1) {
       findings.push({
         actualPath: subtree.actualEntryPaths[0],
         code: 'duplicate-owner-file',
         expectedPath: subtree.entryDisplayPath,
-        message: `Route "${subtree.routeName}" has multiple ${subtree.kind} files: ${subtree.actualEntryPaths.join(', ')}. Keep only one ${subtree.kind} owner file.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (subtree.actualAlternatePaths.length > 1) {
-      let alternateKind = subtree.kind === 'action' ? 'controller' : 'action'
-
-      findings.push({
-        actualPath: subtree.actualAlternatePaths[0],
-        code: 'duplicate-owner-file',
-        expectedPath: subtree.entryDisplayPath,
-        message: `Route "${subtree.routeName}" has multiple ${alternateKind} files: ${subtree.actualAlternatePaths.join(', ')}. Keep only one ${alternateKind} owner file.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (actualEntryPath != null && actualAlternatePath != null) {
-      findings.push({
-        actualPath: actualAlternatePath,
-        code: 'ambiguous-owner',
-        expectedPath: actualEntryPath,
-        message:
-          subtree.kind === 'action'
-            ? `Route "${subtree.routeName}" has both action ${actualEntryPath} and controller ${actualAlternatePath}.`
-            : `Route "${subtree.routeName}" has both controller ${actualEntryPath} and standalone action ${actualAlternatePath}.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (actualAlternatePath != null) {
-      findings.push({
-        actualPath: actualAlternatePath,
-        code: 'wrong-owner-kind',
-        expectedPath: subtree.entryDisplayPath,
-        message:
-          subtree.kind === 'action'
-            ? `Route "${subtree.routeName}" expects action ${subtree.entryDisplayPath}, but found controller ${actualAlternatePath}.`
-            : `Route "${subtree.routeName}" expects controller ${subtree.entryDisplayPath}, but found standalone action ${actualAlternatePath}.`,
-        fixable: fixableFindingKeys.has(`wrong-owner-kind:${subtree.routeName}`),
+        message: `${routeMapName} has multiple action controller files: ${subtree.actualEntryPaths.join(', ')}. Keep only one controller owner file.`,
         routeName: subtree.routeName,
         severity: 'warn',
-        suite: 'controllers',
+        suite: 'actions',
       })
       continue
     }
 
-    if (subtree.kind === 'controller' && subtree.actualEntryPath == null) {
+    if (subtree.actualEntryPath == null) {
       let code =
         subtree.claimedFilePaths.length > 0
           ? ('incomplete-controller' as const)
@@ -115,43 +63,18 @@ function getSubtreeFindings(subtrees: OwnedSubtree[], fixPlans: DoctorFixPlan[])
         fixable: fixableFindingKeys.has(`${code}:${subtree.routeName}`),
         message:
           subtree.claimedFilePaths.length > 0
-            ? `Route "${subtree.routeName}" has files under ${subtree.subtreePath}, but is missing controller ${subtree.entryDisplayPath}.`
-            : `Route "${subtree.routeName}" is missing controller ${subtree.entryDisplayPath}.`,
+            ? `${routeMapName} has files under ${subtree.subtreePath}, but is missing action controller ${subtree.entryDisplayPath}.`
+            : `${routeMapName} is missing action controller ${subtree.entryDisplayPath}.`,
         routeName: subtree.routeName,
         severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (subtree.kind === 'action' && subtree.claimedFilePaths.length > 0) {
-      findings.push({
-        actualPath: subtree.subtreePath,
-        code: 'promotion-drift',
-        expectedPath: actualEntryPath ?? subtree.entryDisplayPath,
-        message:
-          actualEntryPath == null
-            ? `Route "${subtree.routeName}" has files under ${subtree.subtreePath}, but is still expected to use action ${subtree.entryDisplayPath}. Promote it to controller ${subtree.alternateDisplayPath} or move the files back into ${subtree.entryDisplayPath}.`
-            : `Route "${subtree.routeName}" uses action ${actualEntryPath}, but also has files under ${subtree.subtreePath}. Promote it to controller ${subtree.alternateDisplayPath} or keep the route in ${actualEntryPath}.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (subtree.actualEntryPath == null) {
-      findings.push({
-        code: 'missing-owner',
-        expectedPath: subtree.entryDisplayPath,
-        fixable: fixableFindingKeys.has(`missing-owner:${subtree.routeName}`),
-        message: `Route "${subtree.routeName}" is missing action ${subtree.entryDisplayPath}.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
+        suite: 'actions',
       })
     }
   }
 
   return findings
 }
+
+function formatRouteMapName(routeName: string): string {
+  return routeName === ROOT_ROUTE_NAME ? 'Root route map' : `Route map "${routeName}"`
+}

package/src/lib/doctor/controller-fix-plans.ts

@@ -11,7 +11,8 @@ import type {
   OwnedSubtree,
   OwnershipRouteNode,
 } from '../controller-ownership.ts'
-import { renderActionPlaceholder, renderControllerPlaceholder } from './controller-placeholders.ts'
+import { ROOT_ROUTE_NAME } from '../controller-ownership.ts'
+import { renderControllerPlaceholder } from './controller-placeholders.ts'
 import type { DoctorFixPlan } from './types.ts'
 
 const OWNER_EXTENSION_PRIORITY: OwnerFileExtension[] = ['.tsx', '.ts', '.jsx', '.js']
@@ -57,10 +58,7 @@ export async function getControllerFixPlans(
       continue
     }
 
-    let contents =
-      subtree.kind === 'action'
-        ? renderActionPlaceholder(routeNode, entryPath)
-        : renderControllerPlaceholder(routeNode, entryPath, resolvedEntryPathByRouteName)
+    let contents = renderControllerPlaceholder(routeNode, entryPath)
 
     fixPlans.push({
       code,
@@ -68,7 +66,7 @@ export async function getControllerFixPlans(
       kind: 'create-file',
       path: entryPath,
       routeName: subtree.routeName,
-      suite: 'controllers',
+      suite: 'actions',
     })
   }
 
@@ -76,7 +74,7 @@ export async function getControllerFixPlans(
 }
 
 function getFixCodeForSubtree(subtree: OwnedSubtree): DoctorFixPlan['code'] | null {
-  if (subtree.actualEntryPaths.length > 1 || subtree.actualAlternatePaths.length > 1) {
+  if (subtree.actualEntryPaths.length > 1) {
     return null
   }
 
@@ -84,19 +82,7 @@ function getFixCodeForSubtree(subtree: OwnedSubtree): DoctorFixPlan['code'] | nu
     return null
   }
 
-  if (subtree.actualAlternatePath != null) {
-    return 'wrong-owner-kind'
-  }
-
-  if (subtree.kind === 'controller') {
-    return subtree.claimedFilePaths.length > 0 ? 'incomplete-controller' : 'missing-owner'
-  }
-
-  if (subtree.claimedFilePaths.length > 0) {
-    return null
-  }
-
-  return 'missing-owner'
+  return subtree.claimedFilePaths.length > 0 ? 'incomplete-controller' : 'missing-owner'
 }
 
 function inferOwnerExtension(
@@ -109,15 +95,7 @@ function inferOwnerExtension(
     return subtreeExtension
   }
 
-  let alternateExtension = getMostCommonOwnerExtension(subtree.actualAlternatePaths)
-  if (alternateExtension != null) {
-    return alternateExtension
-  }
-
-  let projectExtension = getMostCommonOwnerExtension([
-    ...ownership.scan.actionEntryPaths,
-    ...ownership.scan.controllerEntryPaths,
-  ])
+  let projectExtension = getMostCommonOwnerExtension([...ownership.scan.controllerEntryPaths])
   if (projectExtension != null) {
     return projectExtension
   }
@@ -157,6 +135,12 @@ function getMostCommonOwnerExtension(filePaths: string[]): OwnerFileExtension |
 
 function getRouteNodesByName(tree: OwnershipRouteNode[]): Map<string, OwnershipRouteNode> {
   let routeNodesByName = new Map<string, OwnershipRouteNode>()
+  routeNodesByName.set(ROOT_ROUTE_NAME, {
+    children: tree,
+    key: ROOT_ROUTE_NAME,
+    kind: 'group',
+    name: ROOT_ROUTE_NAME,
+  })
 
   function visit(nodes: OwnershipRouteNode[]): void {
     for (let node of nodes) {