@semiont/frontend 0.3.2 → 0.3.4

package/standalone/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

package/standalone/node_modules/next/dist/build/segment-config/app/app-segment-config.js

@@ -24,15 +24,13 @@ const _zod = require("next/dist/compiled/zod");
 const _zod1 = require("../../../shared/lib/zod");
 const CookieSchema = _zod.z.object({
     name: _zod.z.string(),
-    value: _zod.z.string(),
-    httpOnly: _zod.z.boolean().optional(),
-    path: _zod.z.string().optional()
+    value: _zod.z.string().or(_zod.z.null())
 }).strict();
 const RuntimeSampleSchema = _zod.z.object({
     cookies: _zod.z.array(CookieSchema).optional(),
     headers: _zod.z.array(_zod.z.tuple([
         _zod.z.string(),
-        _zod.z.string()
+        _zod.z.string().or(_zod.z.null())
     ])).optional(),
     params: _zod.z.record(_zod.z.union([
         _zod.z.string(),
@@ -41,23 +39,31 @@ const RuntimeSampleSchema = _zod.z.object({
     searchParams: _zod.z.record(_zod.z.union([
         _zod.z.string(),
         _zod.z.array(_zod.z.string()),
-        _zod.z.undefined()
+        _zod.z.null()
     ])).optional()
 }).strict();
-const StaticPrefetchSchema = _zod.z.object({
-    mode: _zod.z.literal('static'),
+const InstantConfigStaticSchema = _zod.z.object({
+    prefetch: _zod.z.literal('static'),
+    samples: _zod.z.array(RuntimeSampleSchema).min(1).optional(),
     from: _zod.z.array(_zod.z.string()).optional(),
-    expectUnableToVerify: _zod.z.boolean().optional()
+    unstable_disableValidation: _zod.z.literal(true).optional(),
+    unstable_disableDevValidation: _zod.z.literal(true).optional(),
+    unstable_disableBuildValidation: _zod.z.literal(true).optional()
 }).strict();
-const RuntimePrefetchSchema = _zod.z.object({
-    mode: _zod.z.literal('runtime'),
+const InstantConfigRuntimeSchema = _zod.z.object({
+    prefetch: _zod.z.literal('runtime'),
     samples: _zod.z.array(RuntimeSampleSchema).min(1),
     from: _zod.z.array(_zod.z.string()).optional(),
-    expectUnableToVerify: _zod.z.boolean().optional()
+    unstable_disableValidation: _zod.z.literal(true).optional(),
+    unstable_disableDevValidation: _zod.z.literal(true).optional(),
+    unstable_disableBuildValidation: _zod.z.literal(true).optional()
 }).strict();
-const PrefetchSchema = _zod.z.discriminatedUnion('mode', [
-    StaticPrefetchSchema,
-    RuntimePrefetchSchema
+const InstantConfigSchema = _zod.z.union([
+    _zod.z.discriminatedUnion('prefetch', [
+        InstantConfigStaticSchema,
+        InstantConfigRuntimeSchema
+    ]),
+    _zod.z.literal(false)
 ]);
 /**
  * The schema for configuration for a page.
@@ -92,7 +98,12 @@ const PrefetchSchema = _zod.z.discriminatedUnion('mode', [
     ]).optional(),
     /**
    * How this segment should be prefetched.
-   */ unstable_prefetch: PrefetchSchema.optional(),
+   */ unstable_instant: InstantConfigSchema.optional(),
+    /**
+   * The stale time for dynamic responses in seconds.
+   * Controls how long the client-side router cache retains dynamic page data.
+   * Pages only — not allowed in layouts.
+   */ unstable_dynamicStaleTime: _zod.z.number().int().nonnegative().optional(),
     /**
    * The preferred region for the page.
    */ preferredRegion: _zod.z.union([
@@ -120,11 +131,17 @@ function parseAppSegmentConfig(data, route) {
                                 message: `Invalid revalidate value ${JSON.stringify(ctx.data)} on "${route}", must be a non-negative number or false`
                             };
                         }
-                    case 'unstable_prefetch':
+                    case 'unstable_instant':
                         {
                             return {
                                 // @TODO replace this link with a link to the docs when they are written
-                                message: `Invalid unstable_prefetch value ${JSON.stringify(ctx.data)} on "${route}", must be an object with a mode of "static" or "runtime". Read more at https://nextjs.org/docs/messages/invalid-prefetch-configuration`
+                                message: `Invalid unstable_instant value ${JSON.stringify(ctx.data)} on "${route}", must be an object with \`prefetch: "static"\` or \`prefetch: "runtime"\`, or \`false\`. Read more at https://nextjs.org/docs/messages/invalid-instant-configuration`
+                            };
+                        }
+                    case 'unstable_dynamicStaleTime':
+                        {
+                            return {
+                                message: `Invalid unstable_dynamicStaleTime value ${JSON.stringify(ctx.data)} on "${route}", must be a non-negative number`
                             };
                         }
                     default:

package/standalone/node_modules/next/dist/build/static-paths/app.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    assignErrorIfEmpty: null,
+    assignStaticShellMetadata: null,
     buildAppStaticPaths: null,
     calculateFallbackMode: null,
     filterUniqueParams: null,
@@ -17,8 +17,8 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    assignErrorIfEmpty: function() {
-        return assignErrorIfEmpty;
+    assignStaticShellMetadata: function() {
+        return assignStaticShellMetadata;
     },
     buildAppStaticPaths: function() {
         return buildAppStaticPaths;
@@ -46,6 +46,7 @@ const _createincrementalcache = require("../../export/helpers/create-incremental
 const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
 const _emptygeneratestaticparamserror = require("../../shared/lib/errors/empty-generate-static-params-error");
 const _interceptionprefixfromparamtype = require("../../shared/lib/router/utils/interception-prefix-from-param-type");
+const _implicittags = require("../../server/lib/implicit-tags");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -280,7 +281,7 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
     }
     return valid;
 }
-function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
+function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments, computeRemainingPrerenderableParams) {
     // If there are no routes to process, exit early.
     if (prerenderedRoutes.length === 0) {
         return;
@@ -391,6 +392,31 @@ function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
                     route.throwOnEmptyStaticShell = true // Should throw on empty static shell.
                     ;
                 }
+                if (computeRemainingPrerenderableParams && route.fallbackRouteParams && route.fallbackRouteParams.length > 0) {
+                    const fallbackRouteParamsByName = new Map(route.fallbackRouteParams.map((param)=>[
+                            param.paramName,
+                            param
+                        ]));
+                    const remainingPrerenderableParams = [];
+                    // Only unresolved pathname params that can still be filled by
+                    // generateStaticParams belong here. Once we hit an unresolved param
+                    // that is purely dynamic, the rest of the shell also stays dynamic
+                    // and cannot be completed into a more specific prerendered shell.
+                    for (const segment of pathnameSegments){
+                        if (route.params.hasOwnProperty(segment.paramName)) {
+                            continue;
+                        }
+                        if (!segment.hasGenerateStaticParams) {
+                            break;
+                        }
+                        const fallbackRouteParam = fallbackRouteParamsByName.get(segment.paramName);
+                        if (!fallbackRouteParam) {
+                            break;
+                        }
+                        remainingPrerenderableParams.push(fallbackRouteParam);
+                    }
+                    route.remainingPrerenderableParams = remainingPrerenderableParams.length > 0 ? remainingPrerenderableParams : undefined;
+                }
             }
         }
         // Add all children of the current node to the stack. This ensures that
@@ -400,9 +426,30 @@ function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
         }
     }
 }
-async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
+/**
+ * Calls a single generateStaticParams function within a WorkUnitStore context,
+ * making root param getters available during static param generation.
+ */ async function callGenerateStaticParams(generateStaticParams, workUnitAsyncStorage, parentParams, rootParamKeys, implicitTags) {
+    const rootParams = {};
+    for (const key of rootParamKeys){
+        if (key in parentParams) {
+            rootParams[key] = parentParams[key];
+        }
+    }
+    const workUnitStore = {
+        type: 'generate-static-params',
+        phase: 'render',
+        implicitTags,
+        rootParams
+    };
+    return workUnitAsyncStorage.run(workUnitStore, generateStaticParams, {
+        params: parentParams
+    });
+}
+async function generateRouteStaticParams(segments, store, workUnitAsyncStorage, isRoutePPREnabled, rootParamKeys) {
     // Early return if no segments to process
     if (segments.length === 0) return [];
+    const implicitTags = await (0, _implicittags.getImplicitTags)(store.page, store.page, null);
     const queue = [
         {
             segmentIndex: 0,
@@ -436,9 +483,7 @@ async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
         if (params.length > 0) {
             // Process each parent parameter combination
             for (const parentParams of params){
-                const result = await current.generateStaticParams({
-                    params: parentParams
-                });
+                const result = await callGenerateStaticParams(current.generateStaticParams, workUnitAsyncStorage, parentParams, rootParamKeys, implicitTags);
                 if (result.length > 0) {
                     // Merge parent params with each result item
                     for (const item of result){
@@ -456,9 +501,7 @@ async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
             }
         } else {
             // No parent params, call generateStaticParams with empty object
-            const result = await current.generateStaticParams({
-                params: {}
-            });
+            const result = await callGenerateStaticParams(current.generateStaticParams, workUnitAsyncStorage, {}, rootParamKeys, implicitTags);
             if (result.length === 0 && isRoutePPREnabled) {
                 (0, _emptygeneratestaticparamserror.throwEmptyGenerateStaticParamsError)();
             }
@@ -488,7 +531,7 @@ function createReplacements(segment, paramValue) {
         encodeURIComponent)
     };
 }
-async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, buildId, rootParamKeys }) {
+async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, partialFallbacksEnabled = false, buildId, rootParamKeys }) {
     if (segments.some((generate)=>{
         var _generate_config;
         return ((_generate_config = generate.config) == null ? void 0 : _generate_config.dynamicParams) === true;
@@ -533,7 +576,17 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         buildId,
         previouslyRevalidatedTags: []
     });
-    const routeParams = await ComponentMod.workAsyncStorage.run(store, generateRouteStaticParams, segments, store, isRoutePPREnabled);
+    const routeParams = await ComponentMod.workAsyncStorage.run(store, generateRouteStaticParams, segments, store, ComponentMod.workUnitAsyncStorage, isRoutePPREnabled, rootParamKeys);
+    const generatedParamNames = new Set();
+    for (const params of routeParams){
+        for (const paramName of Object.keys(params)){
+            generatedParamNames.add(paramName);
+        }
+    }
+    const prerenderablePathSegments = pathnameRouteParamSegments.map((segment)=>({
+            paramName: segment.paramName,
+            hasGenerateStaticParams: generatedParamNames.has(segment.paramName)
+        }));
     await afterRunner.executeAfter();
     let lastDynamicSegmentHadGenerateStaticParams = false;
     for (const segment of segments){
@@ -572,7 +625,7 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         var _segment_config;
         return ((_segment_config = segment.config) == null ? void 0 : _segment_config.dynamicParams) !== false;
     });
-    const supportsRoutePreGeneration = hadAllParamsGenerated || process.env.NODE_ENV === 'production';
+    const supportsRoutePreGeneration = hadAllParamsGenerated || !process.env.__NEXT_DEV_SERVER;
     const fallbackMode = dynamicParams ? supportsRoutePreGeneration ? isRoutePPREnabled ? _fallback.FallbackMode.PRERENDER : _fallback.FallbackMode.BLOCKING_STATIC_RENDER : undefined : _fallback.FallbackMode.NOT_FOUND;
     const prerenderedRoutesByPathname = new Map();
     // Convert rootParamKeys to Set for O(1) lookup.
@@ -671,7 +724,7 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
     ] : undefined;
     // Now we have to set the throwOnEmptyStaticShell for each of the routes.
     if (prerenderedRoutes && cacheComponents) {
-        assignErrorIfEmpty(prerenderedRoutes, pathnameRouteParamSegments);
+        assignStaticShellMetadata(prerenderedRoutes, prerenderablePathSegments, partialFallbacksEnabled);
     }
     return {
         fallbackMode,

package/standalone/node_modules/next/dist/build/static-paths/pages.js

@@ -38,7 +38,7 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
     const expectedReturnVal = `Expected: { paths: [], fallback: boolean }\n` + `See here for more info: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`;
     if (!staticPathsResult || typeof staticPathsResult !== 'object' || Array.isArray(staticPathsResult)) {
         throw Object.defineProperty(new Error(`Invalid value returned from getStaticPaths in ${page}. Received ${typeof staticPathsResult} ${expectedReturnVal}`), "__NEXT_ERROR_CODE", {
-            value: "E241",
+            value: "E1004",
             enumerable: false,
             configurable: true
         });
@@ -46,14 +46,14 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
     const invalidStaticPathKeys = Object.keys(staticPathsResult).filter((key)=>!(key === 'paths' || key === 'fallback'));
     if (invalidStaticPathKeys.length > 0) {
         throw Object.defineProperty(new Error(`Extra keys returned from getStaticPaths in ${page} (${invalidStaticPathKeys.join(', ')}) ${expectedReturnVal}`), "__NEXT_ERROR_CODE", {
-            value: "E38",
+            value: "E1047",
             enumerable: false,
             configurable: true
         });
     }
     if (!(typeof staticPathsResult.fallback === 'boolean' || staticPathsResult.fallback === 'blocking')) {
         throw Object.defineProperty(new Error(`The \`fallback\` key must be returned from getStaticPaths in ${page}.\n` + expectedReturnVal), "__NEXT_ERROR_CODE", {
-            value: "E243",
+            value: "E1034",
             enumerable: false,
             configurable: true
         });