next-route-graph 1.0.2 → 1.2.0

package/dist/cli.js

@@ -1,58 +1,140 @@
 #!/usr/bin/env node
-import { Command } from "commander";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { stripVTControlCharacters } from "node:util";
+import { Command, Option } from "commander";
 import pc from "picocolors";
-import { analyzeRoutes } from "./core/analyzer.js";
-import { detectAppRouter } from "./core/detector.js";
-import { scanAppDir } from "./core/scanner.js";
-import { renderFlat } from "./render/flat.js";
-import { renderJson } from "./render/json.js";
-import { renderTree } from "./render/tree.js";
-const program = new Command();
-program
-    .name("next-route-graph")
-    .description("Inspect and visualize Next.js App Router project routes")
-    .version("1.0.0")
-    .argument("[projectPath]", "Path to the Next.js project root", ".")
-    .option("--flat", "Output only flat route paths")
-    .option("--json", "Output machine-readable JSON")
-    .option("--search <query>", "Filter routes by search string")
-    .action(async (projectPath, options) => {
+import { filterRoutes, inspectProject } from "./core/inspect.js";
+import { NextRouteGraphError, RouteLintError } from "./errors/index.js";
+import { startPreview } from "./preview.js";
+import { getRenderer } from "./render/index.js";
+function resolveFormat(options) {
+    const aliases = [
+        "json",
+        "flat",
+        "mermaid",
+        "dot",
+        "markdown",
+        "html",
+        "svg",
+    ];
+    const selected = aliases.filter((format) => options[format]);
+    if (selected.length + Number(Boolean(options.format)) > 1) {
+        throw new Error("Choose one output format: --format <type> or one format flag.");
+    }
+    const format = selected[0] ??
+        options.format ??
+        (options.serve !== undefined ? "html" : "tree");
+    if (options.html && options.output)
+        throw new Error("Use --html [file] or --output <file>, not both.");
+    if (options.serve !== undefined &&
+        (format !== "html" || options.output || options.html)) {
+        throw new Error("Use --serve on its own or with --format html; file output is separate.");
+    }
+    return format;
+}
+async function runAnalysis(projectPath, options) {
     try {
-        const { appDir, displayRoot } = detectAppRouter(projectPath);
-        const scannedFiles = await scanAppDir(appDir);
-        let analysisResult = await analyzeRoutes(scannedFiles, projectPath, displayRoot);
-        if (options.search) {
-            const search = options.search;
-            analysisResult.routes = analysisResult.routes.filter((route) => route.path.includes(search));
-            analysisResult.summary = {
-                ...analysisResult.summary,
-                routes: analysisResult.routes.length,
-                dynamic: analysisResult.routes.filter((route) => route.segmentType === "dynamic").length,
-                client: analysisResult.routes.filter((route) => route.rendering === "client").length,
-                server: analysisResult.routes.filter((route) => route.rendering === "server").length,
-            };
+        const format = resolveFormat(options);
+        const portText = options.serve === true ? "3000" : String(options.serve);
+        if (options.serve !== undefined &&
+            (!/^\d+$/.test(portText) || Number(portText) > 65535)) {
+            throw new Error("Preview port must be an integer between 0 and 65535 (0 chooses a free port).");
         }
-        if (options.json) {
-            console.log(renderJson(analysisResult));
-        }
-        else if (options.flat) {
-            const flatOutput = renderFlat(analysisResult.routes);
-            if (flatOutput) {
-                console.log(flatOutput);
+        const fullResult = await inspectProject(projectPath);
+        const result = options.search
+            ? filterRoutes(fullResult, options.search)
+            : fullResult;
+        let output = getRenderer(format).render(result);
+        const lint = fullResult.lint;
+        const failed = lint &&
+            ((options.check && lint.hasErrors) ||
+                (options.strict && (lint.hasErrors || lint.warningCount > 0)));
+        if (options.serve !== undefined) {
+            // A failed CI check must terminate instead of leaving a preview process alive.
+            if (failed)
+                throw new RouteLintError(lint.errorCount, lint.warningCount);
+            const server = await startPreview(output, Number(portText));
+            const address = server.address();
+            if (address && typeof address !== "string") {
+                console.error(pc.green(`✓ Route Graph server running at http://127.0.0.1:${address.port}`));
+                console.error("Static snapshot · Press Ctrl+C to stop");
             }
+            return;
         }
-        else {
-            console.log(renderTree(analysisResult));
+        const target = options.html
+            ? typeof options.html === "string"
+                ? options.html
+                : "route-graph.html"
+            : options.output;
+        if (target && target !== "-") {
+            const absolute = path.resolve(target);
+            await fs.mkdir(path.dirname(absolute), { recursive: true });
+            if (format === "tree")
+                output = stripVTControlCharacters(output);
+            await fs.writeFile(absolute, output + "\n", "utf-8");
+            console.error(pc.green(`✓ ${format === "html" ? "HTML report" : format.toUpperCase() + " export"} written to ${target}`));
         }
+        else if (output) {
+            process.stdout.write(output + "\n");
+        }
+        // Write the report before applying CI exit policy so failing checks leave artifacts.
+        if (failed)
+            throw new RouteLintError(lint.errorCount, lint.warningCount);
     }
     catch (error) {
-        if (options.json) {
-            console.error(JSON.stringify({ error: error.message }));
+        const message = error instanceof Error ? error.message : String(error);
+        if (options.json || options.format === "json") {
+            console.error(JSON.stringify({
+                error: message,
+                code: error instanceof NextRouteGraphError ? error.code : "ERR_CLI",
+            }));
         }
         else {
-            console.error(pc.red(`✗ ${error.message}`));
+            console.error(pc.red(`✗ ${message}`));
+            if (error instanceof NextRouteGraphError && error.hint)
+                console.error(pc.dim(`  Hint: ${error.hint}`));
         }
-        process.exit(1);
+        process.exitCode = 1;
     }
+}
+const program = new Command();
+const { version } = JSON.parse(await fs.readFile(new URL("../package.json", import.meta.url), "utf-8"));
+program
+    .name("next-route-graph")
+    .description("Inspect, lint, and visualize Next.js App Router project routes")
+    .version(version)
+    .argument("[projectPath]", "Path to the Next.js project root", ".")
+    .option("--flat", "Output flat route paths")
+    .option("--json", "Output machine-readable JSON")
+    .option("--mermaid", "Output Mermaid diagram source")
+    .option("--dot", "Output Graphviz DOT source")
+    .option("--markdown", "Output a Markdown table")
+    .option("--svg", "Output a rendered SVG route diagram")
+    .option("--html [file]", "Write an offline interactive HTML report (default: route-graph.html)")
+    .option("--serve [port]", "Preview an HTML snapshot on 127.0.0.1 (default: 3000)")
+    .addOption(new Option("--format <type>", "Output format (default: tree)").choices([
+    "tree",
+    "flat",
+    "json",
+    "mermaid",
+    "dot",
+    "markdown",
+    "html",
+    "svg",
+]))
+    .option("-o, --output <file>", "Write any format to a file; '-' writes to stdout")
+    .option("--search <query>", "Filter path, source file, or HTTP method (case-insensitive)")
+    .option("--check", "Fail on route validation errors")
+    .option("--strict", "Fail on errors or warnings")
+    .action(runAnalysis);
+program
+    .command("check")
+    .description("Check route collisions, root layouts, and slot fallbacks")
+    .argument("[projectPath]", "Path to the Next.js project root", ".")
+    .option("--strict", "Fail on warnings in addition to errors")
+    .option("--json", "Output check report as JSON")
+    .action(async (projectPath, options) => {
+    await runAnalysis(projectPath, { ...options, check: true });
 });
-program.parse(process.argv);
+await program.parseAsync(process.argv);

package/dist/core/analyzer.d.ts

@@ -0,0 +1,16 @@
+import { AnalysisResult, DiscoveredFile, RouteEntry, SummaryStats } from "../types/index.js";
+/**
+ * Aggregates summary statistics for the analyzed routes and convention files.
+ */
+export declare function getRoutesSummary(routes: RouteEntry[], layouts: number, loading: number, errors: number): SummaryStats;
+/**
+ * Analyzes discovered files in a Next.js App Router to construct route entries,
+ * evaluate rendering types, HTTP methods, layouts, and linter rules.
+ *
+ * @param files - All discovered files within the App Router directory
+ * @param projectPath - Base directory path of the project
+ * @param displayRoot - Display name of the App Router root ('app' or 'src/app')
+ * @returns Fully populated AnalysisResult with route metadata and lint report
+ */
+export declare function analyzeRoutes(files: DiscoveredFile[], projectPath: string, displayRoot: string): Promise<AnalysisResult>;
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/core/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../src/core/analyzer.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,cAAc,EACd,cAAc,EACd,UAAU,EAEV,YAAY,EACb,MAAM,mBAAmB,CAAC;AAyK3B;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb,YAAY,CA4Bd;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,cAAc,EAAE,EACvB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,cAAc,CAAC,CAqDzB"}

package/dist/core/analyzer.js

@@ -1,5 +1,11 @@
+import fs from "node:fs/promises";
 import path from "node:path";
-import { detectRenderingType, getSegmentType, parseRoutePath, parseSpecialFileType, } from "./parser.js";
+import { RouteFileReadError } from "../errors/index.js";
+import { lintRoutes } from "./linter.js";
+import { detectHttpMethods, getPrologueDirectives, detectRouteConfig, detectServerActions, extractRouteMetadata, getSegmentType, parseRoutePath, parseSpecialFileType, } from "./parser.js";
+/**
+ * Groups discovered files by their directory relative to the App Router root.
+ */
 function groupFilesByDirectory(files) {
     const dirMap = new Map();
     for (const file of files) {
@@ -14,6 +20,11 @@ function groupFilesByDirectory(files) {
     }
     return dirMap;
 }
+/**
+ * Processes all special convention files in a single directory.
+ * Performs a single disk read per file to extract rendering directives,
+ * HTTP methods, server actions, and segment configs.
+ */
 async function processDirectoryFiles(dirFiles) {
     const routeFiles = [];
     let layouts = 0;
@@ -24,12 +35,28 @@ async function processDirectoryFiles(dirFiles) {
         if (!specialType) {
             continue;
         }
-        const rendering = await detectRenderingType(file.fullPath);
+        let content = "";
+        try {
+            content = await fs.readFile(file.fullPath, "utf-8");
+        }
+        catch (cause) {
+            throw new RouteFileReadError(file.relativePath, cause);
+        }
+        const rendering = getPrologueDirectives(content).has("use client")
+            ? "client"
+            : "server";
+        const methods = specialType === "route" ? detectHttpMethods(content) : undefined;
+        const hasServerActions = detectServerActions(content);
+        const config = detectRouteConfig(content);
         routeFiles.push({
             type: specialType,
             fileName: file.fileName,
             relativePath: file.relativePath,
             rendering,
+            methods,
+            hasServerActions,
+            runtime: config.runtime,
+            dynamicConfig: config.dynamicConfig,
         });
         if (specialType === "layout") {
             layouts++;
@@ -37,7 +64,7 @@ async function processDirectoryFiles(dirFiles) {
         if (specialType === "loading") {
             loading++;
         }
-        if (specialType === "error") {
+        if (specialType === "error" || specialType === "global-error") {
             errors++;
         }
     }
@@ -48,7 +75,29 @@ async function processDirectoryFiles(dirFiles) {
         errors,
     };
 }
-function createRouteEntry(routeFiles) {
+/**
+ * Finds all layout files in parent directories that wrap a specific directory.
+ */
+function findLayoutChain(targetDir, layoutsByDirectory) {
+    const layoutChain = [];
+    const normalizedTarget = targetDir === "." ? "" : targetDir;
+    const segments = normalizedTarget ? normalizedTarget.split("/") : [];
+    // Check from root downwards
+    for (let i = 0; i <= segments.length; i++) {
+        const currentPath = segments.slice(0, i).join("/");
+        const checkDir = currentPath === "" ? "." : currentPath;
+        const layout = layoutsByDirectory.get(checkDir);
+        if (layout) {
+            layoutChain.push(layout);
+        }
+    }
+    return layoutChain;
+}
+/**
+ * Creates a RouteEntry from the convention files in a directory.
+ * Uses cached metadata from the in-memory RouteFile to eliminate duplicate disk reads.
+ */
+function createRouteEntry(routeFiles, layoutsByDirectory) {
     const pageFile = routeFiles.find((file) => file.type === "page");
     const routeHandlerFile = routeFiles.find((file) => file.type === "route");
     const primaryFile = pageFile ?? routeHandlerFile;
@@ -56,43 +105,41 @@ function createRouteEntry(routeFiles) {
         return null;
     }
     const computedPath = parseRoutePath(primaryFile.relativePath);
+    const metadata = extractRouteMetadata(primaryFile.relativePath);
+    const dir = path.dirname(primaryFile.relativePath).replace(/\\/g, "/");
+    const layoutChain = findLayoutChain(dir, layoutsByDirectory);
     return {
         path: computedPath,
         type: pageFile ? "page" : "route",
         file: primaryFile.relativePath,
         segmentType: getSegmentType(computedPath),
         rendering: primaryFile.rendering,
+        methods: primaryFile.methods,
+        hasServerActions: primaryFile.hasServerActions,
+        runtime: primaryFile.runtime,
+        dynamicConfig: primaryFile.dynamicConfig,
         files: routeFiles,
+        parallelSlots: metadata.slots.length > 0 ? metadata.slots : undefined,
+        intercepting: metadata.intercepting,
+        layoutChain: layoutChain.length > 0 ? layoutChain : undefined,
     };
 }
-async function analyzeDirectories(dirMap) {
-    const routesMap = new Map();
-    let totalLayouts = 0;
-    let totalLoading = 0;
-    let totalErrors = 0;
-    for (const dirFiles of dirMap.values()) {
-        const result = await processDirectoryFiles(dirFiles);
-        totalLayouts += result.layouts;
-        totalLoading += result.loading;
-        totalErrors += result.errors;
-        const route = createRouteEntry(result.routeFiles);
-        if (route) {
-            routesMap.set(route.path, route);
-        }
-    }
-    return {
-        routesMap,
-        totalLayouts,
-        totalLoading,
-        totalErrors,
-    };
-}
-function getRoutesSummary(routes, layouts, loading, errors) {
+/**
+ * Aggregates summary statistics for the analyzed routes and convention files.
+ */
+export function getRoutesSummary(routes, layouts, loading, errors) {
     let dynamic = 0;
     let client = 0;
+    let apiRoutes = 0;
+    let parallelRoutes = 0;
+    let interceptedRoutes = 0;
     for (const route of routes) {
         dynamic += route.segmentType !== "static" ? 1 : 0;
         client += route.rendering === "client" ? 1 : 0;
+        apiRoutes += route.type === "route" ? 1 : 0;
+        parallelRoutes +=
+            route.parallelSlots && route.parallelSlots.length > 0 ? 1 : 0;
+        interceptedRoutes += route.intercepting ? 1 : 0;
     }
     return {
         routes: routes.length,
@@ -102,20 +149,57 @@ function getRoutesSummary(routes, layouts, loading, errors) {
         layouts,
         loading,
         errors,
+        apiRoutes,
+        parallelRoutes,
+        interceptedRoutes,
     };
 }
+/**
+ * Analyzes discovered files in a Next.js App Router to construct route entries,
+ * evaluate rendering types, HTTP methods, layouts, and linter rules.
+ *
+ * @param files - All discovered files within the App Router directory
+ * @param projectPath - Base directory path of the project
+ * @param displayRoot - Display name of the App Router root ('app' or 'src/app')
+ * @returns Fully populated AnalysisResult with route metadata and lint report
+ */
 export async function analyzeRoutes(files, projectPath, displayRoot) {
     const startTime = Date.now();
     const dirMap = groupFilesByDirectory(files);
-    const { routesMap, totalLayouts, totalLoading, totalErrors } = await analyzeDirectories(dirMap);
-    const routes = Array.from(routesMap.values()).sort((a, b) => a.path.localeCompare(b.path));
+    const layoutsByDirectory = new Map();
+    for (const [dir, dirFiles] of dirMap) {
+        const layout = dirFiles.find((file) => parseSpecialFileType(file.fileName) === "layout");
+        if (layout)
+            layoutsByDirectory.set(dir, layout.relativePath);
+    }
+    const discoveredRoutes = [];
+    let totalLayouts = 0;
+    let totalLoading = 0;
+    let totalErrors = 0;
+    for (const dirFiles of dirMap.values()) {
+        const result = await processDirectoryFiles(dirFiles);
+        totalLayouts += result.layouts;
+        totalLoading += result.loading;
+        totalErrors += result.errors;
+        const route = createRouteEntry(result.routeFiles, layoutsByDirectory);
+        if (route) {
+            discoveredRoutes.push(route);
+        }
+    }
+    // Sort routes deterministically by URL path, then by file path for duplicate paths
+    const routes = discoveredRoutes.sort((a, b) => {
+        const cmp = a.path.localeCompare(b.path);
+        return cmp !== 0 ? cmp : a.file.localeCompare(b.file);
+    });
     const summary = getRoutesSummary(routes, totalLayouts, totalLoading, totalErrors);
+    const lint = lintRoutes(routes, files);
     return {
         project: path.basename(path.resolve(projectPath)),
         router: "App Router",
         root: displayRoot,
         routes,
         summary,
+        lint,
         executionTimeMs: Date.now() - startTime,
     };
 }

package/dist/core/detector.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Result of App Router detection
+ */
+export interface DetectionResult {
+    appDir: string;
+    displayRoot: string;
+}
+/**
+ * Detects the Next.js App Router root directory within a project path.
+ * Supports standard `./app`, `./src/app`, and direct App Router folder execution.
+ *
+ * @param projectDir - Path to the project root or App Router directory
+ * @returns DetectionResult containing absolute app directory and relative display path
+ * @throws {ProjectNotFoundError} If the target project directory does not exist
+ * @throws {AmbiguousRouterError} If both ./app and ./src/app are present
+ * @throws {NoAppRouterError} If neither ./app nor ./src/app are found
+ */
+export declare function detectAppRouter(projectDir: string): DetectionResult;
+//# sourceMappingURL=detector.d.ts.map

package/dist/core/detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../src/core/detector.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAsDnE"}

package/dist/core/detector.js

@@ -1,16 +1,27 @@
 import fs from "node:fs";
 import path from "node:path";
+import { AmbiguousRouterError, NoAppRouterError, ProjectNotFoundError, } from "../errors/index.js";
+/**
+ * Detects the Next.js App Router root directory within a project path.
+ * Supports standard `./app`, `./src/app`, and direct App Router folder execution.
+ *
+ * @param projectDir - Path to the project root or App Router directory
+ * @returns DetectionResult containing absolute app directory and relative display path
+ * @throws {ProjectNotFoundError} If the target project directory does not exist
+ * @throws {AmbiguousRouterError} If both ./app and ./src/app are present
+ * @throws {NoAppRouterError} If neither ./app nor ./src/app are found
+ */
 export function detectAppRouter(projectDir) {
     const absoluteDir = path.resolve(projectDir);
     if (!fs.existsSync(absoluteDir)) {
-        throw new Error("The specified project path does not exist.");
+        throw new ProjectNotFoundError(projectDir);
     }
     const srcAppPath = path.join(absoluteDir, "src", "app");
     const appPath = path.join(absoluteDir, "app");
     const hasSrcApp = fs.existsSync(srcAppPath) && fs.statSync(srcAppPath).isDirectory();
     const hasApp = fs.existsSync(appPath) && fs.statSync(appPath).isDirectory();
     if (hasSrcApp && hasApp) {
-        throw new Error(`Could not determine the App Router root.\n\nFound both:\n  ./app\n  ./src/app\n\nPlease keep only one App Router root for analysis.`);
+        throw new AmbiguousRouterError();
     }
     if (hasSrcApp) {
         return {
@@ -24,5 +35,22 @@ export function detectAppRouter(projectDir) {
             displayRoot: "app",
         };
     }
-    throw new Error(`No Next.js App Router directory found.\n\nExpected:\n  ./app\n  ./src/app`);
+    // Fallback: Check if the user pointed directly to the app directory itself
+    const isDirectAppDir = fs.statSync(absoluteDir).isDirectory() &&
+        (path.basename(absoluteDir) === "app" ||
+            fs.existsSync(path.join(absoluteDir, "layout.tsx")) ||
+            fs.existsSync(path.join(absoluteDir, "layout.jsx")) ||
+            fs.existsSync(path.join(absoluteDir, "layout.js")) ||
+            fs.existsSync(path.join(absoluteDir, "page.tsx")) ||
+            fs.existsSync(path.join(absoluteDir, "page.jsx")) ||
+            fs.existsSync(path.join(absoluteDir, "page.js")));
+    if (isDirectAppDir) {
+        const parentDirName = path.basename(path.dirname(absoluteDir));
+        const displayRoot = parentDirName === "src" ? "src/app" : path.basename(absoluteDir);
+        return {
+            appDir: absoluteDir,
+            displayRoot,
+        };
+    }
+    throw new NoAppRouterError();
 }

package/dist/core/inspect.d.ts

@@ -0,0 +1,6 @@
+import type { AnalysisResult } from "../types/index.js";
+/** Scan a project without starting Next.js or executing project code. */
+export declare function inspectProject(projectPath?: string): Promise<AnalysisResult>;
+/** Filter endpoint counts; convention-file totals and diagnostics remain project-wide. */
+export declare function filterRoutes(result: AnalysisResult, query: string): AnalysisResult;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/core/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/core/inspect.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,yEAAyE;AACzE,wBAAsB,cAAc,CAClC,WAAW,SAAM,GAChB,OAAO,CAAC,cAAc,CAAC,CAMzB;AAED,0FAA0F;AAC1F,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,MAAM,GACZ,cAAc,CAiBhB"}

package/dist/core/inspect.js

@@ -0,0 +1,21 @@
+import { analyzeRoutes, getRoutesSummary } from "./analyzer.js";
+import { detectAppRouter } from "./detector.js";
+import { scanAppDir } from "./scanner.js";
+/** Scan a project without starting Next.js or executing project code. */
+export async function inspectProject(projectPath = ".") {
+    const start = performance.now();
+    const { appDir, displayRoot } = detectAppRouter(projectPath);
+    const files = await scanAppDir(appDir);
+    const result = await analyzeRoutes(files, projectPath, displayRoot);
+    return { ...result, executionTimeMs: Math.round(performance.now() - start) };
+}
+/** Filter endpoint counts; convention-file totals and diagnostics remain project-wide. */
+export function filterRoutes(result, query) {
+    const search = query.toLowerCase();
+    const routes = result.routes.filter((route) => [route.path, route.file, ...(route.methods ?? [])].some((value) => value.toLowerCase().includes(search)));
+    return {
+        ...result,
+        routes,
+        summary: getRoutesSummary(routes, result.summary.layouts, result.summary.loading, result.summary.errors),
+    };
+}

package/dist/core/linter.d.ts

@@ -0,0 +1,11 @@
+import { DiscoveredFile, LintResult, RouteEntry } from "../types/index.js";
+/**
+ * Validates Next.js App Router routes and file structures against best practices
+ * and official framework rules.
+ *
+ * @param routes - Array of all analyzed route entries
+ * @param files - All discovered files in the App Router directory
+ * @returns LintResult containing discovered errors, warnings, and info diagnostics
+ */
+export declare function lintRoutes(routes: RouteEntry[], files: DiscoveredFile[]): LintResult;
+//# sourceMappingURL=linter.d.ts.map

package/dist/core/linter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linter.d.ts","sourceRoot":"","sources":["../../src/core/linter.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EAEd,UAAU,EACV,UAAU,EACX,MAAM,mBAAmB,CAAC;AAkB3B;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,UAAU,EAAE,EACpB,KAAK,EAAE,cAAc,EAAE,GACtB,UAAU,CA8LZ"}