@zauso-ai/capstan-router 0.2.0 → 0.3.0

package/dist/scanner.js

@@ -1,5 +1,89 @@
+import { openSync, readSync, closeSync, statSync } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import path from "node:path";
+import { canonicalizeRouteManifest, createRouteConflictError as createValidationRouteConflictError, } from "./validation.js";
+import { analyzeRouteFileStaticInfo } from "./static-analysis.js";
+function isRouteGroupSegment(segment) {
+    return /^\([^()/]+\)$/.test(segment);
+}
+function isNotFoundFile(filename) {
+    return filename === "not-found.tsx" || filename === "not-found.page.tsx";
+}
+const componentTypeCache = new Map();
+export class RouteScanCache {
+    states = new Map();
+    get(rootDir) {
+        return this.states.get(rootDir);
+    }
+    set(rootDir, state) {
+        this.states.set(rootDir, state);
+    }
+    clear(rootDir) {
+        if (rootDir) {
+            this.states.delete(path.resolve(rootDir));
+            return;
+        }
+        this.states.clear();
+    }
+}
+export function createRouteScanCache() {
+    return new RouteScanCache();
+}
+/**
+ * Detect whether a page file is a server or client component by checking
+ * for a "use client" directive at the top of the file.
+ *
+ * Accepts an optional pre-computed signature (mtime:size) to avoid a
+ * redundant statSync when the caller already has file stats.
+ */
+function detectComponentType(filePath, knownSignature) {
+    let signature = knownSignature;
+    if (!signature) {
+        try {
+            const stats = statSync(filePath);
+            signature = `${stats.mtimeMs}:${stats.size}`;
+        }
+        catch {
+            componentTypeCache.delete(filePath);
+            return "server";
+        }
+    }
+    const cached = componentTypeCache.get(filePath);
+    if (cached?.signature === signature) {
+        return cached.componentType;
+    }
+    // Read only the first 128 bytes — enough to detect "use client" directive
+    // without pulling the entire file into memory.
+    let fd;
+    try {
+        fd = openSync(filePath, "r");
+    }
+    catch {
+        return "server";
+    }
+    try {
+        const buf = Buffer.alloc(128);
+        const bytesRead = readSync(fd, buf, 0, 128, 0);
+        const head = buf.toString("utf-8", 0, bytesRead);
+        const firstLine = head.split(/\r?\n/)[0]?.trim() ?? "";
+        const componentType = (firstLine === '"use client"' ||
+            firstLine === "'use client'" ||
+            firstLine === '"use client";' ||
+            firstLine === "'use client';")
+            ? "client"
+            : "server";
+        // Reuse the signature from above — no second statSync needed.
+        componentTypeCache.set(filePath, { signature, componentType });
+        return componentType;
+    }
+    catch {
+        componentTypeCache.delete(filePath);
+        return "server";
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 /**
  * Determine the route type from a filename.
  * Returns null if the file is not a recognized route file.
@@ -9,6 +93,12 @@ function classifyFile(filename) {
         return "layout";
     if (filename === "_middleware.ts")
         return "middleware";
+    if (filename === "_loading.tsx")
+        return "loading";
+    if (filename === "_error.tsx")
+        return "error";
+    if (isNotFoundFile(filename))
+        return "not-found";
     if (filename.endsWith(".page.tsx"))
         return "page";
     if (filename.endsWith(".api.ts"))
@@ -54,101 +144,218 @@ function fileToSegment(filename) {
     return { segment: base, params: [], isCatchAll: false };
 }
 /**
- * Convert a directory path relative to the routes root into URL segments.
- * Each directory named as a dynamic segment (e.g. `[orgId]`) is converted.
+ * Recursively walk a directory, returning all files as paths relative to the root.
+ *
+ * Uses async readdir with Dirent to classify entries without extra syscalls,
+ * then statSync per route file for signature. statSync is deliberately
+ * synchronous: on hot filesystem cache (common during dev), sync stat
+ * avoids Promise/microtask overhead that exceeds the sub-microsecond I/O.
  */
-function dirToSegments(relativeDir) {
-    if (relativeDir === "" || relativeDir === ".") {
-        return { segments: [], params: [] };
-    }
-    const parts = relativeDir.split(path.sep);
-    const segments = [];
-    const params = [];
-    for (const part of parts) {
-        const catchAllMatch = part.match(/^\[\.\.\.(\w+)\]$/);
-        if (catchAllMatch) {
-            segments.push("*");
-            params.push(catchAllMatch[1]);
+async function walkDir(dir) {
+    const files = [];
+    const stack = [
+        { absoluteDir: dir, relativeDir: "." },
+    ];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
             continue;
         }
-        const dynamicMatch = part.match(/^\[(\w+)\]$/);
-        if (dynamicMatch) {
-            segments.push(`:${dynamicMatch[1]}`);
-            params.push(dynamicMatch[1]);
+        let entries;
+        try {
+            entries = await readdir(current.absoluteDir, { withFileTypes: true });
+        }
+        catch {
             continue;
         }
-        segments.push(part);
+        for (const entry of entries) {
+            const absolutePath = path.join(current.absoluteDir, entry.name);
+            const relativePath = current.relativeDir === "."
+                ? entry.name
+                : path.join(current.relativeDir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push({
+                    absoluteDir: absolutePath,
+                    relativeDir: relativePath,
+                });
+                continue;
+            }
+            if (entry.isFile()) {
+                const routeType = classifyFile(entry.name);
+                if (!routeType) {
+                    continue;
+                }
+                try {
+                    const stats = statSync(absolutePath);
+                    files.push({
+                        relativePath,
+                        absolutePath,
+                        filename: entry.name,
+                        routeType,
+                        signature: `${stats.mtimeMs}:${stats.size}`,
+                    });
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
     }
-    return { segments, params };
+    files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+    return files;
 }
-/**
- * Collect all _layout.tsx files from the routes root down to the given directory,
- * ordered from outermost to innermost.
- */
-function collectLayouts(routesDir, relativeDir) {
-    const layouts = [];
-    const parts = relativeDir === "" || relativeDir === "." ? [] : relativeDir.split(path.sep);
-    // Check the root directory first
-    layouts.push(path.join(routesDir, "_layout.tsx"));
-    // Then each nested directory
-    let current = routesDir;
-    for (const part of parts) {
-        current = path.join(current, part);
-        layouts.push(path.join(current, "_layout.tsx"));
-    }
-    return layouts;
+function normalizeRelativeDir(relativeDir) {
+    return relativeDir === "" ? "." : relativeDir;
 }
-/**
- * Collect all _middleware.ts files from the routes root down to the given directory,
- * ordered from outermost to innermost.
- */
-function collectMiddlewares(routesDir, relativeDir) {
-    const middlewares = [];
-    const parts = relativeDir === "" || relativeDir === "." ? [] : relativeDir.split(path.sep);
-    middlewares.push(path.join(routesDir, "_middleware.ts"));
-    let current = routesDir;
-    for (const part of parts) {
-        current = path.join(current, part);
-        middlewares.push(path.join(current, "_middleware.ts"));
+function getDirectoryDepth(relativeDir) {
+    if (relativeDir === "." || relativeDir === "") {
+        return 0;
     }
-    return middlewares;
+    return relativeDir.split(path.sep).filter(Boolean).length;
 }
-/**
- * Recursively walk a directory, returning all files as paths relative to the root.
- */
-async function walkDir(dir, root) {
-    const files = [];
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
+function describeDirectorySegment(segment) {
+    if (isRouteGroupSegment(segment)) {
+        return { segments: [], params: [] };
     }
-    catch {
-        // Directory doesn't exist or can't be read
-        return files;
+    const catchAllMatch = segment.match(/^\[\.\.\.(\w+)\]$/);
+    if (catchAllMatch) {
+        return { segments: ["*"], params: [catchAllMatch[1]] };
+    }
+    const dynamicMatch = segment.match(/^\[(\w+)\]$/);
+    if (dynamicMatch) {
+        return { segments: [`:${dynamicMatch[1]}`], params: [dynamicMatch[1]] };
     }
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            const nested = await walkDir(fullPath, root);
-            files.push(...nested);
+    return { segments: [segment], params: [] };
+}
+function resolveDirectoryFile(rootDir, relativeDir, filename, existingAbsolute) {
+    const absolutePath = path.join(rootDir, relativeDir === "." ? "" : relativeDir, filename);
+    return existingAbsolute.has(absolutePath) ? absolutePath : undefined;
+}
+function buildDirectoryContexts(rootDir, routeFiles, existingAbsolute) {
+    const uniqueDirs = new Set(["."]);
+    const signatureByPath = new Map(routeFiles.map((file) => [file.relativePath, file.signature]));
+    for (const { relativePath } of routeFiles) {
+        let currentDir = normalizeRelativeDir(path.dirname(relativePath));
+        for (;;) {
+            uniqueDirs.add(currentDir);
+            if (currentDir === ".") {
+                break;
+            }
+            currentDir = normalizeRelativeDir(path.dirname(currentDir));
         }
-        else if (entry.isFile()) {
-            files.push(path.relative(root, fullPath));
+    }
+    const orderedDirs = [...uniqueDirs].sort((left, right) => {
+        const depthCmp = getDirectoryDepth(left) - getDirectoryDepth(right);
+        if (depthCmp !== 0) {
+            return depthCmp;
         }
+        return left.localeCompare(right);
+    });
+    const contexts = new Map();
+    for (const relativeDir of orderedDirs) {
+        const parentDir = relativeDir === "."
+            ? null
+            : normalizeRelativeDir(path.dirname(relativeDir));
+        const parent = parentDir ? contexts.get(parentDir) : undefined;
+        const dirInfo = (() => {
+            if (!parent || relativeDir === ".") {
+                return { segments: [], params: [] };
+            }
+            const segmentInfo = describeDirectorySegment(path.basename(relativeDir));
+            return {
+                segments: [...parent.dirInfo.segments, ...segmentInfo.segments],
+                params: [...parent.dirInfo.params, ...segmentInfo.params],
+            };
+        })();
+        const layoutPath = resolveDirectoryFile(rootDir, relativeDir, "_layout.tsx", existingAbsolute);
+        const middlewarePath = resolveDirectoryFile(rootDir, relativeDir, "_middleware.ts", existingAbsolute);
+        const loadingPath = resolveDirectoryFile(rootDir, relativeDir, "_loading.tsx", existingAbsolute);
+        const errorPath = resolveDirectoryFile(rootDir, relativeDir, "_error.tsx", existingAbsolute);
+        const notFoundPath = resolveDirectoryFile(rootDir, relativeDir, "not-found.tsx", existingAbsolute)
+            ?? resolveDirectoryFile(rootDir, relativeDir, "not-found.page.tsx", existingAbsolute);
+        const contextSignatureParts = [
+            parent?.contextSignature ?? "root",
+            relativeDir,
+            dirInfo.segments.join(","),
+            dirInfo.params.join(","),
+            layoutPath ? `${normalizeRelativeDir(path.relative(rootDir, layoutPath))}@${signatureByPath.get(normalizeRelativeDir(path.relative(rootDir, layoutPath))) ?? "missing"}` : "layout:none",
+            middlewarePath ? `${normalizeRelativeDir(path.relative(rootDir, middlewarePath))}@${signatureByPath.get(normalizeRelativeDir(path.relative(rootDir, middlewarePath))) ?? "missing"}` : "middleware:none",
+            loadingPath ? `${normalizeRelativeDir(path.relative(rootDir, loadingPath))}@${signatureByPath.get(normalizeRelativeDir(path.relative(rootDir, loadingPath))) ?? "missing"}` : "loading:none",
+            errorPath ? `${normalizeRelativeDir(path.relative(rootDir, errorPath))}@${signatureByPath.get(normalizeRelativeDir(path.relative(rootDir, errorPath))) ?? "missing"}` : "error:none",
+            notFoundPath ? `${normalizeRelativeDir(path.relative(rootDir, notFoundPath))}@${signatureByPath.get(normalizeRelativeDir(path.relative(rootDir, notFoundPath))) ?? "missing"}` : "not-found:none",
+        ];
+        contexts.set(relativeDir, {
+            dirInfo,
+            contextSignature: contextSignatureParts.join("|"),
+            layouts: layoutPath ? [...(parent?.layouts ?? []), layoutPath] : [...(parent?.layouts ?? [])],
+            middlewares: middlewarePath
+                ? [...(parent?.middlewares ?? []), middlewarePath]
+                : [...(parent?.middlewares ?? [])],
+            ...(loadingPath
+                ? { nearestLoading: loadingPath }
+                : parent?.nearestLoading
+                    ? { nearestLoading: parent.nearestLoading }
+                    : {}),
+            ...(errorPath
+                ? { nearestError: errorPath }
+                : parent?.nearestError
+                    ? { nearestError: parent.nearestError }
+                    : {}),
+            ...(notFoundPath
+                ? { nearestNotFound: notFoundPath }
+                : parent?.nearestNotFound
+                    ? { nearestNotFound: parent.nearestNotFound }
+                    : {}),
+        });
     }
-    return files;
+    return contexts;
 }
-/**
- * Filter layout/middleware candidate paths to only those that actually exist as
- * files discovered during the scan.
- */
-function filterExisting(candidates, existingAbsolute) {
-    return candidates.filter((p) => existingAbsolute.has(p));
+function buildCachedManifest(manifest, routeFiles, scannedFiles, validationSignature, validationRouteOrder, validationDiagnostics) {
+    return {
+        fileSignatures: new Map(routeFiles.map((file) => [file.relativePath, file.signature])),
+        scannedFiles,
+        validationDiagnostics,
+        validationRouteOrder,
+        validationSignature,
+        manifest,
+    };
+}
+function snapshotsMatchCacheState(routeFiles, cachedState) {
+    if (routeFiles.length !== cachedState.fileSignatures.size) {
+        return false;
+    }
+    for (const file of routeFiles) {
+        if (cachedState.fileSignatures.get(file.relativePath) !== file.signature) {
+            return false;
+        }
+    }
+    return true;
+}
+function buildStaticDiagnostics(filePath, routeType, urlPattern, params) {
+    return analyzeRouteFileStaticInfo(filePath, routeType, urlPattern, params.length > 0);
+}
+function createRouteValidationKey(route) {
+    return `${route.type}:${route.filePath}`;
+}
+function createRouteValidationSignature(route) {
+    return [
+        route.type,
+        route.filePath,
+        route.urlPattern,
+        route.params.join(","),
+        route.isCatchAll ? "1" : "0",
+        route.methods?.join(",") ?? "",
+        route.layouts.join(","),
+        route.middlewares.join(","),
+        route.loading ?? "",
+        route.error ?? "",
+        route.notFound ?? "",
+    ].join("|");
 }
 /**
  * Scan a routes directory and produce a RouteManifest describing every route file found.
  */
-export async function scanRoutes(routesDir) {
+export async function scanRoutes(routesDir, options = {}) {
     const resolvedRoot = path.resolve(routesDir);
     // Verify the directory exists
     try {
@@ -156,6 +363,7 @@ export async function scanRoutes(routesDir) {
         if (!s.isDirectory()) {
             return {
                 routes: [],
+                diagnostics: [],
                 scannedAt: new Date().toISOString(),
                 rootDir: resolvedRoot,
             };
@@ -164,32 +372,68 @@ export async function scanRoutes(routesDir) {
     catch {
         return {
             routes: [],
+            diagnostics: [],
             scannedAt: new Date().toISOString(),
             rootDir: resolvedRoot,
         };
     }
-    const relativePaths = await walkDir(resolvedRoot, resolvedRoot);
+    const cachedState = options.cache?.get(resolvedRoot);
+    // Quick pre-check: if a single changedFile is known and its signature
+    // matches the cache, the reported change was a no-op (e.g. editor
+    // touch without content change). Return cached manifest immediately
+    // without walking the directory tree.
+    if (options.changedFile && cachedState) {
+        const changedRelative = path.relative(resolvedRoot, path.resolve(options.changedFile));
+        const previousSignature = cachedState.fileSignatures.get(changedRelative);
+        if (previousSignature !== undefined) {
+            try {
+                const stats = statSync(path.resolve(options.changedFile));
+                if (`${stats.mtimeMs}:${stats.size}` === previousSignature) {
+                    return cachedState.manifest;
+                }
+            }
+            catch {
+                // File deleted — fall through to full scan.
+            }
+        }
+    }
+    const routeFiles = await walkDir(resolvedRoot);
+    if (cachedState && snapshotsMatchCacheState(routeFiles, cachedState)) {
+        return cachedState.manifest;
+    }
     // Build a set of all absolute paths for existence checks
-    const absolutePathSet = new Set(relativePaths.map((rp) => path.join(resolvedRoot, rp)));
+    const absolutePathSet = new Set(routeFiles.map((file) => file.absolutePath));
+    const directoryContexts = buildDirectoryContexts(resolvedRoot, routeFiles, absolutePathSet);
     const routes = [];
-    for (const relPath of relativePaths) {
-        const filename = path.basename(relPath);
-        const routeType = classifyFile(filename);
-        if (routeType === null) {
-            // Not a recognized route file — skip
+    const staticDiagnostics = [];
+    const scannedFiles = new Map();
+    for (const routeFile of routeFiles) {
+        const relativeDir = path.dirname(routeFile.relativePath);
+        const absoluteFilePath = routeFile.absolutePath;
+        const directoryContext = directoryContexts.get(normalizeRelativeDir(relativeDir));
+        if (!directoryContext) {
+            throw new Error(`Missing scanner directory context for ${relativeDir}`);
+        }
+        const cached = cachedState?.scannedFiles.get(routeFile.relativePath);
+        if (cached && cached.signature === routeFile.signature && cached.contextSignature === directoryContext.contextSignature) {
+            routes.push(cached.entry);
+            staticDiagnostics.push(...cached.diagnostics);
+            scannedFiles.set(routeFile.relativePath, cached);
             continue;
         }
-        const relativeDir = path.dirname(relPath);
-        const absoluteFilePath = path.join(resolvedRoot, relPath);
         // Build URL pattern
-        const dirInfo = dirToSegments(relativeDir);
-        if (routeType === "layout" || routeType === "middleware") {
+        const { dirInfo } = directoryContext;
+        const routeType = routeFile.routeType;
+        if (routeType === "layout" ||
+            routeType === "middleware" ||
+            routeType === "loading" ||
+            routeType === "error") {
             // Layouts and middlewares don't get their own URL pattern —
             // they are referenced by other routes. But we still include them
             // in the manifest so they can be discovered.
             const urlParts = dirInfo.segments;
             const urlPattern = "/" + urlParts.join("/");
-            routes.push({
+            const entry = {
                 filePath: absoluteFilePath,
                 type: routeType,
                 urlPattern: urlPattern === "/" ? "/" : urlPattern.replace(/\/$/, ""),
@@ -197,28 +441,66 @@ export async function scanRoutes(routesDir) {
                 middlewares: [],
                 params: dirInfo.params,
                 isCatchAll: false,
+            };
+            const staticInfo = buildStaticDiagnostics(absoluteFilePath, routeType, entry.urlPattern, entry.params);
+            if (staticInfo.staticInfo) {
+                entry.staticInfo = staticInfo.staticInfo;
+            }
+            staticDiagnostics.push(...staticInfo.diagnostics);
+            routes.push(entry);
+            scannedFiles.set(routeFile.relativePath, {
+                signature: routeFile.signature,
+                contextSignature: directoryContext.contextSignature,
+                entry,
+                diagnostics: staticInfo.diagnostics,
+            });
+            continue;
+        }
+        if (routeType === "not-found") {
+            const urlPattern = "/" + dirInfo.segments.join("/");
+            const entry = {
+                filePath: absoluteFilePath,
+                type: routeType,
+                urlPattern: urlPattern === "/" ? "/" : urlPattern.replace(/\/$/, ""),
+                layouts: directoryContext.layouts,
+                middlewares: directoryContext.middlewares,
+                params: dirInfo.params,
+                isCatchAll: false,
+                componentType: detectComponentType(absoluteFilePath, routeFile.signature),
+            };
+            const staticInfo = buildStaticDiagnostics(absoluteFilePath, routeType, entry.urlPattern, entry.params);
+            if (staticInfo.staticInfo)
+                entry.staticInfo = staticInfo.staticInfo;
+            staticDiagnostics.push(...staticInfo.diagnostics);
+            if (directoryContext.nearestLoading)
+                entry.loading = directoryContext.nearestLoading;
+            if (directoryContext.nearestError)
+                entry.error = directoryContext.nearestError;
+            if (directoryContext.nearestNotFound)
+                entry.notFound = directoryContext.nearestNotFound;
+            routes.push(entry);
+            scannedFiles.set(routeFile.relativePath, {
+                signature: routeFile.signature,
+                contextSignature: directoryContext.contextSignature,
+                entry,
+                diagnostics: staticInfo.diagnostics,
             });
             continue;
         }
         // Page or API route
-        const fileInfo = fileToSegment(filename);
+        const fileInfo = fileToSegment(routeFile.filename);
         const allParams = [...dirInfo.params, ...fileInfo.params];
         const urlParts = [...dirInfo.segments];
         if (fileInfo.segment !== "") {
             urlParts.push(fileInfo.segment);
         }
         const urlPattern = "/" + urlParts.join("/");
-        // Collect parent layouts and middlewares (only those that actually exist on disk)
-        const layoutCandidates = collectLayouts(resolvedRoot, relativeDir);
-        const middlewareCandidates = collectMiddlewares(resolvedRoot, relativeDir);
-        const layouts = filterExisting(layoutCandidates, absolutePathSet);
-        const middlewares = filterExisting(middlewareCandidates, absolutePathSet);
         const entry = {
             filePath: absoluteFilePath,
             type: routeType,
             urlPattern: urlPattern === "/" ? "/" : urlPattern.replace(/\/$/, ""),
-            layouts,
-            middlewares,
+            layouts: directoryContext.layouts,
+            middlewares: directoryContext.middlewares,
             params: allParams,
             isCatchAll: fileInfo.isCatchAll,
         };
@@ -227,31 +509,55 @@ export async function scanRoutes(routesDir) {
             // The actual exported methods are determined at runtime.
             entry.methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
         }
+        if (routeType === "page") {
+            entry.componentType = detectComponentType(absoluteFilePath, routeFile.signature);
+            if (directoryContext.nearestLoading)
+                entry.loading = directoryContext.nearestLoading;
+            if (directoryContext.nearestError)
+                entry.error = directoryContext.nearestError;
+            if (directoryContext.nearestNotFound)
+                entry.notFound = directoryContext.nearestNotFound;
+        }
+        const staticInfo = buildStaticDiagnostics(absoluteFilePath, routeType, entry.urlPattern, entry.params);
+        if (staticInfo.staticInfo) {
+            entry.staticInfo = staticInfo.staticInfo;
+        }
+        staticDiagnostics.push(...staticInfo.diagnostics);
         routes.push(entry);
+        scannedFiles.set(routeFile.relativePath, {
+            signature: routeFile.signature,
+            contextSignature: directoryContext.contextSignature,
+            entry,
+            diagnostics: staticInfo.diagnostics,
+        });
     }
-    // Sort for deterministic output:
-    // 1. By URL pattern alphabetically
-    // 2. By type (layout < middleware < page < api)
-    // 3. By file path as tiebreaker
-    const typeOrder = {
-        layout: 0,
-        middleware: 1,
-        page: 2,
-        api: 3,
-    };
-    routes.sort((a, b) => {
-        const patternCmp = a.urlPattern.localeCompare(b.urlPattern);
-        if (patternCmp !== 0)
-            return patternCmp;
-        const typeCmp = typeOrder[a.type] - typeOrder[b.type];
-        if (typeCmp !== 0)
-            return typeCmp;
-        return a.filePath.localeCompare(b.filePath);
-    });
-    return {
-        routes,
+    const validationSignature = routes
+        .map((route) => createRouteValidationSignature(route))
+        .join("\n");
+    const routeByValidationKey = new Map(routes.map((route) => [createRouteValidationKey(route), route]));
+    const reusedValidatedRoutes = cachedState && cachedState.validationSignature === validationSignature
+        ? cachedState.validationRouteOrder
+            .map((key) => routeByValidationKey.get(key))
+            .filter((route) => route !== undefined)
+        : undefined;
+    const validated = reusedValidatedRoutes && reusedValidatedRoutes.length === routes.length
+        ? {
+            routes: reusedValidatedRoutes,
+            diagnostics: cachedState.validationDiagnostics,
+        }
+        : canonicalizeRouteManifest(routes, resolvedRoot);
+    const diagnostics = [...validated.diagnostics, ...staticDiagnostics];
+    const errorDiagnostics = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+    if (errorDiagnostics.length > 0) {
+        throw createValidationRouteConflictError(errorDiagnostics);
+    }
+    const manifest = {
+        routes: validated.routes,
+        diagnostics,
         scannedAt: new Date().toISOString(),
         rootDir: resolvedRoot,
     };
+    options.cache?.set(resolvedRoot, buildCachedManifest(manifest, routeFiles, scannedFiles, validationSignature, validated.routes.map((route) => createRouteValidationKey(route)), validated.diagnostics));
+    return manifest;
 }
 //# sourceMappingURL=scanner.js.map