@nilsr0711/drydock 0.1.0 → 0.1.1

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/output/store.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    formatTrigger: null,
+    store: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    formatTrigger: function() {
+        return formatTrigger;
+    },
+    store: function() {
+        return store;
+    }
+});
+const _unistore = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/unistore"));
+const _trace = require("../../trace");
+const _swc = require("../swc");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("./log"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const MAX_LOG_SKIP_DURATION_MS = 3000;
+function formatTrigger(trigger) {
+    // Format dynamic sitemap routes to simpler file path
+    // e.g., /sitemap.xml[] -> /sitemap.xml
+    if (trigger.includes('[__metadata_id__]')) {
+        trigger = trigger.replace('/[__metadata_id__]', '/[id]');
+    }
+    if (trigger.length > 1 && trigger.endsWith('/')) {
+        trigger = trigger.slice(0, -1);
+    }
+    return trigger;
+}
+const store = (0, _unistore.default)({
+    appUrl: null,
+    bindAddr: null,
+    bootstrap: true,
+    logging: true
+});
+let lastStore = {
+    appUrl: null,
+    bindAddr: null,
+    bootstrap: true,
+    logging: true
+};
+function hasStoreChanged(nextStore) {
+    if ([
+        ...new Set([
+            ...Object.keys(lastStore),
+            ...Object.keys(nextStore)
+        ])
+    ].every((key)=>Object.is(lastStore[key], nextStore[key]))) {
+        return false;
+    }
+    lastStore = nextStore;
+    return true;
+}
+let startTime = 0;
+let trigger = '' // default, use empty string for trigger
+;
+let triggerUrl = undefined;
+let loadingLogTimer = null;
+let traceSpan = null;
+let logging = true;
+store.subscribe((state)=>{
+    // Update persisted logging state
+    if ('logging' in state) {
+        logging = state.logging;
+    }
+    // If logging is disabled, do not log
+    if (!logging) {
+        return;
+    }
+    if (!hasStoreChanged(state)) {
+        return;
+    }
+    if (state.bootstrap) {
+        return;
+    }
+    if (state.loading) {
+        if (state.trigger) {
+            trigger = formatTrigger(state.trigger);
+            triggerUrl = state.url;
+            if (trigger !== 'initial') {
+                traceSpan = (0, _trace.trace)('compile-path', undefined, {
+                    trigger: trigger
+                });
+                if (!loadingLogTimer) {
+                    // Only log compiling if compiled is not finished quickly
+                    loadingLogTimer = setTimeout(()=>{
+                        if (triggerUrl && triggerUrl !== trigger && process.env.NEXT_TRIGGER_URL) {
+                            _log.wait(`Compiling ${trigger} (${triggerUrl}) ...`);
+                        } else {
+                            _log.wait(`Compiling ${trigger} ...`);
+                        }
+                    }, MAX_LOG_SKIP_DURATION_MS);
+                }
+            }
+        }
+        if (startTime === 0) {
+            startTime = Date.now();
+        }
+        return;
+    }
+    if (state.errors) {
+        // Log compilation errors
+        _log.error(state.errors[0]);
+        startTime = 0;
+        // Ensure traces are flushed after each compile in development mode
+        (0, _trace.flushAllTraces)();
+        (0, _swc.teardownTraceSubscriber)();
+        return;
+    }
+    let timeMessage = '';
+    if (startTime) {
+        const time = Date.now() - startTime;
+        startTime = 0;
+        timeMessage = ' ' + (time > 2000 ? `in ${Math.round(time / 100) / 10}s` : `in ${time}ms`);
+    }
+    let modulesMessage = '';
+    if (state.totalModulesCount) {
+        modulesMessage = ` (${state.totalModulesCount} modules)`;
+    }
+    if (state.warnings) {
+        _log.warn(state.warnings.join('\n\n'));
+        // Ensure traces are flushed after each compile in development mode
+        (0, _trace.flushAllTraces)();
+        (0, _swc.teardownTraceSubscriber)();
+        return;
+    }
+    if (state.typeChecking) {
+        _log.info(`bundled ${trigger}${timeMessage}${modulesMessage}, type checking...`);
+        return;
+    }
+    if (trigger === 'initial') {
+        trigger = '';
+    } else {
+        if (loadingLogTimer) {
+            clearTimeout(loadingLogTimer);
+            loadingLogTimer = null;
+        }
+        if (traceSpan) {
+            traceSpan.stop();
+            traceSpan = null;
+        }
+        trigger = '';
+    }
+    // Ensure traces are flushed after each compile in development mode
+    (0, _trace.flushAllTraces)();
+    (0, _swc.teardownTraceSubscriber)();
+});
+
+//# sourceMappingURL=store.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/polyfills/fetch/index.js

@@ -0,0 +1,6 @@
+/* globals self */ "use strict";
+const fetchModule = self.fetch.bind(self);
+module.exports = fetchModule;
+module.exports.default = module.exports;
+
+//# sourceMappingURL=index.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/polyfills/fetch/whatwg-fetch.js

@@ -0,0 +1,7 @@
+/* globals self */ "use strict";
+exports.Headers = self.Headers;
+exports.Request = self.Request;
+exports.Response = self.Response;
+exports.fetch = self.fetch;
+
+//# sourceMappingURL=whatwg-fetch.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/polyfills/object-assign.js

@@ -0,0 +1,6 @@
+"use strict";
+var assign = Object.assign.bind(Object);
+module.exports = assign;
+module.exports.default = module.exports;
+
+//# sourceMappingURL=object-assign.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/polyfills/object.assign/auto.js

@@ -0,0 +1,4 @@
+// noop
+"use strict";
+
+//# sourceMappingURL=auto.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/polyfills/object.assign/implementation.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = Object.assign;
+
+//# sourceMappingURL=implementation.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/polyfills/object.assign/polyfill.js

@@ -0,0 +1,6 @@
+"use strict";
+module.exports = function() {
+    return Object.assign;
+};
+
+//# sourceMappingURL=polyfill.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/polyfills/object.assign/shim.js

@@ -0,0 +1,6 @@
+"use strict";
+module.exports = function() {
+    return Object.assign;
+};
+
+//# sourceMappingURL=shim.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/polyfills/process.js

@@ -0,0 +1,5 @@
+"use strict";
+var _global_process, _global_process1;
+module.exports = ((_global_process = global.process) == null ? void 0 : _global_process.env) && typeof ((_global_process1 = global.process) == null ? void 0 : _global_process1.env) === 'object' ? global.process : require('next/dist/compiled/process');
+
+//# sourceMappingURL=process.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/print-build-errors.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "printBuildErrors", {
+    enumerable: true,
+    get: function() {
+        return printBuildErrors;
+    }
+});
+const _utils = require("../shared/lib/turbopack/utils");
+function printBuildErrors(entrypoints, isDev) {
+    // Issues that we want to stop the server from executing
+    const topLevelFatalIssues = [];
+    // Issues that are true errors, but we believe we can keep running and allow the user to address the issue
+    const topLevelErrors = [];
+    // Issues that are warnings but should not affect the running of the build
+    const topLevelWarnings = [];
+    // Track seen formatted error messages to avoid duplicates
+    const seenFatalIssues = new Set();
+    const seenErrors = new Set();
+    const seenWarnings = new Set();
+    for (const issue of entrypoints.issues){
+        // We only want to completely shut down the server
+        if (issue.severity === 'fatal' || issue.severity === 'bug') {
+            const formatted = (0, _utils.formatIssue)(issue);
+            if (!seenFatalIssues.has(formatted)) {
+                seenFatalIssues.add(formatted);
+                topLevelFatalIssues.push(formatted);
+            }
+        } else if ((0, _utils.isRelevantWarning)(issue)) {
+            const formatted = (0, _utils.formatIssue)(issue);
+            if (!seenWarnings.has(formatted)) {
+                seenWarnings.add(formatted);
+                topLevelWarnings.push(formatted);
+            }
+        } else if (issue.severity === 'error') {
+            const formatted = (0, _utils.formatIssue)(issue);
+            if (isDev) {
+                // We want to treat errors as recoverable in development
+                // so that we can show the errors in the site and allow users
+                // to respond to the errors when necessary. In production builds
+                // though we want to error out and stop the build process.
+                if (!seenErrors.has(formatted)) {
+                    seenErrors.add(formatted);
+                    topLevelErrors.push(formatted);
+                }
+            } else {
+                if (!seenFatalIssues.has(formatted)) {
+                    seenFatalIssues.add(formatted);
+                    topLevelFatalIssues.push(formatted);
+                }
+            }
+        }
+    }
+    // TODO: print in order by source location so issues from the same file are displayed together and then add a summary at the end about the number of warnings/errors
+    if (topLevelWarnings.length > 0) {
+        console.warn(`Turbopack build encountered ${topLevelWarnings.length} warnings:\n${topLevelWarnings.join('\n')}`);
+    }
+    if (topLevelErrors.length > 0) {
+        console.error(`Turbopack build encountered ${topLevelErrors.length} errors:\n${topLevelErrors.join('\n')}`);
+    }
+    if (topLevelFatalIssues.length > 0) {
+        throw Object.defineProperty(new Error(`Turbopack build failed with ${topLevelFatalIssues.length} errors:\n${topLevelFatalIssues.join('\n')}`), "__NEXT_ERROR_CODE", {
+            value: "E425",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+
+//# sourceMappingURL=print-build-errors.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/route-discovery.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    collectAppFiles: null,
+    collectPagesFiles: null,
+    createPagesMapping: null,
+    createRelativeFilePath: null,
+    discoverRoutes: null,
+    getPageFromPath: null,
+    processAppRoutes: null,
+    processLayoutRoutes: null,
+    processPageRoutes: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    collectAppFiles: function() {
+        return collectAppFiles;
+    },
+    collectPagesFiles: function() {
+        return collectPagesFiles;
+    },
+    createPagesMapping: function() {
+        return createPagesMapping;
+    },
+    createRelativeFilePath: function() {
+        return createRelativeFilePath;
+    },
+    discoverRoutes: function() {
+        return discoverRoutes;
+    },
+    getPageFromPath: function() {
+        return getPageFromPath;
+    },
+    processAppRoutes: function() {
+        return processAppRoutes;
+    },
+    processLayoutRoutes: function() {
+        return processLayoutRoutes;
+    },
+    processPageRoutes: function() {
+        return processPageRoutes;
+    }
+});
+const _path = require("path");
+const _findpagefile = require("../server/lib/find-page-file");
+const _recursivereaddir = require("../lib/recursive-readdir");
+const _constants = require("../lib/constants");
+const _normalizepathsep = require("../shared/lib/page-path/normalize-path-sep");
+const _apppaths = require("../shared/lib/router/utils/app-paths");
+const _ensureleadingslash = require("../shared/lib/page-path/ensure-leading-slash");
+const _pagetypes = require("../lib/page-types");
+const _fileclassifier = require("./file-classifier");
+const _getmetadataroute = require("../lib/metadata/get-metadata-route");
+const _ismetadataroute = require("../lib/metadata/is-metadata-route");
+const _getpagestaticinfo = require("./analysis/get-page-static-info");
+const _entryconstants = require("../shared/lib/entry-constants");
+const _utils = require("./utils");
+const PRIVATE_PAGES_PREFIX_REGEX = /^private-next-pages\//;
+const PRIVATE_APP_PREFIX_REGEX = /^private-next-app-dir\//;
+const SKIP_ROUTES = new Set([
+    _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY,
+    _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY
+]);
+function removeSuffix(value, suffix) {
+    return value.endsWith(suffix) ? value.slice(0, -suffix.length) : value;
+}
+/** Normalize a route for the app router */ function normalizeAppRoute(pageName) {
+    return (0, _apppaths.normalizeAppPath)((0, _normalizepathsep.normalizePathSep)(pageName));
+}
+/** Normalize a layout route (strip /layout suffix) */ function normalizeLayoutRoute(pageName) {
+    return (0, _ensureleadingslash.ensureLeadingSlash)(removeSuffix((0, _apppaths.normalizeAppPath)((0, _normalizepathsep.normalizePathSep)(pageName)), '/layout'));
+}
+function getPageFromPath(pagePath, pageExtensions) {
+    let page = (0, _normalizepathsep.normalizePathSep)(pagePath);
+    // Try longer extensions first so compound extensions like 'page.js'
+    // match before shorter ones like 'js'
+    const sorted = [
+        ...pageExtensions
+    ].sort((a, b)=>b.length - a.length);
+    for (const extension of sorted){
+        const next = removeSuffix(page, `.${extension}`);
+        if (next !== page) {
+            page = next;
+            break;
+        }
+    }
+    page = removeSuffix(page, '/index');
+    return page === '' ? '/' : page;
+}
+async function collectAppFiles(appDir, validFileMatcher) {
+    const allAppFiles = await (0, _recursivereaddir.recursiveReadDir)(appDir, {
+        pathnameFilter: (absolutePath)=>validFileMatcher.isAppRouterPage(absolutePath) || validFileMatcher.isRootNotFound(absolutePath) || validFileMatcher.isAppLayoutPage(absolutePath) || validFileMatcher.isAppDefaultPage(absolutePath),
+        ignorePartFilter: (part)=>part.startsWith('_')
+    });
+    const appPaths = allAppFiles.filter((absolutePath)=>validFileMatcher.isAppRouterPage(absolutePath) || validFileMatcher.isRootNotFound(absolutePath));
+    const layoutPaths = allAppFiles.filter((absolutePath)=>validFileMatcher.isAppLayoutPage(absolutePath));
+    const defaultPaths = allAppFiles.filter((absolutePath)=>validFileMatcher.isAppDefaultPage(absolutePath));
+    return {
+        appPaths,
+        layoutPaths,
+        defaultPaths
+    };
+}
+async function collectPagesFiles(pagesDir, validFileMatcher) {
+    return await (0, _recursivereaddir.recursiveReadDir)(pagesDir, {
+        pathnameFilter: validFileMatcher.isPageFile
+    });
+}
+function createRelativeFilePath(baseDir, filePath, prefix, isSrcDir) {
+    const privatePrefixRegex = prefix === 'pages' ? PRIVATE_PAGES_PREFIX_REGEX : PRIVATE_APP_PREFIX_REGEX;
+    const srcPrefix = isSrcDir ? 'src/' : '';
+    return (0, _path.join)(baseDir, filePath.replace(privatePrefixRegex, `${srcPrefix}${prefix}/`));
+}
+function processPageRoutes(mappedPages, baseDir, isSrcDir) {
+    const pageRoutes = [];
+    const pageApiRoutes = [];
+    for (const [route, filePath] of Object.entries(mappedPages)){
+        const relativeFilePath = createRelativeFilePath(baseDir, filePath, 'pages', isSrcDir);
+        if (route.startsWith('/api/')) {
+            pageApiRoutes.push({
+                route: (0, _normalizepathsep.normalizePathSep)(route),
+                filePath: relativeFilePath
+            });
+        } else {
+            if ((0, _utils.isReservedPage)(route)) continue;
+            pageRoutes.push({
+                route: (0, _normalizepathsep.normalizePathSep)(route),
+                filePath: relativeFilePath
+            });
+        }
+    }
+    return {
+        pageRoutes,
+        pageApiRoutes
+    };
+}
+function processAppRoutes(mappedAppPages, validFileMatcher, baseDir, isSrcDir) {
+    const appRoutes = [];
+    const appRouteHandlers = [];
+    for (const [page, filePath] of Object.entries(mappedAppPages)){
+        if (page === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY || page === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY) {
+            continue;
+        }
+        const relativeFilePath = createRelativeFilePath(baseDir, filePath, 'app', isSrcDir);
+        const route = normalizeAppRoute(page);
+        if (validFileMatcher.isAppRouterRoute(filePath)) {
+            appRouteHandlers.push({
+                route,
+                filePath: relativeFilePath
+            });
+        } else {
+            appRoutes.push({
+                route,
+                filePath: relativeFilePath
+            });
+        }
+    }
+    return {
+        appRoutes,
+        appRouteHandlers
+    };
+}
+function processLayoutRoutes(mappedAppLayouts, baseDir, isSrcDir) {
+    return Object.entries(mappedAppLayouts).map(([route, filePath])=>({
+            route: normalizeLayoutRoute(route),
+            filePath: createRelativeFilePath(baseDir, filePath, 'app', isSrcDir)
+        }));
+}
+async function createPagesMapping({ isDev, pageExtensions, pagePaths, pagesType, pagesDir, appDir, appDirOnly }) {
+    const isAppRoute = pagesType === 'app';
+    const promises = pagePaths.map(async (pagePath)=>{
+        if (pagePath.endsWith('.d.ts') && pageExtensions.includes('ts')) {
+            return;
+        }
+        let pageKey = getPageFromPath(pagePath, pageExtensions);
+        if (isAppRoute) {
+            // Turbopack encodes '_' as '%5F' in app paths; normalize to underscores.
+            pageKey = pageKey.replace(/%5F/g, '_');
+            if (pageKey === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE) {
+                pageKey = _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY;
+            }
+            if (pageKey === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE) {
+                pageKey = _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY;
+            }
+        }
+        const normalizedPath = (0, _normalizepathsep.normalizePathSep)((0, _path.join)(pagesType === _pagetypes.PAGE_TYPES.PAGES ? _constants.PAGES_DIR_ALIAS : pagesType === _pagetypes.PAGE_TYPES.APP ? _constants.APP_DIR_ALIAS : _constants.ROOT_DIR_ALIAS, pagePath));
+        let route = pagesType === _pagetypes.PAGE_TYPES.APP ? (0, _getmetadataroute.normalizeMetadataRoute)(pageKey) : pageKey;
+        if (pagesType === _pagetypes.PAGE_TYPES.APP && (0, _ismetadataroute.isMetadataRouteFile)(pagePath, pageExtensions, true)) {
+            const filePath = (0, _path.join)(appDir, pagePath);
+            const staticInfo = await (0, _getpagestaticinfo.getPageStaticInfo)({
+                nextConfig: {},
+                pageFilePath: filePath,
+                isDev,
+                page: pageKey,
+                pageType: pagesType
+            });
+            route = (0, _getmetadataroute.normalizeMetadataPageToRoute)(route, !!(staticInfo.generateImageMetadata || staticInfo.generateSitemaps));
+        }
+        return [
+            route,
+            normalizedPath
+        ];
+    });
+    const pages = Object.fromEntries((await Promise.all(promises)).filter((entry)=>entry != null));
+    switch(pagesType){
+        case _pagetypes.PAGE_TYPES.ROOT:
+            {
+                return pages;
+            }
+        case _pagetypes.PAGE_TYPES.APP:
+            {
+                const hasAppPages = Object.keys(pages).length > 0;
+                const hasAppGlobalError = !isDev && appDirOnly;
+                return {
+                    ...hasAppPages && {
+                        [_entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY]: require.resolve('next/dist/client/components/builtin/global-not-found')
+                    },
+                    ...hasAppGlobalError && {
+                        [_entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY]: require.resolve('next/dist/client/components/builtin/app-error')
+                    },
+                    ...pages
+                };
+            }
+        case _pagetypes.PAGE_TYPES.PAGES:
+            {
+                if (isDev) {
+                    delete pages['/_app'];
+                    delete pages['/_error'];
+                    delete pages['/_document'];
+                }
+                const root = isDev && pagesDir ? _constants.PAGES_DIR_ALIAS : 'next/dist/pages';
+                if (Object.keys(pages).length === 0 && !appDirOnly) {
+                    appDirOnly = true;
+                }
+                return {
+                    ...(isDev || !appDirOnly) && {
+                        '/_app': `${root}/_app`,
+                        '/_error': `${root}/_error`,
+                        '/_document': `${root}/_document`,
+                        ...pages
+                    }
+                };
+            }
+        default:
+            {
+                return {};
+            }
+    }
+}
+async function discoverRoutes(options) {
+    const { appDir, pagesDir, pageExtensions, isDev, baseDir, isSrcDir, debugBuildPaths } = options;
+    const validFileMatcher = options.validFileMatcher || (0, _findpagefile.createValidFileMatcher)(pageExtensions, appDir);
+    let appDirOnly = options.appDirOnly ?? (!!appDir && !pagesDir);
+    // Helper to reduce createPagesMapping boilerplate
+    const mapPaths = (pagePaths, pagesType)=>createPagesMapping({
+            pagePaths,
+            isDev,
+            pagesType,
+            pageExtensions,
+            pagesDir,
+            appDir,
+            appDirOnly
+        });
+    // Helper to apply debugBuildPaths filtering
+    const applyDebugFilter = (paths, debugPaths)=>{
+        if (debugPaths.length > 0) {
+            const debugPathsSet = new Set(debugPaths);
+            return paths.filter((p)=>debugPathsSet.has(p));
+        }
+        // Empty array means build none
+        return [];
+    };
+    let pageRoutes = [];
+    let pageApiRoutes = [];
+    let mappedPages;
+    let pagesPaths = [];
+    if (pagesDir && !appDirOnly) {
+        if (process.env.NEXT_PRIVATE_PAGE_PATHS) {
+            pagesPaths = JSON.parse(process.env.NEXT_PRIVATE_PAGE_PATHS);
+        } else {
+            pagesPaths = await collectPagesFiles(pagesDir, validFileMatcher);
+            if (debugBuildPaths) {
+                pagesPaths = applyDebugFilter(pagesPaths, debugBuildPaths.pages);
+            }
+        }
+        mappedPages = await mapPaths(pagesPaths, _pagetypes.PAGE_TYPES.PAGES);
+        // Update appDirOnly if no user page routes were found, so the
+        // subsequent app mapping can emit the global error entry.
+        if (Object.keys(mappedPages).length === 0) {
+            appDirOnly = true;
+        }
+        ;
+        ({ pageRoutes, pageApiRoutes } = processPageRoutes(mappedPages, baseDir, !!isSrcDir));
+    }
+    let appRoutes = [];
+    let appRouteHandlers = [];
+    let layoutRoutes = [];
+    let slots = [];
+    let mappedAppPages;
+    let mappedAppLayouts;
+    if (appDir) {
+        let appPaths;
+        let layoutPaths;
+        let defaultPaths;
+        if (process.env.NEXT_PRIVATE_APP_PATHS) {
+            // Used for testing — override collected app paths
+            appPaths = JSON.parse(process.env.NEXT_PRIVATE_APP_PATHS);
+            layoutPaths = [];
+            defaultPaths = [];
+        } else {
+            const result = await collectAppFiles(appDir, validFileMatcher);
+            appPaths = result.appPaths;
+            layoutPaths = result.layoutPaths;
+            defaultPaths = result.defaultPaths;
+            if (debugBuildPaths) {
+                appPaths = applyDebugFilter(appPaths, debugBuildPaths.app);
+            }
+        }
+        // Map all app file types in parallel
+        let mappedDefaultFiles;
+        [mappedAppPages, mappedAppLayouts, mappedDefaultFiles] = await Promise.all([
+            mapPaths(appPaths, _pagetypes.PAGE_TYPES.APP),
+            mapPaths(layoutPaths, _pagetypes.PAGE_TYPES.APP),
+            mapPaths(defaultPaths, _pagetypes.PAGE_TYPES.APP)
+        ]);
+        // Extract slots from pages and default files
+        slots = (0, _fileclassifier.combineSlots)((0, _fileclassifier.extractSlotsFromRoutes)(mappedAppPages, SKIP_ROUTES), (0, _fileclassifier.extractSlotsFromRoutes)(mappedDefaultFiles));
+        ({ appRoutes, appRouteHandlers } = processAppRoutes(mappedAppPages, validFileMatcher, baseDir, !!isSrcDir));
+        layoutRoutes = processLayoutRoutes(mappedAppLayouts, baseDir, !!isSrcDir);
+    }
+    return {
+        appRoutes,
+        appRouteHandlers,
+        layoutRoutes,
+        slots,
+        pageRoutes,
+        pageApiRoutes,
+        mappedAppPages,
+        mappedAppLayouts,
+        mappedPages,
+        pagesPaths,
+        appDirOnly
+    };
+}
+
+//# sourceMappingURL=route-discovery.js.map