@elench/testkit 0.1.61 → 0.1.63

package/lib/coverage/evidence.mjs

@@ -1,10 +1,12 @@
 import fs from "fs";
 import path from "path";
-import { extractHttpSuiteRequests } from "./next-static-analysis.mjs";
+import { extractHttpSuiteRequests, extractPlaywrightVisitedRoutes } from "./next-static-analysis.mjs";
 import {
   apiRouteLookupKey,
   HTTP_METHODS,
   dedupeTargets,
+  findMatchingApiRouteEntry,
+  findMatchingRouteValue,
   toApiRequestPath,
   toSelectionType,
 } from "./shared.mjs";
@@ -15,14 +17,35 @@ import {
   pathMatchesOwner,
 } from "./routing.mjs";
 
+function readTestFileContent(entry, context) {
+  if (!context?.serviceRoot) return null;
+  const absolutePath = path.join(context.serviceRoot, entry.filePath);
+  if (!fs.existsSync(absolutePath)) return null;
+  return fs.readFileSync(absolutePath, "utf8");
+}
+
+function resolveApiRouteEntry(context, method, requestPath) {
+  const exact = context.apiRouteByKey.get(apiRouteLookupKey(method, requestPath));
+  if (exact) return exact;
+  return findMatchingApiRouteEntry(method, requestPath, context.apiRouteEntries || []);
+}
+
 export function inferCoveredNodeIdsForTest(entry, context) {
   const coveredNodeIds = new Set();
-  const selectionType = toSelectionType(entry.type, entry.framework);
+  const content = readTestFileContent(entry, context);
 
+  // Capability: Playwright page routes (content-first, path-fallback)
   if (entry.framework === "playwright") {
-    const route = inferPageRouteFromTestFile(entry.filePath, context.nextAppRoot, context.serviceRoot);
-    if (route && context.pageByRoute.has(route)) {
-      const pageEntry = context.pageByRoute.get(route);
+    const gotoRoutes = content ? extractPlaywrightVisitedRoutes(content, entry.filePath) : [];
+    const routes = gotoRoutes.length > 0
+      ? gotoRoutes
+      : (() => { const r = inferPageRouteFromTestFile(entry.filePath, context.nextAppRoot, context.serviceRoot); return r ? [r] : []; })();
+    for (const route of routes) {
+      const matchedRoute = context.pageByRoute.get(route)
+        ? route
+        : findMatchingRouteValue(route, [...context.pageByRoute.keys()]);
+      const pageEntry = matchedRoute ? context.pageByRoute.get(matchedRoute) : null;
+      if (!pageEntry) continue;
       coveredNodeIds.add(pageEntry.node.id);
       for (const target of extractPlaywrightTargets(entry, context)) {
         const surfaceNode = pageEntry.surfacesByTargetValue?.get(target.value);
@@ -31,28 +54,30 @@ export function inferCoveredNodeIdsForTest(entry, context) {
     }
   }
 
-  if (selectionType === "int") {
-    const explicitRequests = extractHttpSuiteRequestsFromTestFile(entry, context);
-    if (explicitRequests.length > 0) {
-      for (const request of explicitRequests) {
-        const routeEntry = context.apiRouteByKey.get(apiRouteLookupKey(request.method, request.path));
+  // Capability: HTTP request extraction (any test type with rawReq/fetch/wrapper calls)
+  if (content) {
+    const requests = extractHttpSuiteRequests(content, entry.filePath);
+    for (const request of requests) {
+      if (!request.path.startsWith("/api/")) continue;
+      const routeEntry = resolveApiRouteEntry(context, request.method, request.path);
+      if (routeEntry) coveredNodeIds.add(routeEntry.node.id);
+    }
+  }
+
+  // Capability: path-based API route inference (fallback when no content matches)
+  if (coveredNodeIds.size === 0) {
+    const apiRoutes = inferApiRoutesFromTestFile(entry.filePath, context.nextAppRoot, context.serviceRoot);
+    for (const route of apiRoutes) {
+      for (const method of HTTP_METHODS) {
+        const routeEntry = resolveApiRouteEntry(context, method, toApiRequestPath(route));
         if (routeEntry) coveredNodeIds.add(routeEntry.node.id);
       }
-    } else {
-      const apiRoutes = inferApiRoutesFromTestFile(entry.filePath, context.nextAppRoot, context.serviceRoot);
-      for (const route of apiRoutes) {
-        for (const method of HTTP_METHODS) {
-          const routeEntry = context.apiRouteByKey.get(apiRouteLookupKey(method, toApiRequestPath(route)));
-          if (routeEntry) coveredNodeIds.add(routeEntry.node.id);
-        }
-      }
     }
   }
 
-  if (selectionType === "dal") {
-    for (const nodeId of inferDataCapabilitiesFromTestFile(entry, context)) {
-      coveredNodeIds.add(nodeId);
-    }
+  // Capability: DAL owner directory matching
+  for (const nodeId of inferDataCapabilitiesFromTestFile(entry, context)) {
+    coveredNodeIds.add(nodeId);
   }
 
   return [...coveredNodeIds].sort();
@@ -118,21 +143,8 @@ export function extractPlaywrightTargetsFromContent(content) {
   return dedupeTargets(targets);
 }
 
-export function extractHttpSuiteRequestsFromTestFile(entry, context) {
-  if (!entry || toSelectionType(entry.type, entry.framework) !== "int" || !context?.serviceRoot) return [];
-  const absolutePath = path.join(context.serviceRoot, entry.filePath);
-  if (!fs.existsSync(absolutePath)) return [];
-  return extractHttpSuiteRequestsFromContent(fs.readFileSync(absolutePath, "utf8"), entry.filePath);
-}
-
-export function extractHttpSuiteRequestsFromContent(content, filePath = "unknown") {
-  return extractHttpSuiteRequests(content, filePath)
-    .filter((request) => request.path.startsWith("/api/"))
-    .sort((left, right) => `${left.method}:${left.path}`.localeCompare(`${right.method}:${right.path}`));
-}
-
 export function inferDataCapabilitiesFromTestFile(entry, context) {
-  if (!entry || toSelectionType(entry.type, entry.framework) !== "dal") return [];
+  if (!entry) return [];
   const ownerDirectory = inferOwnerDirectoryFromTestFile(entry.filePath);
   if (!ownerDirectory) return [];
   return inferDataCapabilitiesFromOwner(ownerDirectory, context.dataCapabilities);

package/lib/coverage/evidence.test.mjs

@@ -1,10 +1,11 @@
 import { describe, expect, it } from "vitest";
 import {
   buildEvidenceDetailsFromTargets,
-  extractHttpSuiteRequestsFromContent,
   extractPlaywrightTargetsFromContent,
   inferDataCapabilitiesFromOwner,
 } from "./evidence.mjs";
+import { extractPlaywrightVisitedRoutes } from "./next-static-analysis.mjs";
+import { DYNAMIC_SEGMENT_TOKEN } from "./shared.mjs";
 
 describe("coverage evidence helpers", () => {
   it("extracts and dedupes Playwright targets from source content", () => {
@@ -20,21 +21,6 @@ describe("coverage evidence helpers", () => {
     ]);
   });
 
-  it("extracts API requests from integration suite source content", () => {
-    const content = `
-      export default defineHttpSuite(({ rawReq }) => {
-        rawReq("GET", "/api/campaigns");
-        rawReq("POST", "/api/campaigns");
-        rawReq("GET", "/health");
-      });
-    `;
-
-    expect(extractHttpSuiteRequestsFromContent(content, "campaigns.int.testkit.ts")).toEqual([
-      { method: "GET", path: "/api/campaigns", confidence: "high" },
-      { method: "POST", path: "/api/campaigns", confidence: "high" },
-    ]);
-  });
-
   it("builds compact evidence details only when meaningful signals exist", () => {
     expect(
       buildEvidenceDetailsFromTargets({
@@ -62,3 +48,31 @@ describe("coverage evidence helpers", () => {
     ]);
   });
 });
+
+describe("extractPlaywrightVisitedRoutes", () => {
+  it("extracts routes from page.goto() via AST", () => {
+    expect(extractPlaywrightVisitedRoutes(`
+      import { test } from "@playwright/test";
+      test("nav", async ({ page }) => {
+        await page.goto("/dashboard");
+        await page.goto("/settings/profile?tab=general");
+        await page.goto("/dashboard"); // duplicate
+        await page.goto("https://external.com/path"); // external
+        await page.goto("http://localhost:3000/events"); // same-origin absolute
+      });
+    `, "nav.pw.testkit.ts")).toEqual(["/dashboard", "/settings/profile", "/events"]);
+  });
+
+  it("handles property chain: foo.page.goto()", () => {
+    expect(extractPlaywrightVisitedRoutes(`
+      await this.page.goto("/projects");
+    `, "test.pw.testkit.ts")).toEqual(["/projects"]);
+  });
+
+  it("normalizes dynamic goto expressions into route patterns", () => {
+    expect(extractPlaywrightVisitedRoutes(`
+      await page.goto(\`/projects/\${id}\`);
+      await page.goto(someVar);
+    `, "test.pw.testkit.ts")).toEqual([`/projects/${DYNAMIC_SEGMENT_TOKEN}`]);
+  });
+});

package/lib/coverage/graph-builder.mjs

@@ -3,10 +3,10 @@ import { buildEvidenceDetails, inferCoveredNodeIdsForTest } from "./evidence.mjs
 import { findNextAppRoot, resolveImportToSourceFile, resolveServiceRoot } from "./fs-walk.mjs";
 import { discoverApiRoutes, discoverPageViews, discoverServerActions } from "./next-discovery.mjs";
 import {
-  apiRouteLookupKey,
   appendGraph,
   createEmptyGraph,
   createTestFileNode,
+  findMatchingApiRouteEntry,
   normalizePath,
   toSelectionType,
 } from "./shared.mjs";
@@ -29,12 +29,26 @@ export function buildCoverageGraph({ productDir, repoDiscovery = {}, services =
     const context = serviceContexts.get(entry.serviceName);
     const testNodeId = createTestFileNode(graph, entry);
     if (!context) {
+      graph.diagnostics.push({
+        level: "warn",
+        code: "no-service-context",
+        filePath: entry.filePath,
+        service: entry.serviceName,
+        message: `No coverage context available for service "${entry.serviceName}".`,
+      });
       evidence.push(createFallbackEvidence(entry, testNodeId));
       continue;
     }
 
     const coveredNodeIds = inferCoveredNodeIdsForTest(entry, context);
     if (coveredNodeIds.length === 0) {
+      graph.diagnostics.push({
+        level: "info",
+        code: "zero-coverage-inferred",
+        filePath: entry.filePath,
+        service: entry.serviceName,
+        message: `No routes, API endpoints, or data capabilities matched for "${entry.filePath}".`,
+      });
       evidence.push(createFallbackEvidence(entry, testNodeId));
       continue;
     }
@@ -108,7 +122,7 @@ export function buildServiceCoverageContext(productDir, serviceName, config, rep
 
   const pageByRoute = new Map(pages.pageEntries.map((entry) => [entry.route, entry]));
   const apiRouteByKey = new Map(
-    apiRoutes.routeEntries.map((entry) => [apiRouteLookupKey(entry.method, entry.requestPath), entry])
+    apiRoutes.routeEntries.map((entry) => [`${entry.method}:${entry.requestPath}`, entry])
   );
   const serverActionByExportKey = new Map(
     serverActions.actionEntries.map((entry) => [`${entry.sourceFile}#${entry.exportName}`, entry])
@@ -116,7 +130,7 @@ export function buildServiceCoverageContext(productDir, serviceName, config, rep
 
   for (const pageEntry of pages.pageEntries) {
     for (const request of pageEntry.requests) {
-      const apiRoute = apiRouteByKey.get(apiRouteLookupKey(request.method, request.path));
+      const apiRoute = findMatchingApiRouteEntry(request.method, request.path, apiRoutes.routeEntries);
       if (!apiRoute) continue;
       graph.edges.push({
         id: `handles:${request.node.id}:${apiRoute.node.id}`,
@@ -147,6 +161,7 @@ export function buildServiceCoverageContext(productDir, serviceName, config, rep
     graph,
     pageByRoute,
     apiRouteByKey,
+    apiRouteEntries: apiRoutes.routeEntries,
     serverActionByExportKey,
     dataCapabilities: dataAugmentation.nodes,
   };

package/lib/coverage/index.test.mjs

@@ -375,6 +375,309 @@ describe("coverage graph builder", () => {
     expect(context.apiRouteByKey.get("GET:/api/projects/[projectId]").node).toBeTruthy();
   });
 
+  it("resolves root-level PW test via page.goto() content extraction", () => {
+    const productDir = createProduct();
+    writeFile(
+      productDir,
+      "src/app/dashboard/page.tsx",
+      `export default function DashboardPage() { return <button data-testid="dash-header">Dashboard</button>; }`
+    );
+    writeFile(
+      productDir,
+      "__testkit__/dashboard.pw.testkit.ts",
+      `
+        import { test, expect } from "@playwright/test";
+        test("dashboard loads", async ({ page }) => {
+          await page.goto("/dashboard");
+          await expect(page.getByTestId("dash-header")).toBeVisible();
+        });
+      `
+    );
+
+    const graph = buildCoverageGraph({
+      productDir,
+      services: {
+        web: {
+          local: { cwd: ".", start: "node server.js", baseUrl: "http://127.0.0.1:3000", readyUrl: "http://127.0.0.1:3000" },
+        },
+      },
+      discoveryFiles: [
+        {
+          serviceName: "web",
+          type: "e2e",
+          framework: "playwright",
+          suiteName: "dashboard",
+          filePath: "__testkit__/dashboard.pw.testkit.ts",
+        },
+      ],
+    });
+
+    const evidence = graph.evidence.find((e) => e.testFilePath === "__testkit__/dashboard.pw.testkit.ts");
+    expect(evidence.coveredNodeIds).toEqual(
+      expect.arrayContaining([
+        "page_view:web:/dashboard",
+        "ui_surface:web:/dashboard:dash-header",
+      ])
+    );
+  });
+
+  it("resolves root-level e2e test via rawReq content extraction", () => {
+    const productDir = createProduct();
+    writeFile(
+      productDir,
+      "src/app/api/projects/route.ts",
+      `export async function GET() { return Response.json({ ok: true }); }`
+    );
+    writeFile(
+      productDir,
+      "__testkit__/projects.e2e.testkit.ts",
+      `
+        import { defineHttpSuite } from "@elench/testkit";
+        export default defineHttpSuite(({ rawReq }) => {
+          rawReq("GET", "/api/projects");
+        });
+      `
+    );
+
+    const graph = buildCoverageGraph({
+      productDir,
+      services: {
+        web: {
+          local: { cwd: ".", start: "node server.js", baseUrl: "http://127.0.0.1:3000", readyUrl: "http://127.0.0.1:3000" },
+        },
+      },
+      discoveryFiles: [
+        {
+          serviceName: "web",
+          type: "e2e",
+          framework: "k6",
+          suiteName: "projects",
+          filePath: "__testkit__/projects.e2e.testkit.ts",
+        },
+      ],
+    });
+
+    const evidence = graph.evidence.find((e) => e.testFilePath === "__testkit__/projects.e2e.testkit.ts");
+    expect(evidence.coveredNodeIds).toEqual(["api_route:web:GET:/api/projects"]);
+  });
+
+  it("resolves scenario test via rawReq content extraction", () => {
+    const productDir = createProduct();
+    writeFile(
+      productDir,
+      "src/app/api/campaigns/route.ts",
+      `export async function POST() { return Response.json({ ok: true }); }`
+    );
+    writeFile(
+      productDir,
+      "__testkit__/campaign-flow.scenario.testkit.ts",
+      `
+        import { defineHttpSuite } from "@elench/testkit";
+        export default defineHttpSuite(({ rawReq }) => {
+          rawReq("POST", "/api/campaigns");
+        });
+      `
+    );
+
+    const graph = buildCoverageGraph({
+      productDir,
+      services: {
+        web: {
+          local: { cwd: ".", start: "node server.js", baseUrl: "http://127.0.0.1:3000", readyUrl: "http://127.0.0.1:3000" },
+        },
+      },
+      discoveryFiles: [
+        {
+          serviceName: "web",
+          type: "scenario",
+          framework: "k6",
+          suiteName: "campaign-flow",
+          filePath: "__testkit__/campaign-flow.scenario.testkit.ts",
+        },
+      ],
+    });
+
+    const evidence = graph.evidence.find((e) => e.testFilePath === "__testkit__/campaign-flow.scenario.testkit.ts");
+    expect(evidence.coveredNodeIds).toEqual(["api_route:web:POST:/api/campaigns"]);
+  });
+
+  it("builds route-tree coverage from ancestor layouts, provider effects, local handlers, and dynamic request templates", () => {
+    const productDir = createProduct();
+    writeFile(
+      productDir,
+      "src/app/(dashboard)/layout.tsx",
+      `
+        import { ProjectProvider } from "@/components/project-context";
+
+        export default function DashboardLayout({ children }) {
+          return <ProjectProvider>{children}</ProjectProvider>;
+        }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/components/project-context.tsx",
+      `
+        "use client";
+        import { useEffect } from "react";
+
+        export function ProjectProvider({ children }) {
+          const fetchProjects = async () => {
+            await fetch("/api/projects");
+          };
+
+          useEffect(() => {
+            fetchProjects();
+          }, []);
+
+          return <section>{children}</section>;
+        }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/app/(dashboard)/projects/page.tsx",
+      `
+        "use client";
+        import { useState } from "react";
+
+        export default function ProjectsPage() {
+          const [name, setName] = useState("");
+
+          const handleCreate = async (event) => {
+            event.preventDefault();
+            await fetch("/api/projects", { method: "POST" });
+            setName("");
+          };
+
+          return (
+            <form onSubmit={handleCreate}>
+              <input value={name} onChange={(event) => setName(event.target.value)} />
+              <button data-testid="project-create-button" type="submit">Create Project</button>
+            </form>
+          );
+        }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/app/(dashboard)/events/page.tsx",
+      `
+        "use client";
+        import { useEffect } from "react";
+
+        export default function EventsPage() {
+          const activeProject = { id: "project-1" };
+
+          useEffect(() => {
+            fetch(\`/api/projects/\${activeProject.id}/events?limit=100\`);
+          }, [activeProject.id]);
+
+          return <div>Events</div>;
+        }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/app/api/projects/route.ts",
+      `
+        export async function GET() { return Response.json([]); }
+        export async function POST() { return Response.json({}, { status: 201 }); }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/app/api/projects/[projectId]/events/route.ts",
+      `
+        export async function GET() { return Response.json([]); }
+      `
+    );
+
+    const context = buildServiceCoverageContext(productDir, "web", {
+      local: { cwd: ".", start: "node server.js", baseUrl: "http://127.0.0.1:3000", readyUrl: "http://127.0.0.1:3000" },
+    });
+
+    expect(context.graph.edges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          kind: "requests",
+          from: "page_view:web:/projects",
+          to: expect.stringContaining("client_request:web:src/components/project-context.tsx:page:/projects"),
+        }),
+        expect.objectContaining({
+          kind: "handles",
+          from: expect.stringContaining("client_request:web:src/components/project-context.tsx:page:/projects"),
+          to: "api_route:web:GET:/api/projects",
+        }),
+        expect.objectContaining({
+          kind: "triggers",
+          from: expect.stringContaining("ui_surface:web:/projects"),
+          to: "ui_action:web:/projects:handleCreate",
+        }),
+        expect.objectContaining({
+          kind: "requests",
+          from: "ui_action:web:/projects:handleCreate",
+          to: expect.stringContaining("client_request:web:src/app/(dashboard)/projects/page.tsx"),
+        }),
+        expect.objectContaining({
+          kind: "handles",
+          to: "api_route:web:POST:/api/projects",
+        }),
+        expect.objectContaining({
+          kind: "requests",
+          from: "page_view:web:/events",
+          to: expect.stringContaining("client_request:web:src/components/project-context.tsx:page:/events"),
+        }),
+        expect.objectContaining({
+          kind: "handles",
+          to: "api_route:web:GET:/api/projects/[projectId]/events",
+        }),
+      ])
+    );
+  });
+
+  it("emits zero-coverage-inferred diagnostic when no patterns match", () => {
+    const productDir = createProduct();
+    writeFile(productDir, "src/app/page.tsx", `export default function HomePage() { return null; }`);
+    writeFile(
+      productDir,
+      "__testkit__/misc.e2e.testkit.ts",
+      `// no recognizable patterns here\nconsole.log("hello");`
+    );
+
+    const graph = buildCoverageGraph({
+      productDir,
+      services: {
+        web: {
+          local: { cwd: ".", start: "node server.js", baseUrl: "http://127.0.0.1:3000", readyUrl: "http://127.0.0.1:3000" },
+        },
+      },
+      discoveryFiles: [
+        {
+          serviceName: "web",
+          type: "e2e",
+          framework: "k6",
+          suiteName: "misc",
+          filePath: "__testkit__/misc.e2e.testkit.ts",
+        },
+      ],
+    });
+
+    expect(graph.diagnostics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          level: "info",
+          code: "zero-coverage-inferred",
+          filePath: "__testkit__/misc.e2e.testkit.ts",
+          service: "web",
+        }),
+      ])
+    );
+
+    const evidence = graph.evidence.find((e) => e.testFilePath === "__testkit__/misc.e2e.testkit.ts");
+    expect(evidence.coveredNodeIds).toEqual([expect.stringContaining("test_file:web:")]);
+  });
+
   it("does not exclude app/coverage source routes while still allowing top-level coverage output to be ignored", () => {
     const productDir = createProduct();
     writeFile(productDir, "app/coverage/page.tsx", `export default function CoveragePage() { return null; }`);

package/lib/coverage/next-discovery.mjs

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { analyzeNextPageFile } from "./next-static-analysis.mjs";
+import { analyzeNextRouteTree } from "./next-static-analysis.mjs";
 import { extractBackendImports, extractExportedFunctions, extractExportedMethodBodies } from "./backend-discovery.mjs";
 import { resolveImportToSourceFile, walkFiles } from "./fs-walk.mjs";
 import { routeFromApiFile, routeFromAppFile } from "./routing.mjs";
@@ -36,18 +36,22 @@ export function discoverPageViews({ serviceName, serviceRoot, nextAppRoot, exclu
       filePath: relativePath,
     };
     nodes.push(node);
+    const routeRootFiles = collectRouteRootFiles(nextAppRoot, absolutePath)
+      .map((absoluteRootPath) => ({
+        filePath: normalizePath(path.relative(serviceRoot, absoluteRootPath)),
+        content: fs.readFileSync(absoluteRootPath, "utf8"),
+      }));
 
-    const pageAnalysis = analyzeNextPageFile({
+    const pageAnalysis = analyzeNextRouteTree({
       serviceName,
       serviceRoot,
-      filePath: relativePath,
       route,
-      content,
+      rootFiles: routeRootFiles,
       readSourceFile: (resolvedPath) => {
         const absoluteResolved = path.join(serviceRoot, resolvedPath);
         return fs.existsSync(absoluteResolved) ? fs.readFileSync(absoluteResolved, "utf8") : null;
       },
-      resolveImportPath: (specifier) => resolveImportToSourceFile(serviceRoot, relativePath, specifier),
+      resolveImportPath: (fromFilePath, specifier) => resolveImportToSourceFile(serviceRoot, fromFilePath, specifier),
       isServerActionFile,
       normalizeRoute,
     });
@@ -68,6 +72,33 @@ export function discoverPageViews({ serviceName, serviceRoot, nextAppRoot, exclu
   return { nodes, edges, pageEntries };
 }
 
+function collectRouteRootFiles(nextAppRoot, pageAbsolutePath) {
+  const rootFiles = [];
+  let currentDir = path.dirname(pageAbsolutePath);
+  const appRoot = path.resolve(nextAppRoot);
+
+  while (currentDir.startsWith(appRoot)) {
+    const layoutFile = resolveRouteCompanion(currentDir, "layout");
+    if (layoutFile) rootFiles.push(layoutFile);
+    if (currentDir === appRoot) break;
+    currentDir = path.dirname(currentDir);
+  }
+
+  rootFiles.reverse();
+  rootFiles.push(pageAbsolutePath);
+  return [...new Set(rootFiles)];
+}
+
+function resolveRouteCompanion(directoryPath, baseName) {
+  const candidates = [
+    path.join(directoryPath, `${baseName}.tsx`),
+    path.join(directoryPath, `${baseName}.ts`),
+    path.join(directoryPath, `${baseName}.jsx`),
+    path.join(directoryPath, `${baseName}.js`),
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+}
+
 export function discoverApiRoutes({ serviceName, serviceRoot, nextAppRoot, exclude = [], resolveImportToSourceFile }) {
   const routeFiles = walkFiles(path.join(nextAppRoot, "api"), { baseDir: serviceRoot, exclude }).filter(
     (filePath) => filePath.endsWith("/route.ts") || filePath.endsWith("/route.tsx") || filePath.endsWith("/route.js")