@sifxprime/krouter 0.5.166 → 0.5.167

package/app/node_modules/next/dist/server/lib/router-utils/setup-dev-bundler.js

@@ -27,6 +27,7 @@ const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _querystring = /*#__PURE__*/ _interop_require_default(require("querystring"));
 const _watchpack = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/watchpack"));
 const _findup = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/find-up"));
+const _picocolors = require("../../../lib/picocolors");
 const _filesystem = require("./filesystem");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../build/output/log"));
 const _shared = require("../../../trace/shared");
@@ -34,11 +35,14 @@ const _findpagefile = require("../find-page-file");
 const _events = require("../../../telemetry/events");
 const _utils = require("../../../shared/lib/router/utils");
 const _sortbypageexts = require("../../../build/sort-by-page-exts");
+const _getconventionfilebasename = require("../../../build/get-convention-file-base-name");
+const _normalizecatchallroutes = require("./normalize-catchall-routes");
 const _verifytypescriptsetup = require("../../../lib/verify-typescript-setup");
 const _verifypartytownsetup = require("../../../lib/verify-partytown-setup");
 const _routeregex = require("../../../shared/lib/router/utils/route-regex");
 const _builddataroute = require("./build-data-route");
 const _routematcher = require("../../../shared/lib/router/utils/route-matcher");
+const _normalizepagepath = require("../../../shared/lib/page-path/normalize-page-path");
 const _normalizepathsep = require("../../../shared/lib/page-path/normalize-path-sep");
 const _createclientrouterfilter = require("../../../lib/create-client-router-filter");
 const _absolutepathtopage = require("../../../shared/lib/page-path/absolute-path-to-page");
@@ -57,9 +61,17 @@ const _store = require("../../../build/output/store");
 const _utils2 = require("../../../shared/lib/turbopack/utils");
 const _defineenv = require("../../../build/define-env");
 const _internalerror = require("../../../shared/lib/turbopack/internal-error");
-const _normalizepath = require("../../../lib/normalize-path");
+const _recursivereaddir = require("../../../lib/recursive-readdir");
 const _constants1 = require("../../../lib/constants");
 const _url = require("../../../lib/url");
+const _isapiroute = require("../../../lib/is-api-route");
+const _isapppageroute = require("../../../lib/is-app-page-route");
+const _isapprouteroute = require("../../../lib/is-app-route-route");
+const _unmatchedapppageserror = require("../../../shared/lib/errors/unmatched-app-pages-error");
+const _missingcanonicalinterceptionrouteserror = require("../../../shared/lib/errors/missing-canonical-interception-routes-error");
+const _incompatibleparallelrouteslotserror = require("../../../shared/lib/errors/incompatible-parallel-route-slots-error");
+const _interceptionroutes = require("../../../shared/lib/router/utils/interception-routes");
+const _strictroutematchingconfig = require("./strict-route-matching-config");
 const _routetypesutils = require("./route-types-utils");
 const _cachelifetypeutils = require("./cache-life-type-utils");
 const _rootparamstypeutils = require("./root-params-type-utils");
@@ -68,6 +80,7 @@ const _apppaths = require("../../../shared/lib/router/utils/app-paths");
 const _ensureleadingslash = require("../../../shared/lib/page-path/ensure-leading-slash");
 const _lockfile = require("../../../build/lockfile");
 const _magicidentifier = require("../../../shared/lib/magic-identifier");
+const _routekind = require("../../route-kind");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -188,7 +201,8 @@ async function startWatcher(opts) {
             previewProps: opts.fsChecker.previewProps,
             resetFetch,
             lockfile,
-            onDevServerCleanup: opts.onDevServerCleanup
+            onDevServerCleanup: opts.onDevServerCleanup,
+            hasVulnerabilityInsight: opts.hasVulnerabilityInsight
         });
     })();
     await hotReloader.start();
@@ -221,52 +235,70 @@ async function startWatcher(opts) {
         skipProxyUrlNormalize: nextConfig.skipProxyUrlNormalize
     };
     await _fs.default.promises.writeFile(routesManifestPath, JSON.stringify(routesManifest));
+    const previewPropsManifestPath = _path.default.join(distDir, _constants.SERVER_DIRECTORY, _constants.PREVIEW_PROPS_MANIFEST);
+    _fs.default.mkdirSync(_path.default.join(distDir, _constants.SERVER_DIRECTORY), {
+        recursive: true
+    });
+    await _fs.default.promises.writeFile(previewPropsManifestPath, JSON.stringify(opts.fsChecker.previewProps, null, 2));
     const prerenderManifestPath = _path.default.join(distDir, _constants.PRERENDER_MANIFEST);
     await _fs.default.promises.writeFile(prerenderManifestPath, JSON.stringify({
         version: 4,
         routes: {},
         dynamicRoutes: {},
-        notFoundRoutes: [],
-        preview: opts.fsChecker.previewProps
+        notFoundRoutes: []
     }, null, 2));
     if (opts.nextConfig.experimental.nextScriptWorkers) {
         await (0, _verifypartytownsetup.verifyPartytownSetup)(opts.dir, _path.default.join(distDir, _constants.CLIENT_STATIC_FILES_PATH));
     }
     opts.fsChecker.ensureCallback(async function ensure(item) {
-        if (item.type === 'appFile' || item.type === 'pageFile') {
-            await hotReloader.ensurePage({
-                clientOnly: false,
-                page: item.itemPath,
-                isApp: item.type === 'appFile',
-                definition: undefined
-            });
-        }
+        const definition = item.route;
+        // FsOutput also includes static assets, which do not need compilation.
+        if (!definition) return;
+        // Static-info lookup needs the concrete grouped or parallel app path to
+        // discover segment configuration such as `runtime = 'edge'`.
+        await hotReloader.ensurePage({
+            clientOnly: false,
+            page: definition.page,
+            isApp: item.type === 'appFile',
+            definition,
+            url: item.requestPath
+        });
     });
     let resolved = false;
     let prevSortedRoutes = [];
-    await new Promise(async (resolve, reject)=>{
-        if (pagesDir) {
-            // Watchpack doesn't emit an event for an empty directory
-            _fs.default.readdir(pagesDir, (_, files)=>{
-                if (files == null ? void 0 : files.length) {
-                    return;
-                }
-                if (!resolved) {
-                    resolve();
-                    resolved = true;
-                }
+    let hasComputedSortedRoutes = false;
+    const pages = pagesDir ? [
+        pagesDir
+    ] : [];
+    const app = appDir ? [
+        appDir
+    ] : [];
+    const directories = [
+        ...pages,
+        ...app
+    ];
+    // Snapshot the route directories before watching starts. Watchpack can report
+    // its first aggregation while a directory scan is still in flight, so route
+    // discovery needs this snapshot to avoid observing a partial filesystem.
+    const initialFiles = (await Promise.all(directories.map(async (directory)=>{
+        try {
+            return await (0, _recursivereaddir.recursiveReadDir)(directory, {
+                relativePathnames: false
             });
+        } catch (err) {
+            // The directory can be removed while the dev server boots. Watchpack
+            // reports that as a removal later on.
+            if (err.code !== 'ENOENT') throw err;
+            return [];
+        }
+    }))).flat();
+    const initialPageFiles = initialFiles.filter(validFileMatcher.isPageFile);
+    await new Promise(async (resolve, reject)=>{
+        if (initialFiles.length === 0) {
+            // Watchpack doesn't emit an event when all route directories are empty.
+            resolve();
+            resolved = true;
         }
-        const pages = pagesDir ? [
-            pagesDir
-        ] : [];
-        const app = appDir ? [
-            appDir
-        ] : [];
-        const directories = [
-            ...pages,
-            ...app
-        ];
         const rootDir = pagesDir || appDir;
         const files = [
             ...(0, _utils1.getPossibleMiddlewareFilenames)(_path.default.join(rootDir, '..'), nextConfig.pageExtensions),
@@ -297,20 +329,39 @@ async function startWatcher(opts) {
         let enabledTypeScript = await verifyTypeScript(opts);
         let previousClientRouterFilters;
         let previousConflictingPagePaths = new Set();
+        let previousRouteMatchingErrors = null;
+        let hadInitialScan = false;
+        let previousDuplicatePagePaths = new Set();
         const routeTypesFilePath = _path.default.join(distDir, 'types', 'routes.d.ts');
         const validatorFilePath = _path.default.join(distDir, 'types', 'validator.ts');
         let initialWatchTime = performance.now() + performance.timeOrigin;
+        // Startup only waits this long for Watchpack to observe the files found by
+        // the snapshot above, so a file it never reports cannot stall the server.
+        const initialScanDeadline = initialWatchTime + 30000;
         wp.on('aggregated', async ()=>{
             var _serverFields_middleware, _serverFields_middleware1;
+            const isInitialScan = !hadInitialScan;
             let writeEnvDefinitions = false;
             let typescriptStatusFromLastAggregation = enabledTypeScript;
             let middlewareMatchers;
             const routedPages = [];
             const knownFiles = wp.getTimeInfoEntries();
+            // Watchpack can emit an aggregation while its initial directory scan is
+            // still in flight. Ignore partial startup passes so route definitions and
+            // errors are not published until every initial page file is observable.
+            // Bounded by a deadline so an unwatchable file can never block startup.
+            if (!resolved && performance.now() + performance.timeOrigin < initialScanDeadline && initialPageFiles.some((file)=>_fs.default.existsSync(file) && !knownFiles.has(file))) {
+                return;
+            }
+            hadInitialScan = true;
             const appPaths = {};
+            const defaultAppPaths = new Set();
             const pageNameSet = new Set();
             const conflictingAppPagePaths = new Set();
+            const duplicatePagePaths = new Set();
             const appPageFilePaths = new Map();
+            const appRouteFilePaths = new Map();
+            const parallelRouteLayoutFiles = new Map();
             const pagesPageFilePaths = new Map();
             const appRouteHandlers = [];
             const pageApiRoutes = [];
@@ -318,7 +369,8 @@ async function startWatcher(opts) {
             const appRoutes = [];
             const layoutRoutes = [];
             const slots = [];
-            let envChange = false;
+            let envFileChange = false;
+            let clientRouterFiltersChange = false;
             let tsconfigChange = false;
             let conflictingPageChange = 0;
             let hasRootAppNotFound = false;
@@ -336,7 +388,8 @@ async function startWatcher(opts) {
                 if (!files.includes(fileName) && !directories.some((d)=>fileName.startsWith(d))) {
                     continue;
                 }
-                const { name: fileBaseName, dir: fileDir } = _path.default.parse(fileName);
+                const { base: fileBase, dir: fileDir } = _path.default.parse(fileName);
+                const fileBaseName = (0, _getconventionfilebasename.getConventionFileBaseName)(fileBase);
                 const isAtConventionLevel = fileDir === dir || fileDir === _path.default.join(dir, 'src');
                 if (isAtConventionLevel && fileBaseName === _constants1.MIDDLEWARE_FILENAME) {
                     middlewareFilePath = fileName;
@@ -347,11 +400,7 @@ async function startWatcher(opts) {
                 if (middlewareFilePath) {
                     if (proxyFilePath) {
                         const cwd = process.cwd();
-                        throw Object.defineProperty(new Error(`Both ${_constants1.MIDDLEWARE_FILENAME} file "./${_path.default.relative(cwd, middlewareFilePath)}" and ${_constants1.PROXY_FILENAME} file "./${_path.default.relative(cwd, proxyFilePath)}" are detected. Please use "./${_path.default.relative(cwd, proxyFilePath)}" only. Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`), "__NEXT_ERROR_CODE", {
-                            value: "E900",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error(`Both ${_constants1.MIDDLEWARE_FILENAME} file "./${_path.default.relative(cwd, middlewareFilePath)}" and ${_constants1.PROXY_FILENAME} file "./${_path.default.relative(cwd, proxyFilePath)}" are detected. Please use "./${_path.default.relative(cwd, proxyFilePath)}" only. Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`);
                     }
                     _log.warnOnce(`The "${_constants1.MIDDLEWARE_FILENAME}" file convention is deprecated. Please use "${_constants1.PROXY_FILENAME}" instead.\n\n` + `  To migrate automatically, run:\n` + `  npx @next/codemod@canary middleware-to-proxy .\n\n` + `  Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`);
                 }
@@ -367,7 +416,7 @@ async function startWatcher(opts) {
                 fileWatchTimes.set(fileName, nextWatchTime);
                 if (envFiles.includes(fileName)) {
                     if (fileChanged) {
-                        envChange = true;
+                        envFileChange = true;
                     }
                     continue;
                 }
@@ -380,9 +429,19 @@ async function startWatcher(opts) {
                     }
                     continue;
                 }
-                if ((meta == null ? void 0 : meta.accuracy) === undefined || !validFileMatcher.isPageFile(fileName)) {
+                const fileExists = _fs.default.existsSync(fileName);
+                if (!validFileMatcher.isPageFile(fileName) || (meta == null ? void 0 : meta.accuracy) === undefined && !fileExists) {
                     continue;
                 }
+                if (fileExists) {
+                    try {
+                        if (!_fs.default.statSync(fileName).isFile()) {
+                            continue;
+                        }
+                    } catch  {
+                        continue;
+                    }
+                }
                 const isAppPath = Boolean(appDir && (0, _normalizepathsep.normalizePathSep)(fileName).startsWith((0, _normalizepathsep.normalizePathSep)(appDir) + '/'));
                 const isPagePath = Boolean(pagesDir && (0, _normalizepathsep.normalizePathSep)(fileName).startsWith((0, _normalizepathsep.normalizePathSep)(pagesDir) + '/'));
                 const rootFile = (0, _absolutepathtopage.absolutePathToPage)(fileName, {
@@ -464,6 +523,8 @@ async function startWatcher(opts) {
                     (0, _fileclassifier.addSlotIfNew)(slots, normalizedPageName);
                     // Handle layouts separately - they don't get added to appPaths
                     if (validFileMatcher.isAppLayoutPage(fileName)) {
+                        const layoutPath = normalizedPageName.replace(/%5F/g, '_').replace(/\/layout$/, '') || '/';
+                        parallelRouteLayoutFiles.set(layoutPath, fileName);
                         const layoutRoute = (0, _ensureleadingslash.ensureLeadingSlash)((0, _apppaths.normalizeAppPath)(normalizedPageName).replace(/\/layout$/, ''));
                         layoutRoutes.push({
                             route: layoutRoute,
@@ -471,15 +532,21 @@ async function startWatcher(opts) {
                         });
                         continue;
                     }
+                    if (validFileMatcher.isAppDefaultPage(fileName)) {
+                        defaultAppPaths.add(normalizedPageName.replace(/%5F/g, '_'));
+                        continue;
+                    }
                     // Skip non-router pages (loading.tsx, error.tsx, etc.)
                     if (!validFileMatcher.isAppRouterPage(fileName)) continue;
                     const originalPageName = pageName;
                     pageName = (0, _apppaths.normalizeAppPath)(pageName).replace(/%5F/g, '_');
                     const appRoute = (0, _normalizepathsep.normalizePathSep)(pageName);
+                    const appPath = opts.turbo ? originalPageName.replace(/%5F/g, '_') : originalPageName;
                     if (!appPaths[pageName]) {
                         appPaths[pageName] = [];
                     }
-                    appPaths[pageName].push(opts.turbo ? originalPageName.replace(/%5F/g, '_') : originalPageName);
+                    appPaths[pageName].push(appPath);
+                    appRouteFilePaths.set(appPath, fileName);
                     if (useFileSystemPublicRoutes) {
                         if (appDir && (0, _ismetadataroute.isStaticMetadataFile)(fileName.replace(appDir, ''))) {
                             const segment = _path.default.posix.dirname(pageName);
@@ -494,14 +561,26 @@ async function startWatcher(opts) {
                         route: appRoute,
                         filePath: fileName
                     };
-                    if (validFileMatcher.isAppRouterRoute(fileName)) {
-                        appRouteHandlers.push(routeEntry);
+                    if ((0, _isapprouteroute.isAppRouteRoute)(appPath)) {
+                        appRouteHandlers.push({
+                            ...routeEntry,
+                            page: appPath
+                        });
                     } else {
                         appRoutes.push(routeEntry);
                     }
                     if (routedPages.includes(pageName)) continue;
                 } else {
                     // Pages router
+                    const existingPageFilePath = pagesPageFilePaths.get(pageName);
+                    if (pagesDir && existingPageFilePath) {
+                        duplicatePagePaths.add(pageName);
+                        if (!previousDuplicatePagePaths.has(pageName)) {
+                            const existingPagePath = (0, _normalizepathsep.normalizePathSep)(_path.default.join('pages', _path.default.relative(pagesDir, existingPageFilePath)));
+                            const duplicatePagePath = (0, _normalizepathsep.normalizePathSep)(_path.default.join('pages', _path.default.relative(pagesDir, fileName)));
+                            _log.warn(`Duplicate page detected. ${(0, _picocolors.cyan)(existingPagePath)} and ${(0, _picocolors.cyan)(duplicatePagePath)} both resolve to ${(0, _picocolors.cyan)(pageName)}.`);
+                        }
+                    }
                     if (useFileSystemPublicRoutes) {
                         pageFiles.add(pageName);
                         opts.fsChecker.nextDataRoutes.add(pageName);
@@ -511,7 +590,7 @@ async function startWatcher(opts) {
                         route,
                         filePath: fileName
                     };
-                    if (pageName.startsWith('/api/')) {
+                    if ((0, _isapiroute.isAPIRoute)(pageName)) {
                         pageApiRoutes.push(routeEntry);
                     } else {
                         pageRoutes.push(routeEntry);
@@ -547,28 +626,28 @@ async function startWatcher(opts) {
                         const pagesPath = _path.default.relative(dir, pagesPageFilePaths.get(p));
                         errorMessage += `  "${pagesPath}" - "${appPath}"\n`;
                     }
-                    hotReloader.setHmrServerError(Object.defineProperty(new Error(errorMessage), "__NEXT_ERROR_CODE", {
-                        value: "E1010",
-                        enumerable: false,
-                        configurable: true
-                    }));
+                    hotReloader.setHmrServerError(new Error(errorMessage));
                 } else if (numConflicting === 0) {
                     hotReloader.clearHmrServerError();
-                    await propagateServerField(opts, 'reloadMatchers', undefined);
                 }
             }
             previousConflictingPagePaths = conflictingAppPagePaths;
+            previousDuplicatePagePaths = duplicatePagePaths;
             let clientRouterFilters;
             if (nextConfig.experimental.clientRouterFilter) {
                 clientRouterFilters = (0, _createclientrouterfilter.createClientRouterFilter)(Object.keys(appPaths), nextConfig.experimental.clientRouterFilterRedirects ? (nextConfig._originalRedirects || []).filter((r)=>!r.internal) : [], nextConfig.experimental.clientRouterFilterAllowedRate);
                 if (!previousClientRouterFilters || JSON.stringify(previousClientRouterFilters) !== JSON.stringify(clientRouterFilters)) {
-                    envChange = true;
+                    clientRouterFiltersChange = true;
                     previousClientRouterFilters = clientRouterFilters;
                 }
             }
-            if (envChange || tsconfigChange) {
-                if (envChange) {
-                    writeEnvDefinitions = true;
+            // Also set on the initial scan, so that typed env definitions exist
+            // from startup.
+            if (envFileChange || isInitialScan) {
+                writeEnvDefinitions = true;
+            }
+            if (envFileChange || clientRouterFiltersChange || tsconfigChange) {
+                if (envFileChange) {
                     await propagateServerField(opts, 'loadEnvConfig', [
                         {
                             dev: true,
@@ -577,9 +656,7 @@ async function startWatcher(opts) {
                     ]);
                 }
                 if (hotReloader.turbopackProject) {
-                    var _opts_nextConfig_turbopack;
                     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
-                    const rootPath = ((_opts_nextConfig_turbopack = opts.nextConfig.turbopack) == null ? void 0 : _opts_nextConfig_turbopack.root) || opts.nextConfig.outputFileTracingRoot || opts.dir;
                     await hotReloader.turbopackProject.update({
                         defineEnv: (0, _swc.createDefineEnv)({
                             isTurbopack: true,
@@ -593,9 +670,7 @@ async function startWatcher(opts) {
                             middlewareMatchers: undefined,
                             projectPath: opts.dir,
                             rewrites: opts.fsChecker.rewrites
-                        }),
-                        rootPath,
-                        projectPath: (0, _normalizepath.normalizePath)(_path.default.relative(rootPath, dir))
+                        })
                     });
                 } else {
                     var _hotReloader_activeWebpackConfigs;
@@ -648,7 +723,7 @@ async function startWatcher(opts) {
                                 }
                             });
                         }
-                        if (envChange) {
+                        if (envFileChange || clientRouterFiltersChange) {
                             var _config_plugins;
                             (_config_plugins = config.plugins) == null ? void 0 : _config_plugins.forEach((plugin)=>{
                                 // we look for the DefinePlugin definitions so we can
@@ -681,23 +756,129 @@ async function startWatcher(opts) {
                     });
                 }
                 await hotReloader.invalidate({
-                    reloadAfterInvalidation: envChange
+                    // A router-filter change only requires the updated define to be
+                    // compiled into the bundles; unlike env, it can't affect rendered
+                    // output or cached data.
+                    reloadAfterInvalidation: envFileChange
                 });
             }
             if (nestedMiddleware.length > 0) {
-                _log.error(Object.defineProperty(new _utils1.NestedMiddlewareError(nestedMiddleware, dir, pagesDir || appDir), "__NEXT_ERROR_CODE", {
-                    value: "E394",
-                    enumerable: false,
-                    configurable: true
-                }).message);
+                _log.error(new _utils1.NestedMiddlewareError(nestedMiddleware, dir, pagesDir || appDir).message);
                 nestedMiddleware = [];
             }
+            // appPaths intentionally contains both pages and route handlers. The
+            // removed matcher providers classified those entries independently, so
+            // isolate pages before catch-all normalization and definition creation.
+            const appPagePaths = {};
+            for (const [route, routeAppPaths] of Object.entries(appPaths)){
+                const pageAppPaths = routeAppPaths.filter(_isapppageroute.isAppPageRoute);
+                if (pageAppPaths.length > 0) {
+                    appPagePaths[route] = pageAppPaths;
+                }
+            }
+            const { unmatchedAppPages, incompatibleParallelRouteSlots } = (0, _normalizecatchallroutes.normalizeCatchAllRoutes)(appPagePaths, undefined, {
+                strictRouteMatching: nextConfig.experimental.strictRouteMatching,
+                defaultAppPaths
+            });
+            const missingCanonicalInterceptionRoutes = nextConfig.experimental.strictRouteMatching ? (0, _interceptionroutes.findMissingCanonicalInterceptionRoutes)(appPagePaths) : [];
+            const routeMatchingErrors = [];
+            if (missingCanonicalInterceptionRoutes.length > 0) {
+                routeMatchingErrors.push(new _missingcanonicalinterceptionrouteserror.MissingCanonicalInterceptionRoutesError(missingCanonicalInterceptionRoutes));
+            }
+            if (incompatibleParallelRouteSlots.length > 0) {
+                routeMatchingErrors.push(new _incompatibleparallelrouteslotserror.IncompatibleParallelRouteSlotsError(incompatibleParallelRouteSlots.map((incompatibleRoute)=>({
+                        ...incompatibleRoute,
+                        layoutFile: _path.default.relative(dir, parallelRouteLayoutFiles.get(incompatibleRoute.layoutPath) ?? _path.default.join(appDir, incompatibleRoute.layoutPath, 'layout'))
+                    }))));
+            }
+            if (unmatchedAppPages.length > 0) {
+                routeMatchingErrors.push(new _unmatchedapppageserror.UnmatchedAppPagesError(unmatchedAppPages.map((appPath)=>{
+                    const filePath = appRouteFilePaths.get(appPath);
+                    return filePath ? (0, _normalizepathsep.normalizePathSep)(_path.default.relative(dir, filePath)) : appPath;
+                })));
+            }
+            const routeMatchingError = routeMatchingErrors[0] ?? null;
+            const routeMatchingErrorsKey = routeMatchingErrors.map((error)=>error.message).join('\n\n') || null;
+            if (numConflicting === 0 && routeMatchingErrorsKey !== null && routeMatchingErrorsKey !== previousRouteMatchingErrors) {
+                for (const error of routeMatchingErrors){
+                    _log.error(error.message);
+                }
+                const warning = (0, _strictroutematchingconfig.getStrictRouteMatchingDefaultWarning)(nextConfig);
+                if (warning) {
+                    _log.warnOnce(warning);
+                }
+            }
+            // Turbopack reports route-matching failures as app-structure issues.
+            // Webpack needs an HMR server error so dev can finish booting and surface
+            // the problem to connected clients instead of throwing from this watcher.
+            if (!opts.turbo) {
+                if (numConflicting === 0 && routeMatchingError) {
+                    hotReloader.setHmrServerError(routeMatchingError);
+                } else if (numConflicting === 0 && previousRouteMatchingErrors) {
+                    hotReloader.clearHmrServerError();
+                }
+            }
+            previousRouteMatchingErrors = routeMatchingErrorsKey;
+            for (const pageAppPaths of Object.values(appPagePaths)){
+                pageAppPaths.sort(_apppaths.compareAppPaths);
+            }
+            (0, _normalizecatchallroutes.normalizeCatchAllRoutes)(appPaths);
             // Make sure to sort parallel routes to make the result deterministic.
             serverFields.appPathRoutes = Object.fromEntries(Object.entries(appPaths).map(([k, v])=>[
                     k,
                     v.sort(_apppaths.compareAppPaths)
                 ]));
             await propagateServerField(opts, 'appPathRoutes', serverFields.appPathRoutes);
+            // fsChecker replaces the removed dev matcher providers. Refresh its
+            // definitions on every watcher pass so newly added routes can be ensured
+            // and rendered without waiting for a separate matcher reload.
+            const pageRouteDefinitions = [
+                ...pageRoutes.map(({ route, filePath })=>({
+                        kind: _routekind.RouteKind.PAGES,
+                        pathname: route,
+                        page: route,
+                        bundlePath: _path.default.posix.join('pages', (0, _normalizepagepath.normalizePagePath)(route)),
+                        filename: filePath,
+                        ...opts.nextConfig.i18n ? {
+                            i18n: {}
+                        } : undefined
+                    })),
+                ...pageApiRoutes.map(({ route, filePath })=>({
+                        kind: _routekind.RouteKind.PAGES_API,
+                        pathname: route,
+                        page: route,
+                        bundlePath: _path.default.posix.join('pages', (0, _normalizepagepath.normalizePagePath)(route)),
+                        filename: filePath,
+                        ...opts.nextConfig.i18n ? {
+                            i18n: {}
+                        } : undefined
+                    }))
+            ];
+            const appRouteDefinitions = [
+                ...Object.entries(appPagePaths).map(([route, routeAppPaths])=>{
+                    const page = (0, _apppaths.selectAppPageEntry)(route, routeAppPaths);
+                    const filePath = appRouteFilePaths.get(page);
+                    return {
+                        kind: _routekind.RouteKind.APP_PAGE,
+                        pathname: route,
+                        page,
+                        bundlePath: _path.default.posix.join('app', (0, _normalizepagepath.normalizePagePath)(page)),
+                        filename: filePath,
+                        appPaths: routeAppPaths
+                    };
+                }),
+                ...appRouteHandlers.map(({ route, page, filePath })=>{
+                    return {
+                        kind: _routekind.RouteKind.APP_ROUTE,
+                        pathname: route,
+                        page,
+                        bundlePath: _path.default.posix.join('app', (0, _normalizepagepath.normalizePagePath)(page)),
+                        filename: filePath
+                    };
+                })
+            ];
+            opts.fsChecker.setRouteDefinitions('pageFile', pageRouteDefinitions);
+            opts.fsChecker.setRouteDefinitions('appFile', appRouteDefinitions);
             // TODO: pass this to fsChecker/next-dev-server?
             serverFields.middleware = middlewareMatchers ? {
                 match: null,
@@ -730,7 +911,9 @@ async function startWatcher(opts) {
                 const sortedRoutes = (0, _utils.getSortedRoutes)(routedPages);
                 opts.fsChecker.dynamicRoutes = sortedRoutes.map((page)=>{
                     const regex = (0, _routeregex.getNamedRouteRegex)(page, {
-                        prefixRouteKeys: true
+                        prefixRouteKeys: true,
+                        includePrefix: true,
+                        includeSuffix: true
                     });
                     return {
                         regex: regex.re.toString(),
@@ -754,7 +937,7 @@ async function startWatcher(opts) {
                         match: (0, _routematcher.getRouteMatcher)({
                             // TODO: fix this in the manifest itself, must also be fixed in
                             // upstream builder that relies on this
-                            re: opts.nextConfig.i18n ? new RegExp(route.dataRouteRegex.replace(`/development/`, `/development/(?<nextLocale>[^/]+?)/`)) : new RegExp(route.dataRouteRegex),
+                            re: opts.nextConfig.i18n ? new RegExp((0, _builddataroute.addLocalePrefixToDataRouteRegex)(route.dataRouteRegex, 'development')) : new RegExp(route.dataRouteRegex),
                             groups: routeRegex.groups
                         })
                     });
@@ -763,12 +946,10 @@ async function startWatcher(opts) {
                 // For Turbopack ADDED_PAGE and REMOVED_PAGE are implemented in hot-reloader-turbopack.ts
                 // in order to avoid a race condition where ADDED_PAGE and REMOVED_PAGE are sent before Turbopack picked up the file change.
                 if (!opts.turbo) {
-                    // Reload the matchers. The filesystem would have been written to,
-                    // and the matchers need to re-scan it to update the router.
-                    // Reloading the matchers should happen before `ADDED_PAGE` or `REMOVED_PAGE` is sent over the websocket
-                    // otherwise it sends the event too early.
-                    await propagateServerField(opts, 'reloadMatchers', undefined);
-                    if (!(prevSortedRoutes == null ? void 0 : prevSortedRoutes.every((val, idx)=>val === sortedRoutes[idx]))) {
+                    const sortedRoutesChanged = prevSortedRoutes.length !== sortedRoutes.length || prevSortedRoutes.some((route, idx)=>route !== sortedRoutes[idx]);
+                    // The first aggregation has nothing to compare against, so every
+                    // route would look added to a client that is already connected.
+                    if (hasComputedSortedRoutes && sortedRoutesChanged) {
                         const addedRoutes = sortedRoutes.filter((route)=>!prevSortedRoutes.includes(route));
                         const removedRoutes = prevSortedRoutes.filter((route)=>!sortedRoutes.includes(route));
                         // emit the change so clients fetch the update
@@ -799,6 +980,7 @@ async function startWatcher(opts) {
                     }
                 }
                 prevSortedRoutes = sortedRoutes;
+                hasComputedSortedRoutes = true;
                 if (enabledTypeScript) {
                     var _nextConfig_experimental;
                     // Using === false to make the check clearer.

package/app/node_modules/next/dist/server/lib/router-utils/strict-route-matching-config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    STRICT_ROUTE_MATCHING_DEFAULT_WARNING: null,
+    getStrictRouteMatchingDefaultWarning: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    STRICT_ROUTE_MATCHING_DEFAULT_WARNING: function() {
+        return STRICT_ROUTE_MATCHING_DEFAULT_WARNING;
+    },
+    getStrictRouteMatchingDefaultWarning: function() {
+        return getStrictRouteMatchingDefaultWarning;
+    }
+});
+const STRICT_ROUTE_MATCHING_DEFAULT_WARNING = "Strict route matching is enabled by default. This validation indicates a bug in your app's route structure, but you can temporarily restore loose route matching by setting `deprecated.looseRouteMatching` to `true` in your Next.js config.";
+function getStrictRouteMatchingDefaultWarning(config) {
+    return config.experimental.strictRouteMatching ? STRICT_ROUTE_MATCHING_DEFAULT_WARNING : undefined;
+}
+
+//# sourceMappingURL=strict-route-matching-config.js.map