@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/build/define-env.js

@@ -17,12 +17,13 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+const DEFINE_ENV_EXPRESSION = Symbol('DEFINE_ENV_EXPRESSION');
 /**
  * Serializes the DefineEnv config so that it can be inserted into the code by Webpack/Turbopack, JSON stringifies each value.
  */ function serializeDefineEnv(defineEnv) {
     const defineEnvStringified = Object.fromEntries(Object.entries(defineEnv).map(([key, value])=>[
             key,
-            JSON.stringify(value)
+            typeof value === 'object' && DEFINE_ENV_EXPRESSION in value ? value[DEFINE_ENV_EXPRESSION] : JSON.stringify(value)
         ]));
     return defineEnvStringified;
 }
@@ -48,7 +49,7 @@ function getImageConfig(config, dev) {
     };
 }
 function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir, projectPath, fetchCacheKeyPrefix, hasRewrites, isClient, isEdgeServer, isNodeServer, middlewareMatchers, omitNonDeterministic, rewrites }) {
-    var _config_experimental, _config_experimental1, _config_experimental2, _config_experimental_staleTimes, _config_experimental_staleTimes1, _config_experimental_staleTimes2, _config_experimental_staleTimes3, _config_i18n, _config_compiler;
+    var _config_experimental, _config_experimental1, _config_experimental_staleTimes, _config_experimental_staleTimes1, _config_experimental_staleTimes2, _config_experimental_staleTimes3, _config_i18n, _config_compiler;
     const nextPublicEnv = (0, _staticenv.getNextPublicEnvironmentVariables)();
     const nextConfigEnv = (0, _staticenv.getNextConfigEnv)(config);
     const isPPREnabled = (0, _ppr.checkIsAppPPREnabled)(config.experimental.ppr);
@@ -72,23 +73,33 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         'process.turbopack': isTurbopack,
         'process.env.TURBOPACK': isTurbopack,
         'process.env.__NEXT_BUNDLER': isTurbopack ? 'Turbopack' : process.env.NEXT_RSPACK ? 'Rspack' : 'Webpack',
-        // minimal mode is enforced when an adapter is configured
-        'process.env.MINIMAL_MODE': Boolean(config.experimental.adapterPath),
         // TODO: enforce `NODE_ENV` on `process.env`, and add a test:
         'process.env.NODE_ENV': dev || config.experimental.allowDevelopmentBuild ? 'development' : 'production',
+        'process.env.__NEXT_DEV_SERVER': dev ? '1' : '',
         'process.env.NEXT_RUNTIME': isEdgeServer ? 'edge' : isNodeServer ? 'nodejs' : '',
         'process.env.NEXT_MINIMAL': '',
         'process.env.__NEXT_APP_NAV_FAIL_HANDLING': Boolean(config.experimental.appNavFailHandling),
+        'process.env.__NEXT_APP_NEW_SCROLL_HANDLER': Boolean(config.experimental.appNewScrollHandler),
         'process.env.__NEXT_PPR': isPPREnabled,
         'process.env.__NEXT_CACHE_COMPONENTS': isCacheComponentsEnabled,
+        'process.env.__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS': Boolean(config.experimental.cachedNavigations),
+        'process.env.__NEXT_INSTANT_NAV_TOGGLE': !!config.experimental.instantNavigationDevToolsToggle,
         'process.env.__NEXT_USE_CACHE': isUseCacheEnabled,
-        ...isClient ? {
-            // TODO use `globalThis.NEXT_DEPLOYMENT_ID` on client to still support accessing
-            // process.env.NEXT_DEPLOYMENT_ID in userland
-            'process.env.NEXT_DEPLOYMENT_ID': ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useSkewCookie) ? false : config.deploymentId || false
+        'process.env.NEXT_IMMUTABLE_ASSET_TOKEN': config.experimental.immutableAssetToken || '',
+        ...((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useSkewCookie) || !config.deploymentId ? {
+            'process.env.NEXT_DEPLOYMENT_ID': false
+        } : isClient ? isTurbopack ? {
+            // This is set at runtime by packages/next/src/client/register-deployment-id-global.ts
+            'process.env.NEXT_DEPLOYMENT_ID': {
+                [DEFINE_ENV_EXPRESSION]: 'globalThis.NEXT_DEPLOYMENT_ID'
+            }
+        } : {
+            // For Webpack, we currently don't use the non-inlining globalThis.NEXT_DEPLOYMENT_ID
+            // approach because we cannot forward this global variable to web workers easily.
+            'process.env.NEXT_DEPLOYMENT_ID': config.deploymentId || false
         } : ((_config_experimental1 = config.experimental) == null ? void 0 : _config_experimental1.runtimeServerDeploymentId) ? {
         } : {
-            'process.env.NEXT_DEPLOYMENT_ID': ((_config_experimental2 = config.experimental) == null ? void 0 : _config_experimental2.useSkewCookie) ? false : config.deploymentId || false
+            'process.env.NEXT_DEPLOYMENT_ID': config.deploymentId || false
         },
         // Propagates the `__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING` environment
         // variable to the client.
@@ -106,6 +117,7 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         'process.env.__NEXT_CLIENT_ROUTER_D_FILTER': (clientRouterFilters == null ? void 0 : clientRouterFilters.dynamicFilter) ?? false,
         'process.env.__NEXT_CLIENT_VALIDATE_RSC_REQUEST_HEADERS': Boolean(config.experimental.validateRSCRequestHeaders),
         'process.env.__NEXT_DYNAMIC_ON_HOVER': Boolean(config.experimental.dynamicOnHover),
+        'process.env.__NEXT_PREFETCH_INLINING': Boolean(config.experimental.prefetchInlining),
         'process.env.__NEXT_OPTIMISTIC_CLIENT_CACHE': config.experimental.optimisticClientCache ?? true,
         'process.env.__NEXT_MIDDLEWARE_PREFETCH': config.experimental.proxyPrefetch ?? 'flexible',
         'process.env.__NEXT_CROSS_ORIGIN': config.crossOrigin,
@@ -165,7 +177,7 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
             'process.env.__NEXT_RELATIVE_DIST_DIR': config.distDir,
             'process.env.__NEXT_RELATIVE_PROJECT_DIR': _nodepath.default.relative(process.cwd(), projectPath)
         } : {},
-        'process.env.__NEXT_BROWSER_DEBUG_INFO_IN_TERMINAL': JSON.stringify(config.experimental.browserDebugInfoInTerminal || false),
+        'process.env.__NEXT_BROWSER_DEBUG_INFO_IN_TERMINAL': JSON.stringify(config.logging && config.logging.browserToTerminal || false),
         'process.env.__NEXT_MCP_SERVER': !!config.experimental.mcpServer,
         // The devtools need to know whether or not to show an option to clear the
         // bundler cache. This option may be removed later once Turbopack's
@@ -181,7 +193,13 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         // no-op that just restarts the development server.
         'process.env.__NEXT_BUNDLER_HAS_PERSISTENT_CACHE': !isTurbopack || (config.experimental.turbopackFileSystemCacheForDev ?? false),
         'process.env.__NEXT_REACT_DEBUG_CHANNEL': config.experimental.reactDebugChannel ?? false,
-        'process.env.__NEXT_TRANSITION_INDICATOR': config.experimental.transitionIndicator ?? false
+        'process.env.__NEXT_TRANSITION_INDICATOR': config.experimental.transitionIndicator ?? false,
+        'process.env.__NEXT_GESTURE_TRANSITION': config.experimental.gestureTransition ?? false,
+        'process.env.__NEXT_OPTIMISTIC_ROUTING': config.experimental.optimisticRouting ?? false,
+        'process.env.__NEXT_VARY_PARAMS': config.experimental.varyParams ?? false,
+        'process.env.__NEXT_EXPOSE_TESTING_API': dev || config.experimental.exposeTestingApiInProductionBuild === true,
+        'process.env.__NEXT_CACHE_LIFE': config.cacheLife,
+        'process.env.__NEXT_CLIENT_PARAM_PARSING_ORIGINS': config.experimental.clientParamParsingOrigins || []
     };
     const userDefines = ((_config_compiler = config.compiler) == null ? void 0 : _config_compiler.define) ?? {};
     for(const key in userDefines){

package/standalone/node_modules/next/dist/build/duration-to-string.js

@@ -57,7 +57,7 @@ function durationToString(compilerDuration) {
     } else if (compilerDuration > SECONDS_THRESHOLD_LOW) {
         return `${compilerDuration.toFixed(1)}s`;
     } else {
-        return `${(compilerDuration * MILLISECONDS_PER_SECOND).toFixed(1)}ms`;
+        return `${(compilerDuration * MILLISECONDS_PER_SECOND).toFixed(0)}ms`;
     }
 }
 /**

package/standalone/node_modules/next/dist/build/entries.js

@@ -3,14 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    collectAppFiles: null,
-    collectPagesFiles: null,
-    combineSlots: null,
     createEntrypoints: null,
-    createPagesMapping: null,
-    createRelativeFilePath: null,
-    extractSlotsFromAppRoutes: null,
-    extractSlotsFromDefaultFiles: null,
     finalizeEntrypoint: null,
     getAppEntry: null,
     getAppLoader: null,
@@ -18,10 +11,7 @@ Object.defineProperty(exports, "__esModule", {
     getEdgeServerEntry: null,
     getInstrumentationEntry: null,
     getPageFilePath: null,
-    getPageFromPath: null,
-    processAppRoutes: null,
-    processLayoutRoutes: null,
-    processPageRoutes: null,
+    isDeferredEntry: null,
     runDependingOnPageType: null
 });
 function _export(target, all) {
@@ -31,30 +21,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    collectAppFiles: function() {
-        return collectAppFiles;
-    },
-    collectPagesFiles: function() {
-        return collectPagesFiles;
-    },
-    combineSlots: function() {
-        return combineSlots;
-    },
     createEntrypoints: function() {
         return createEntrypoints;
     },
-    createPagesMapping: function() {
-        return createPagesMapping;
-    },
-    createRelativeFilePath: function() {
-        return createRelativeFilePath;
-    },
-    extractSlotsFromAppRoutes: function() {
-        return extractSlotsFromAppRoutes;
-    },
-    extractSlotsFromDefaultFiles: function() {
-        return extractSlotsFromDefaultFiles;
-    },
     finalizeEntrypoint: function() {
         return finalizeEntrypoint;
     },
@@ -76,17 +45,8 @@ _export(exports, {
     getPageFilePath: function() {
         return getPageFilePath;
     },
-    getPageFromPath: function() {
-        return getPageFromPath;
-    },
-    processAppRoutes: function() {
-        return processAppRoutes;
-    },
-    processLayoutRoutes: function() {
-        return processLayoutRoutes;
-    },
-    processPageRoutes: function() {
-        return processPageRoutes;
+    isDeferredEntry: function() {
+        return isDeferredEntry;
     },
     runDependingOnPageType: function() {
         return runDependingOnPageType;
@@ -99,175 +59,18 @@ const _isapiroute = require("../lib/is-api-route");
 const _isedgeruntime = require("../lib/is-edge-runtime");
 const _constants1 = require("../shared/lib/constants");
 const _utils = require("./utils");
-const _getpagestaticinfo = require("./analysis/get-page-static-info");
-const _normalizepathsep = require("../shared/lib/page-path/normalize-path-sep");
 const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path");
 const _apppaths = require("../shared/lib/router/utils/app-paths");
 const _nextmiddlewareloader = require("./webpack/loaders/next-middleware-loader");
 const _isapprouteroute = require("../lib/is-app-route-route");
-const _getmetadataroute = require("../lib/metadata/get-metadata-route");
 const _nextrouteloader = require("./webpack/loaders/next-route-loader");
 const _isinternalcomponent = require("../lib/is-internal-component");
-const _ismetadataroute = require("../lib/metadata/is-metadata-route");
 const _routekind = require("../server/route-kind");
 const _utils1 = require("./webpack/loaders/utils");
 const _normalizecatchallroutes = require("./normalize-catchall-routes");
 const _pagetypes = require("../lib/page-types");
-const _recursivereaddir = require("../lib/recursive-readdir");
-const _segment = require("../shared/lib/segment");
-const _ensureleadingslash = require("../shared/lib/page-path/ensure-leading-slash");
-const _entryconstants = require("../shared/lib/entry-constants");
 const _getstaticinfoincludinglayouts = require("./get-static-info-including-layouts");
-async function collectAppFiles(appDir, validFileMatcher) {
-    // Collect app pages, layouts, and default files in a single directory traversal
-    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('_')
-    });
-    // Separate app pages, layouts, and defaults
-    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 (0, _recursivereaddir.recursiveReadDir)(pagesDir, {
-        pathnameFilter: validFileMatcher.isPageFile
-    });
-}
-function createRelativeFilePath(baseDir, filePath, prefix, isSrcDir) {
-    const privatePrefix = prefix === 'pages' ? 'private-next-pages' : 'private-next-app-dir';
-    const srcPrefix = isSrcDir ? 'src/' : '';
-    return (0, _path.join)(baseDir, filePath.replace(new RegExp(`^${privatePrefix}/`), `${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 {
-            // Filter out _app, _error, _document
-            if ((0, _utils.isReservedPage)(route)) continue;
-            pageRoutes.push({
-                route: (0, _normalizepathsep.normalizePathSep)(route),
-                filePath: relativeFilePath
-            });
-        }
-    }
-    return {
-        pageRoutes,
-        pageApiRoutes
-    };
-}
-function extractSlotsFromAppRoutes(mappedAppPages) {
-    const slots = [];
-    for (const [page] of Object.entries(mappedAppPages)){
-        if (page === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY || page === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY) {
-            continue;
-        }
-        const segments = page.split('/');
-        for(let i = segments.length - 1; i >= 0; i--){
-            const segment = segments[i];
-            if ((0, _segment.isParallelRouteSegment)(segment)) {
-                const parentPath = (0, _apppaths.normalizeAppPath)(segments.slice(0, i).join('/'));
-                const slotName = segment.slice(1);
-                // Check if the slot already exists
-                if (slots.some((s)=>s.name === slotName && s.parent === parentPath)) continue;
-                slots.push({
-                    name: slotName,
-                    parent: parentPath
-                });
-                break;
-            }
-        }
-    }
-    return slots;
-}
-function extractSlotsFromDefaultFiles(mappedDefaultFiles) {
-    const slots = [];
-    for (const [route] of Object.entries(mappedDefaultFiles)){
-        const segments = route.split('/');
-        for(let i = segments.length - 1; i >= 0; i--){
-            const segment = segments[i];
-            if ((0, _segment.isParallelRouteSegment)(segment)) {
-                const parentPath = (0, _apppaths.normalizeAppPath)(segments.slice(0, i).join('/'));
-                const slotName = segment.slice(1);
-                // Check if the slot already exists
-                if (slots.some((s)=>s.name === slotName && s.parent === parentPath)) continue;
-                slots.push({
-                    name: slotName,
-                    parent: parentPath
-                });
-                break;
-            }
-        }
-    }
-    return slots;
-}
-function combineSlots(...slotArrays) {
-    const slotSet = new Set();
-    const result = [];
-    for (const slots of slotArrays){
-        for (const slot of slots){
-            const key = `${slot.name}:${slot.parent}`;
-            if (!slotSet.has(key)) {
-                slotSet.add(key);
-                result.push(slot);
-            }
-        }
-    }
-    return result;
-}
-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);
-        if (validFileMatcher.isAppRouterRoute(filePath)) {
-            appRouteHandlers.push({
-                route: (0, _apppaths.normalizeAppPath)((0, _normalizepathsep.normalizePathSep)(page)),
-                filePath: relativeFilePath
-            });
-        } else {
-            appRoutes.push({
-                route: (0, _apppaths.normalizeAppPath)((0, _normalizepathsep.normalizePathSep)(page)),
-                filePath: relativeFilePath
-            });
-        }
-    }
-    return {
-        appRoutes,
-        appRouteHandlers
-    };
-}
-function processLayoutRoutes(mappedAppLayouts, baseDir, isSrcDir) {
-    const layoutRoutes = [];
-    for (const [route, filePath] of Object.entries(mappedAppLayouts)){
-        const relativeFilePath = createRelativeFilePath(baseDir, filePath, 'app', isSrcDir);
-        layoutRoutes.push({
-            route: (0, _ensureleadingslash.ensureLeadingSlash)((0, _apppaths.normalizeAppPath)((0, _normalizepathsep.normalizePathSep)(route)).replace(/\/layout$/, '')),
-            filePath: relativeFilePath
-        });
-    }
-    return layoutRoutes;
-}
-function getPageFromPath(pagePath, pageExtensions) {
-    let page = (0, _normalizepathsep.normalizePathSep)(pagePath.replace(new RegExp(`\\.+(${pageExtensions.join('|')})$`), ''));
-    page = page.replace(/\/index$/, '');
-    return page === '' ? '/' : page;
-}
+const _routediscovery = require("./route-discovery");
 function getPageFilePath({ absolutePagePath, pagesDir, appDir, rootDir }) {
     if (absolutePagePath.startsWith(_constants.PAGES_DIR_ALIAS) && pagesDir) {
         return absolutePagePath.replace(_constants.PAGES_DIR_ALIAS, pagesDir);
@@ -280,98 +83,29 @@ function getPageFilePath({ absolutePagePath, pagesDir, appDir, rootDir }) {
     }
     return require.resolve(absolutePagePath);
 }
-async function createPagesMapping({ isDev, pageExtensions, pagePaths, pagesType, pagesDir, appDir, appDirOnly }) {
-    const isAppRoute = pagesType === 'app';
-    const promises = pagePaths.map(async (pagePath)=>{
-        // Do not process .d.ts files as routes
-        if (pagePath.endsWith('.d.ts') && pageExtensions.includes('ts')) {
-            return;
-        }
-        let pageKey = getPageFromPath(pagePath, pageExtensions);
-        if (isAppRoute) {
-            pageKey = pageKey.replace(/%5F/g, '_');
-            if (pageKey === _constants1.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;
-            }
+function isDeferredEntry(page, deferredEntries) {
+    if (!deferredEntries || deferredEntries.length === 0) {
+        return false;
+    }
+    // Normalize the page path
+    const normalizedPage = page.startsWith('/') ? page : `/${page}`;
+    for (const pattern of deferredEntries){
+        // Normalize the pattern
+        const normalizedPattern = pattern.startsWith('/') ? pattern : `/${pattern}`;
+        // Check for exact match or prefix match for directories
+        if (normalizedPage === normalizedPattern) {
+            return true;
         }
-        const normalizedPath = (0, _normalizepathsep.normalizePathSep)((0, _path.join)(pagesType === 'pages' ? _constants.PAGES_DIR_ALIAS : pagesType === 'app' ? _constants.APP_DIR_ALIAS : _constants.ROOT_DIR_ALIAS, pagePath));
-        let route = pagesType === 'app' ? (0, _getmetadataroute.normalizeMetadataRoute)(pageKey) : pageKey;
-        if (pagesType === '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));
+        // Check if the page is under the deferred directory
+        if (normalizedPage.startsWith(normalizedPattern + '/')) {
+            return true;
         }
-        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;
-                // Whether to emit App router 500.html entry, which only presents in production and only app router presents
-                const hasAppGlobalError = !isDev && appDirOnly;
-                return {
-                    // If there's any app pages existed, add a default /_not-found route as 404.
-                    // If there's any custom /_not-found page, it will override the default one.
-                    ...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'];
-                }
-                // In development we always alias these to allow Webpack to fallback to
-                // the correct source file so that HMR can work properly when a file is
-                // added or removed.
-                const root = isDev && pagesDir ? _constants.PAGES_DIR_ALIAS : 'next/dist/pages';
-                // If there are no user pages routes, treat this as app-dir-only mode.
-                // The pages/ folder could be present and the initial appDirOnly is treated as false, but no valid routes are found.
-                if (Object.keys(pages).length === 0 && !appDirOnly) {
-                    appDirOnly = true;
-                }
-                return {
-                    // Don't add default pages entries if this is an app-router-only build
-                    ...(isDev || !appDirOnly) && {
-                        '/_app': `${root}/_app`,
-                        '/_error': `${root}/_error`,
-                        '/_document': `${root}/_document`,
-                        ...pages
-                    }
-                };
-            }
-        default:
-            {
-                return {};
-            }
     }
+    return false;
 }
 function getEdgeServerEntry(opts) {
     var _opts_config_experimental_sri;
+    const cacheHandler = opts.config.cacheHandler || undefined;
     if (opts.pagesType === 'app' && (0, _isapprouteroute.isAppRouteRoute)(opts.page) && opts.appDirLoader) {
         const loaderParams = {
             absolutePagePath: opts.absolutePagePath,
@@ -379,7 +113,10 @@ function getEdgeServerEntry(opts) {
             appDirLoader: Buffer.from(opts.appDirLoader || '').toString('base64'),
             preferredRegion: opts.preferredRegion,
             middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64'),
-            cacheHandlers: JSON.stringify(opts.config.cacheHandlers || {})
+            cacheHandlers: JSON.stringify(opts.config.cacheHandlers || {}),
+            ...cacheHandler ? {
+                cacheHandler
+            } : {}
         };
         return {
             import: `next-edge-app-route-loader?${(0, _querystring.stringify)(loaderParams)}!`,
@@ -394,7 +131,10 @@ function getEdgeServerEntry(opts) {
             rootDir: opts.rootDir,
             matchers: ((_opts_middleware = opts.middleware) == null ? void 0 : _opts_middleware.matchers) ? (0, _nextmiddlewareloader.encodeMatchers)(opts.middleware.matchers) : '',
             preferredRegion: opts.preferredRegion,
-            middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64')
+            middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64'),
+            ...cacheHandler ? {
+                cacheHandler
+            } : {}
         };
         return {
             import: `next-middleware-loader?${(0, _querystring.stringify)(loaderParams)}!`,
@@ -408,7 +148,10 @@ function getEdgeServerEntry(opts) {
             page: opts.page,
             rootDir: opts.rootDir,
             preferredRegion: opts.preferredRegion,
-            middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64')
+            middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64'),
+            ...cacheHandler ? {
+                cacheHandler
+            } : {}
         };
         return {
             import: `next-edge-function-loader?${(0, _querystring.stringify)(loaderParams)}!`,
@@ -427,11 +170,13 @@ function getEdgeServerEntry(opts) {
         pagesType: opts.pagesType,
         appDirLoader: Buffer.from(opts.appDirLoader || '').toString('base64'),
         sriEnabled: !opts.isDev && !!((_opts_config_experimental_sri = opts.config.experimental.sri) == null ? void 0 : _opts_config_experimental_sri.algorithm),
-        cacheHandler: opts.config.cacheHandler,
         preferredRegion: opts.preferredRegion,
         middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64'),
         serverActions: opts.config.experimental.serverActions,
-        cacheHandlers: JSON.stringify(opts.config.cacheHandlers || {})
+        cacheHandlers: JSON.stringify(opts.config.cacheHandlers || {}),
+        ...cacheHandler ? {
+            cacheHandler
+        } : {}
     };
     return {
         import: `next-edge-ssr-loader?${JSON.stringify(loaderParams)}!`,
@@ -523,7 +268,8 @@ function runDependingOnPageType(params) {
     return;
 }
 async function createEntrypoints(params) {
-    const { config, pages, pagesDir, isDev, rootDir, rootPaths, appDir, appPaths, pageExtensions } = params;
+    const { config, pages, pagesDir, isDev, rootDir, rootPaths, appDir, appPaths, pageExtensions, deferredEntriesFilter } = params;
+    const deferredEntries = config.experimental.deferredEntries;
     const edgeServer = {};
     const server = {};
     const client = {};
@@ -537,17 +283,29 @@ async function createEntrypoints(params) {
                 appPathsPerRoute[normalizedPath] = [];
             }
             appPathsPerRoute[normalizedPath].push(// TODO-APP: refactor to pass the page path from createPagesMapping instead.
-            getPageFromPath(actualPath, pageExtensions).replace(_constants.APP_DIR_ALIAS, ''));
+            (0, _routediscovery.getPageFromPath)(actualPath, pageExtensions).replace(_constants.APP_DIR_ALIAS, ''));
         }
         // TODO: find a better place to do this
         (0, _normalizecatchallroutes.normalizeCatchAllRoutes)(appPathsPerRoute);
         // Make sure to sort parallel routes to make the result deterministic.
         appPathsPerRoute = Object.fromEntries(Object.entries(appPathsPerRoute).map(([k, v])=>[
                 k,
-                v.sort()
+                v.sort(_apppaths.compareAppPaths)
             ]));
     }
     const getEntryHandler = (mappings, pagesType)=>async (page)=>{
+            // Apply deferred entries filter if specified
+            if (deferredEntriesFilter) {
+                const isDeferred = isDeferredEntry(page, deferredEntries);
+                if (deferredEntriesFilter === 'exclude' && isDeferred) {
+                    // Skip deferred entries when excluding them
+                    return;
+                }
+                if (deferredEntriesFilter === 'only' && !isDeferred) {
+                    // Skip non-deferred entries when only including deferred ones
+                    return;
+                }
+            }
             const bundleFile = (0, _normalizepagepath.normalizePagePath)(page);
             const clientBundlePath = _path.posix.join(pagesType, bundleFile);
             const serverBundlePath = pagesType === _pagetypes.PAGE_TYPES.PAGES ? _path.posix.join('pages', bundleFile) : pagesType === _pagetypes.PAGE_TYPES.APP ? _path.posix.join('app', bundleFile) : bundleFile.slice(1);
@@ -605,6 +363,7 @@ async function createEntrypoints(params) {
                             pagePath: absolutePagePath,
                             appDir,
                             appPaths: matchedAppPaths,
+                            allNormalizedAppPaths: Object.keys(appPathsPerRoute),
                             pageExtensions,
                             basePath: config.basePath,
                             assetPrefix: config.assetPrefix,
@@ -677,6 +436,7 @@ async function createEntrypoints(params) {
                                 pagePath: absolutePagePath,
                                 appDir: appDir,
                                 appPaths: matchedAppPaths,
+                                allNormalizedAppPaths: Object.keys(appPathsPerRoute),
                                 pageExtensions,
                                 basePath: config.basePath,
                                 assetPrefix: config.assetPrefix,

package/standalone/node_modules/next/dist/build/file-classifier.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    addSlotIfNew: null,
+    combineSlots: null,
+    extractSlotFromPath: null,
+    extractSlotsFromRoutes: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    addSlotIfNew: function() {
+        return addSlotIfNew;
+    },
+    combineSlots: function() {
+        return combineSlots;
+    },
+    extractSlotFromPath: function() {
+        return extractSlotFromPath;
+    },
+    extractSlotsFromRoutes: function() {
+        return extractSlotsFromRoutes;
+    }
+});
+const _apppaths = require("../shared/lib/router/utils/app-paths");
+const _segment = require("../shared/lib/segment");
+function extractSlotFromPath(pagePath) {
+    const segments = pagePath.split('/');
+    for(let i = segments.length - 1; i >= 0; i--){
+        const segment = segments[i];
+        if ((0, _segment.isParallelRouteSegment)(segment)) {
+            return {
+                name: segment.slice(1),
+                parent: (0, _apppaths.normalizeAppPath)(segments.slice(0, i).join('/'))
+            };
+        }
+    }
+    return undefined;
+}
+function addSlotIfNew(slots, pagePath) {
+    const slot = extractSlotFromPath(pagePath);
+    if (!slot) return false;
+    if (slots.some((s)=>s.name === slot.name && s.parent === slot.parent)) return false;
+    slots.push(slot);
+    return true;
+}
+function extractSlotsFromRoutes(routes, skipRoutes) {
+    const slots = [];
+    for (const [route] of Object.entries(routes)){
+        if (skipRoutes == null ? void 0 : skipRoutes.has(route)) continue;
+        addSlotIfNew(slots, route);
+    }
+    return slots;
+}
+function combineSlots(...slotArrays) {
+    const slotSet = new Set();
+    const result = [];
+    for (const slots of slotArrays){
+        for (const slot of slots){
+            const key = `${slot.name}:${slot.parent}`;
+            if (!slotSet.has(key)) {
+                slotSet.add(key);
+                result.push(slot);
+            }
+        }
+    }
+    return result;
+}
+
+//# sourceMappingURL=file-classifier.js.map