@remix-run/cli 0.2.0 → 0.3.0

package/dist/lib/controller-ownership.js

@@ -1,58 +1,69 @@
 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.js";
+import { getControllerOwnerCandidates, getOwnerModuleBaseName, getPreferredOwnerDisplayPath, getRouteSubtreePath, isControllerEntryFileName, toDiskSegment, } from "./controller-files.js";
+const ACTIONS_PATH_PREFIX = 'app/actions/';
+export const ROOT_ROUTE_NAME = '<root>';
 export async function inspectControllerOwnership(appRoot, tree) {
     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,
     };
 }
 export function buildOwnedSubtrees(tree, parentSegments = [], subtrees = []) {
+    if (parentSegments.length === 0 &&
+        subtrees.length === 0 &&
+        tree.some((node) => node.kind === 'route')) {
+        addSubtreePlan(ROOT_ROUTE_NAME, [], subtrees);
+    }
     for (let node of tree) {
-        let segments = [...parentSegments, toDiskSegment(node.key)];
-        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);
+        if (node.kind !== 'group') {
             continue;
         }
-        if (parentSegments.length > 0) {
+        let segments = [...parentSegments, toDiskSegment(node.key)];
+        if (hasDirectRouteLeaf(node.children)) {
+            addSubtreePlan(node.name, segments, subtrees);
+        }
+        buildOwnedSubtrees(node.children, segments, subtrees);
+    }
+    return subtrees;
+}
+export function buildRouteDirectories(tree, parentSegments = [], directories = []) {
+    for (let node of tree) {
+        if (node.kind !== 'group') {
             continue;
         }
-        let alternateCandidates = getControllerOwnerCandidates(segments);
-        let entryCandidates = getActionOwnerCandidates(segments);
-        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) {
+    return tree.some((node) => node.kind === 'route');
+}
+function addSubtreePlan(routeName, segments, subtrees) {
+    let entryCandidates = getControllerOwnerCandidates(segments);
+    subtrees.push({
+        entryCandidates,
+        entryDisplayPath: getPreferredOwnerDisplayPath(entryCandidates),
+        routeName,
+        subtreePath: getRouteSubtreePath(segments),
+    });
 }
 async function scanControllersDirectory(appRoot) {
-    let controllersDir = path.join(appRoot, 'app', 'controllers');
+    let actionsDir = path.join(appRoot, 'app', 'actions');
     let controllerEntryPaths = new Set();
-    let actionEntryPaths = new Set();
-    let rootDirectoryPaths = new Set();
+    let routeDirectoryPaths = new Set();
     let routeLocalFilePaths = new Set();
     async function walk(currentDir, isRoot) {
         let entries;
@@ -70,9 +81,7 @@ async function scanControllersDirectory(appRoot) {
             let entryPath = path.join(currentDir, entry.name);
             let relativePath = normalizeRelativePath(path.relative(appRoot, entryPath));
             if (entry.isDirectory()) {
-                if (isRoot) {
-                    rootDirectoryPaths.add(relativePath);
-                }
+                routeDirectoryPaths.add(relativePath);
                 await walk(entryPath, false);
                 continue;
             }
@@ -83,20 +92,15 @@ async function scanControllersDirectory(appRoot) {
                 controllerEntryPaths.add(relativePath);
                 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,
     };
 }
@@ -104,12 +108,9 @@ function applyScanToSubtrees(subtreePlans, scan) {
     let claimedRouteLocalPaths = claimFilesToDeepestSubtree([...scan.routeLocalFilePaths], subtreePlans);
     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) ?? [],
@@ -143,49 +144,20 @@ function claimFilesToDeepestSubtree(filePaths, subtreePlans) {
     }
     return claims;
 }
-function getOrphanActionPaths(subtreePlans, scan) {
-    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, scan) {
-    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, scan) {
-    let expectedRootDirectories = new Set(subtreePlans.map((subtree) => getTopLevelSubtreePath(subtree.subtreePath)));
+function getOrphanRouteDirectoryPaths(routeDirectories, scan) {
+    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) => isDirectoryWithinDirectory(controllerPath, directoryPath)))
         .sort();
 }
-function hasOwnerPath(scan, kind, filePath) {
-    return kind === 'action'
-        ? scan.actionEntryPaths.has(filePath)
-        : scan.controllerEntryPaths.has(filePath);
-}
-function invertOwnerKind(kind) {
-    return kind === 'action' ? 'controller' : 'action';
-}
-function isActionCandidate(fileName) {
-    return isActionFileName(fileName);
-}
 function isRouteLocalFileName(fileName) {
     let baseName = getOwnerModuleBaseName(fileName);
     return (baseName != null &&
@@ -193,21 +165,18 @@ function isRouteLocalFileName(fileName) {
         !baseName.endsWith('.test') &&
         !baseName.endsWith('.spec'));
 }
-function findOwnerPath(scan, kind, candidatePaths) {
-    return findOwnerPaths(scan, kind, candidatePaths)[0] ?? null;
-}
-function findOwnerPaths(scan, kind, candidatePaths) {
+function findOwnerPaths(scan, candidatePaths) {
     let existingPaths = [];
     for (let candidatePath of candidatePaths) {
-        if (hasOwnerPath(scan, kind, candidatePath)) {
+        if (scan.controllerEntryPaths.has(candidatePath)) {
             existingPaths.push(candidatePath);
         }
     }
     return existingPaths;
 }
 function isNestedControllerPath(filePath) {
-    return (filePath.startsWith('app/controllers/') &&
-        filePath.slice('app/controllers/'.length).includes('/'));
+    return (filePath.startsWith(ACTIONS_PATH_PREFIX) &&
+        filePath.slice(ACTIONS_PATH_PREFIX.length).includes('/'));
 }
 function isWithinDirectory(filePath, directoryPath) {
     return filePath.startsWith(`${directoryPath}/`);
@@ -215,10 +184,6 @@ function isWithinDirectory(filePath, directoryPath) {
 function isDirectoryWithinDirectory(directoryPath, parentDirectoryPath) {
     return (directoryPath === parentDirectoryPath || isWithinDirectory(directoryPath, parentDirectoryPath));
 }
-function getTopLevelSubtreePath(subtreePath) {
-    let subtreeSegments = subtreePath.slice('app/controllers/'.length).split('/');
-    return getRouteSubtreePath([subtreeSegments[0]]);
-}
 function normalizeRelativePath(filePath) {
     return filePath.split(path.sep).join('/');
 }

package/dist/lib/doctor/controller-findings.d.ts

@@ -1,4 +1,4 @@
-import type { ControllerOwnership } from '../controller-ownership.ts';
+import { type ControllerOwnership } from '../controller-ownership.ts';
 import type { DoctorFinding, DoctorFixPlan } from './types.ts';
 export declare function getControllerFindings(ownership: ControllerOwnership, fixPlans: DoctorFixPlan[]): DoctorFinding[];
 //# sourceMappingURL=controller-findings.d.ts.map

package/dist/lib/doctor/controller-findings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller-findings.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controller-findings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAgB,MAAM,4BAA4B,CAAA;AACnF,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE9D,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,mBAAmB,EAC9B,QAAQ,EAAE,aAAa,EAAE,GACxB,aAAa,EAAE,CAyBjB"}
+{"version":3,"file":"controller-findings.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controller-findings.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE9D,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,mBAAmB,EAC9B,QAAQ,EAAE,aAAa,EAAE,GACxB,aAAa,EAAE,CAkBjB"}

package/dist/lib/doctor/controller-findings.js

@@ -1,26 +1,20 @@
+import { ROOT_ROUTE_NAME, } from "../controller-ownership.js";
 export function getControllerFindings(ownership, fixPlans) {
     return [
         ...getSubtreeFindings(ownership.subtrees, fixPlans),
-        ...ownership.orphanActionPaths.map((actualPath) => ({
-            actualPath,
-            code: 'orphan-action',
-            message: `Standalone action ${actualPath} does not match any top-level route.`,
-            severity: 'warn',
-            suite: 'controllers',
-        })),
         ...ownership.orphanControllerPaths.map((actualPath) => ({
             actualPath,
             code: 'orphan-controller',
-            message: `Controller ${actualPath} does not match any route group.`,
+            message: `Action controller ${actualPath} does not match any route map.`,
             severity: 'warn',
-            suite: 'controllers',
+            suite: 'actions',
         })),
         ...ownership.orphanRouteDirectoryPaths.map((actualPath) => ({
             actualPath,
             code: 'orphan-route-directory',
-            message: `Directory ${actualPath} does not match any route subtree.`,
+            message: `Directory ${actualPath} does not match any route-map key path.`,
             severity: 'warn',
-            suite: 'controllers',
+            suite: 'actions',
         })),
     ];
 }
@@ -28,63 +22,20 @@ function getSubtreeFindings(subtrees, fixPlans) {
     let findings = [];
     let fixableFindingKeys = new Set(fixPlans.map((fixPlan) => `${fixPlan.code}:${fixPlan.routeName ?? ''}`));
     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'
                 : 'missing-owner';
@@ -94,39 +45,16 @@ function getSubtreeFindings(subtrees, fixPlans) {
                 expectedPath: subtree.entryDisplayPath,
                 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}.`,
-                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}.`,
+                    ? `${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',
+                suite: 'actions',
             });
         }
     }
     return findings;
 }
+function formatRouteMapName(routeName) {
+    return routeName === ROOT_ROUTE_NAME ? 'Root route map' : `Route map "${routeName}"`;
+}

package/dist/lib/doctor/controller-fix-plans.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller-fix-plans.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controller-fix-plans.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,mBAAmB,EAEnB,kBAAkB,EACnB,MAAM,4BAA4B,CAAA;AAEnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAI/C,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,kBAAkB,EAAE,EAC1B,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,aAAa,EAAE,CAAC,CAqD1B"}
+{"version":3,"file":"controller-fix-plans.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controller-fix-plans.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,mBAAmB,EAEnB,kBAAkB,EACnB,MAAM,4BAA4B,CAAA;AAGnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAI/C,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,kBAAkB,EAAE,EAC1B,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,aAAa,EAAE,CAAC,CAkD1B"}

package/dist/lib/doctor/controller-fix-plans.js

@@ -1,7 +1,8 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { getOwnerCandidateForExtension, getOwnerFileExtension, } from "../controller-files.js";
-import { renderActionPlaceholder, renderControllerPlaceholder } from "./controller-placeholders.js";
+import { ROOT_ROUTE_NAME } from "../controller-ownership.js";
+import { renderControllerPlaceholder } from "./controller-placeholders.js";
 const OWNER_EXTENSION_PRIORITY = ['.tsx', '.ts', '.jsx', '.js'];
 export async function getControllerFixPlans(appRoot, tree, ownership) {
     let routeNodesByName = getRouteNodesByName(tree);
@@ -31,51 +32,33 @@ export async function getControllerFixPlans(appRoot, tree, ownership) {
         if (routeNode == null || entryPath == null) {
             continue;
         }
-        let contents = subtree.kind === 'action'
-            ? renderActionPlaceholder(routeNode, entryPath)
-            : renderControllerPlaceholder(routeNode, entryPath, resolvedEntryPathByRouteName);
+        let contents = renderControllerPlaceholder(routeNode, entryPath);
         fixPlans.push({
             code,
             contents,
             kind: 'create-file',
             path: entryPath,
             routeName: subtree.routeName,
-            suite: 'controllers',
+            suite: 'actions',
         });
     }
     return fixPlans;
 }
 function getFixCodeForSubtree(subtree) {
-    if (subtree.actualEntryPaths.length > 1 || subtree.actualAlternatePaths.length > 1) {
+    if (subtree.actualEntryPaths.length > 1) {
         return null;
     }
     if (subtree.actualEntryPath != null) {
         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(subtree, ownership, hasTsconfig) {
     let subtreeExtension = getMostCommonOwnerExtension(subtree.claimedRouteLocalFilePaths);
     if (subtreeExtension != null) {
         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;
     }
@@ -106,6 +89,12 @@ function getMostCommonOwnerExtension(filePaths) {
 }
 function getRouteNodesByName(tree) {
     let routeNodesByName = new Map();
+    routeNodesByName.set(ROOT_ROUTE_NAME, {
+        children: tree,
+        key: ROOT_ROUTE_NAME,
+        kind: 'group',
+        name: ROOT_ROUTE_NAME,
+    });
     function visit(nodes) {
         for (let node of nodes) {
             routeNodesByName.set(node.name, node);

package/dist/lib/doctor/controller-placeholders.d.ts

@@ -1,4 +1,3 @@
-import type { OwnershipRouteNode } from '../controller-ownership.ts';
-export declare function renderActionPlaceholder(routeNode: OwnershipRouteNode, entryPath: string): string;
-export declare function renderControllerPlaceholder(routeNode: OwnershipRouteNode, entryPath: string, resolvedEntryPathByRouteName: Map<string, string>): string;
+import { type OwnershipRouteNode } from '../controller-ownership.ts';
+export declare function renderControllerPlaceholder(routeNode: OwnershipRouteNode, entryPath: string): string;
 //# sourceMappingURL=controller-placeholders.d.ts.map

package/dist/lib/doctor/controller-placeholders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller-placeholders.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controller-placeholders.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAmDpE,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAgChG;AAED,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,kBAAkB,EAC7B,SAAS,EAAE,MAAM,EACjB,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAChD,MAAM,CAkCR"}
+{"version":3,"file":"controller-placeholders.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controller-placeholders.ts"],"names":[],"mappings":"AAGA,OAAO,EAAmB,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAErF,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,kBAAkB,EAC7B,SAAS,EAAE,MAAM,GAChB,MAAM,CAyBR"}