@evoscientist/webui 0.2.5 → 0.2.6

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

@@ -76,16 +76,21 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         // 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_DISABLE_DEV_OVERLAY_UX': process.env.NEXT_PRIVATE_DISABLE_DEV_OVERLAY_UX === '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_TURBOPACK_SHARED_RUNTIME': Boolean(config.experimental.turbopackSharedRuntime),
         '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_INSTANT_NAV_TOGGLE': isCacheComponentsEnabled,
+        'process.env.__NEXT_EXPERIMENTAL_COLD_CACHE_BADGE': Boolean(config.experimental.coldCacheBadge),
+        'process.env.__NEXT_REQUEST_INSIGHTS': dev && !!config.experimental.requestInsights,
         'process.env.__NEXT_USE_CACHE': isUseCacheEnabled,
-        'process.env.NEXT_IMMUTABLE_ASSET_TOKEN': config.experimental.immutableAssetToken || '',
+        'process.env.__NEXT_USE_NODE_STREAMS': isEdgeServer ? false : true,
+        'process.env.NEXT_SUPPORTS_IMMUTABLE_ASSETS': config.supportsImmutableAssets || false,
         ...((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useSkewCookie) || !config.deploymentId ? {
             'process.env.NEXT_DEPLOYMENT_ID': false
         } : isClient ? isTurbopack ? {
@@ -116,7 +121,9 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         'process.env.__NEXT_CLIENT_ROUTER_S_FILTER': (clientRouterFilters == null ? void 0 : clientRouterFilters.staticFilter) ?? false,
         '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_SERVER_COMPONENTS_HMR_CANCELLATION': Boolean(config.experimental.serverComponentsHmrCancellation),
         'process.env.__NEXT_DYNAMIC_ON_HOVER': Boolean(config.experimental.dynamicOnHover),
+        'process.env.__NEXT_USE_OFFLINE': Boolean(config.experimental.useOffline),
         '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',
@@ -196,6 +203,7 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         '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_INSTRUMENTATION_CLIENT_ROUTER_TRANSITION_EVENTS': config.experimental.instrumentationClientRouterTransitionEvents ?? 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,

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

@@ -38,7 +38,6 @@ const MILLISECONDS_PER_SECOND = 1000;
 // Time thresholds and conversion factors for nanoseconds
 const NANOSECONDS_PER_SECOND = 1000000000;
 const NANOSECONDS_PER_MILLISECOND = 1000000;
-const NANOSECONDS_PER_MICROSECOND = 1000;
 const NANOSECONDS_IN_MINUTE = 60000000000 // 60 * 1_000_000_000
 ;
 const MINUTES_THRESHOLD_NANOSECONDS = 120000000000 // 2 minutes in nanoseconds
@@ -67,7 +66,7 @@ function durationToString(compilerDuration) {
  * - >= 40 seconds: show in whole seconds (e.g., "45s")
  * - >= 2 seconds: show in seconds with 1 decimal place (e.g., "3.2s")
  * - >= 2 milliseconds: show in whole milliseconds (e.g., "250ms")
- * - < 2 milliseconds: show in whole microseconds (e.g., "500µs")
+ * - < 2 milliseconds: show in milliseconds with 1 decimal place (e.g., "0.5ms")
  *
  * @param durationBigInt - Duration in nanoseconds as a BigInt
  * @returns Formatted duration string with appropriate unit and precision
@@ -82,7 +81,7 @@ function durationToString(compilerDuration) {
     } else if (duration >= MILLISECONDS_THRESHOLD_NANOSECONDS) {
         return `${(duration / NANOSECONDS_PER_MILLISECOND).toFixed(0)}ms`;
     } else {
-        return `${(duration / NANOSECONDS_PER_MICROSECOND).toFixed(0)}µs`;
+        return `${(duration / NANOSECONDS_PER_MILLISECOND).toFixed(1)}ms`;
     }
 }
 function hrtimeToSeconds(hrtime) {

package/dist/node_modules/next/dist/build/next-config-ts/transpile-config.js

@@ -11,56 +11,15 @@ Object.defineProperty(exports, "transpileConfig", {
 const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _nodefs = require("node:fs");
 const _nodeurl = require("node:url");
-const _commentjson = /*#__PURE__*/ _interop_require_wildcard(require("next/dist/compiled/comment-json"));
 const _requirehook = require("./require-hook");
 const _log = require("../output/log");
 const _utils = require("../../server/lib/utils");
+const _loadTsConfig = require("../../lib/typescript/loadTsConfig");
 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;
-}
 function resolveSWCOptions(cwd, compilerOptions) {
     var _process_versions, _process;
     return {
@@ -74,7 +33,7 @@ function resolveSWCOptions(cwd, compilerOptions) {
             ...compilerOptions.baseUrl ? {
                 baseUrl: _nodepath.default.resolve(cwd, compilerOptions.baseUrl)
             } : compilerOptions.paths ? {
-                baseUrl: cwd
+                baseUrl: compilerOptions.pathsBasePath ?? cwd
             } : {}
         },
         module: {
@@ -89,76 +48,6 @@ function resolveSWCOptions(cwd, compilerOptions) {
         }
     };
 }
-function resolveExtends(extendsPath, currentConfigDir) {
-    // Relative paths are resolved relative to the current config's directory
-    if (extendsPath.startsWith('./') || extendsPath.startsWith('../') || _nodepath.default.isAbsolute(extendsPath)) {
-        const resolved = _nodepath.default.resolve(currentConfigDir, extendsPath);
-        // TypeScript allows omitting .json extension
-        if ((0, _nodefs.existsSync)(resolved)) {
-            return resolved;
-        }
-        if (!resolved.endsWith('.json') && (0, _nodefs.existsSync)(resolved + '.json')) {
-            return resolved + '.json';
-        }
-        return resolved;
-    }
-    // Package paths - use require.resolve to find the package
-    try {
-        // Try resolving as a direct path within the package
-        return require.resolve(extendsPath, {
-            paths: [
-                currentConfigDir
-            ]
-        });
-    } catch  {
-        // If that fails, try appending tsconfig.json for package names like "@tsconfig/node18"
-        try {
-            return require.resolve(extendsPath + '/tsconfig.json', {
-                paths: [
-                    currentConfigDir
-                ]
-            });
-        } catch  {
-            // Return the original path and let it fail later with a clear error
-            return _nodepath.default.resolve(currentConfigDir, extendsPath);
-        }
-    }
-}
-function loadTsConfigFile(configPath, visited) {
-    const resolvedPath = _nodepath.default.resolve(configPath);
-    if (visited.has(resolvedPath)) {
-        return {};
-    }
-    visited.add(resolvedPath);
-    if (!(0, _nodefs.existsSync)(resolvedPath)) {
-        return {};
-    }
-    const configContent = (0, _nodefs.readFileSync)(resolvedPath, 'utf8');
-    const config = _commentjson.parse(configContent);
-    const configDir = _nodepath.default.dirname(resolvedPath);
-    let mergedOptions = {};
-    // Note that config options from `extends` should get overwritten, not merged
-    if (config.extends) {
-        const extendsList = Array.isArray(config.extends) ? config.extends : [
-            config.extends
-        ];
-        for (const extendsPath of extendsList){
-            const parentConfigPath = resolveExtends(extendsPath, configDir);
-            const parentOptions = loadTsConfigFile(parentConfigPath, visited);
-            mergedOptions = {
-                ...mergedOptions,
-                ...parentOptions
-            };
-        }
-    }
-    const currentOptions = config.compilerOptions ?? {};
-    mergedOptions = {
-        ...mergedOptions,
-        paths: currentOptions.paths ?? mergedOptions.paths,
-        baseUrl: currentOptions.baseUrl ?? mergedOptions.baseUrl
-    };
-    return mergedOptions;
-}
 async function loadTsConfig(dir) {
     // NOTE: This doesn't fully cover the edge case for setting
     // "typescript.tsconfigPath" in next config which is currently
@@ -169,7 +58,7 @@ async function loadTsConfig(dir) {
     if (!(0, _nodefs.existsSync)(resolvedTsConfigPath)) {
         return {};
     }
-    return loadTsConfigFile(resolvedTsConfigPath, new Set());
+    return (0, _loadTsConfig.loadTsConfigOptions)(resolvedTsConfigPath);
 }
 async function transpileConfig({ nextConfigPath, dir }) {
     try {

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

@@ -42,29 +42,28 @@ const RuntimeSampleSchema = _zod.z.object({
         _zod.z.null()
     ])).optional()
 }).strict();
-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(),
-    unstable_disableValidation: _zod.z.literal(true).optional(),
-    unstable_disableDevValidation: _zod.z.literal(true).optional(),
-    unstable_disableBuildValidation: _zod.z.literal(true).optional()
-}).strict();
-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(),
+const InstantConfigObjectSchema = _zod.z.object({
+    level: _zod.z.enum([
+        'warning',
+        'experimental-error'
+    ]).optional(),
+    unstable_samples: _zod.z.array(RuntimeSampleSchema).min(1).optional(),
+    unstable_from: _zod.z.array(_zod.z.string()).optional(),
     unstable_disableValidation: _zod.z.literal(true).optional(),
     unstable_disableDevValidation: _zod.z.literal(true).optional(),
     unstable_disableBuildValidation: _zod.z.literal(true).optional()
 }).strict();
 const InstantConfigSchema = _zod.z.union([
-    _zod.z.discriminatedUnion('prefetch', [
-        InstantConfigStaticSchema,
-        InstantConfigRuntimeSchema
-    ]),
+    InstantConfigObjectSchema,
+    _zod.z.literal(true),
     _zod.z.literal(false)
 ]);
+const PrefetchSchema = _zod.z.enum([
+    'auto',
+    'partial',
+    'unstable_eager',
+    'force-disabled'
+]);
 /**
  * The schema for configuration for a page.
  */ const AppSegmentConfigSchema = _zod.z.object({
@@ -98,7 +97,18 @@ const InstantConfigSchema = _zod.z.union([
     ]).optional(),
     /**
    * How this segment should be prefetched.
-   */ unstable_instant: InstantConfigSchema.optional(),
+   */ instant: InstantConfigSchema.optional(),
+    /**
+   * Controls prefetching for this segment.
+   * - 'auto' (default) is a noop.
+   * - 'partial' enables Partial Prefetching. Only Cache Components are
+   *   prefetched, not dynamic ones. When a static prefetch is insufficient,
+   *   the segment may be prefetched with a runtime request instead.
+   * - 'unstable_eager' behaves like 'partial' but, when App Shells are enabled,
+   *   keeps eagerly prefetching the route's segments instead of relying on the
+   *   shared app shell. Internal migration aid; not part of the public API.
+   * - 'force-disabled' disables prefetching for the segment.
+   */ prefetch: PrefetchSchema.optional(),
     /**
    * The stale time for dynamic responses in seconds.
    * Controls how long the client-side router cache retains dynamic page data.
@@ -131,11 +141,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_instant':
+                    case 'instant':
                         {
                             return {
                                 // @TODO replace this link with a link to the docs when they are written
-                                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`
+                                message: `Invalid instant value ${JSON.stringify(ctx.data)} on "${route}", must be \`true\`, \`false\`, or an object. Read more at https://nextjs.org/docs/messages/invalid-instant-configuration`
+                            };
+                        }
+                    case 'prefetch':
+                        {
+                            return {
+                                message: `Invalid prefetch value ${JSON.stringify(ctx.data)} on "${route}", must be "auto", "partial", "unstable_eager", or "force-disabled".`
                             };
                         }
                     case 'unstable_dynamicStaleTime':

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

@@ -30,6 +30,13 @@ const _appdirmodule = require("../../../server/lib/app-dir-module");
     if ('generateStaticParams' in userland && typeof userland.generateStaticParams === 'function') {
         var _segment_config;
         segment.generateStaticParams = userland.generateStaticParams;
+        // Compiler-injected factory whose error stack is anchored at the user's
+        // `generateStaticParams` declaration. Used to throw a meaningful error when
+        // an empty result is detected under Cache Components.
+        const createEmptyParamsError = userland.__next_create_empty_gsp_error;
+        if (typeof createEmptyParamsError === 'function') {
+            segment.createEmptyParamsError = createEmptyParamsError;
+        }
         // Validate that `generateStaticParams` makes sense in this context.
         if (((_segment_config = segment.config) == null ? void 0 : _segment_config.runtime) === 'edge') {
             throw Object.defineProperty(new Error('Edge runtime is not supported with `generateStaticParams`.'), "__NEXT_ERROR_CODE", {
@@ -90,7 +97,10 @@ const _appdirmodule = require("../../../server/lib/app-dir-module");
  *
  * @param routeModule the app route module
  * @returns the segments for the app route module
- */ function collectAppRouteSegments(routeModule) {
+ */ async function collectAppRouteSegments(routeModule) {
+    // The route file may be an async module (top-level await), so the userland
+    // module must be resolved before its exports can be inspected.
+    await routeModule.ensureUserland();
     // Get the pathname parts, slice off the first element (which is empty).
     const parts = routeModule.definition.pathname.split('/').slice(1);
     if (parts.length === 0) {

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

@@ -43,9 +43,12 @@ const _fallback = require("../../lib/fallback");
 const _utils = require("./utils");
 const _escapepathdelimiters = /*#__PURE__*/ _interop_require_default(require("../../shared/lib/router/utils/escape-path-delimiters"));
 const _createincrementalcache = require("../../export/helpers/create-incremental-cache");
+const _workasyncstorageexternal = require("../../server/app-render/work-async-storage.external");
 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 _isplainobject = require("../../shared/lib/is-plain-object");
+const _workunitasyncstorageexternal = require("../../server/app-render/work-unit-async-storage.external");
 const _implicittags = require("../../server/lib/implicit-tags");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -281,7 +284,7 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
     }
     return valid;
 }
-function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments, computeRemainingPrerenderableParams) {
+function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments) {
     // If there are no routes to process, exit early.
     if (prerenderedRoutes.length === 0) {
         return;
@@ -392,7 +395,7 @@ function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments, computeR
                     route.throwOnEmptyStaticShell = true // Should throw on empty static shell.
                     ;
                 }
-                if (computeRemainingPrerenderableParams && route.fallbackRouteParams && route.fallbackRouteParams.length > 0) {
+                if (route.fallbackRouteParams && route.fallbackRouteParams.length > 0) {
                     const fallbackRouteParamsByName = new Map(route.fallbackRouteParams.map((param)=>[
                             param.paramName,
                             param
@@ -426,10 +429,15 @@ function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments, computeR
         }
     }
 }
+function getValueType(value) {
+    if (value === null) return 'null';
+    if (Array.isArray(value)) return 'array';
+    return typeof value;
+}
 /**
  * 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) {
+ */ async function callGenerateStaticParams(page, generateStaticParams, parentParams, rootParamKeys, implicitTags, isStaticExport) {
     const rootParams = {};
     for (const key of rootParamKeys){
         if (key in parentParams) {
@@ -442,11 +450,35 @@ function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments, computeR
         implicitTags,
         rootParams
     };
-    return workUnitAsyncStorage.run(workUnitStore, generateStaticParams, {
+    const generatedParams = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(workUnitStore, generateStaticParams, {
         params: parentParams
     });
+    if (!Array.isArray(generatedParams)) {
+        throw Object.defineProperty(new Error(`Invalid value returned from generateStaticParams for "${page}". Expected an array, but received type ${getValueType(generatedParams)}. See more info here: https://nextjs.org/docs/messages/generate-static-params`), "__NEXT_ERROR_CODE", {
+            value: "E1450",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (isStaticExport && generatedParams.length === 0) {
+        throw Object.defineProperty(new Error(`Page "${page}" returned an empty array from "generateStaticParams()". With "output: export", at least one route must be generated. See more info here: https://nextjs.org/docs/messages/generate-static-params`), "__NEXT_ERROR_CODE", {
+            value: "E1454",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    for (const [index, params] of generatedParams.entries()){
+        if (!(0, _isplainobject.isPlainObject)(params)) {
+            throw Object.defineProperty(new Error(`Invalid value at index ${index} returned from generateStaticParams for "${page}". Expected an object, but received type ${getValueType(params)}. See more info here: https://nextjs.org/docs/messages/generate-static-params`), "__NEXT_ERROR_CODE", {
+                value: "E1451",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    return generatedParams;
 }
-async function generateRouteStaticParams(segments, store, workUnitAsyncStorage, isRoutePPREnabled, rootParamKeys) {
+async function generateRouteStaticParams(segments, store, isRoutePPREnabled, rootParamKeys, isStaticExport) {
     // Early return if no segments to process
     if (segments.length === 0) return [];
     const implicitTags = await (0, _implicittags.getImplicitTags)(store.page, store.page, null);
@@ -483,7 +515,7 @@ async function generateRouteStaticParams(segments, store, workUnitAsyncStorage,
         if (params.length > 0) {
             // Process each parent parameter combination
             for (const parentParams of params){
-                const result = await callGenerateStaticParams(current.generateStaticParams, workUnitAsyncStorage, parentParams, rootParamKeys, implicitTags);
+                const result = await callGenerateStaticParams(store.page, current.generateStaticParams, parentParams, rootParamKeys, implicitTags, isStaticExport);
                 if (result.length > 0) {
                     // Merge parent params with each result item
                     for (const item of result){
@@ -493,7 +525,7 @@ async function generateRouteStaticParams(segments, store, workUnitAsyncStorage,
                         });
                     }
                 } else if (isRoutePPREnabled) {
-                    (0, _emptygeneratestaticparamserror.throwEmptyGenerateStaticParamsError)();
+                    (0, _emptygeneratestaticparamserror.throwEmptyGenerateStaticParamsError)(current.createEmptyParamsError);
                 } else {
                     // No results, just pass through parent params
                     nextParams.push(parentParams);
@@ -501,9 +533,9 @@ async function generateRouteStaticParams(segments, store, workUnitAsyncStorage,
             }
         } else {
             // No parent params, call generateStaticParams with empty object
-            const result = await callGenerateStaticParams(current.generateStaticParams, workUnitAsyncStorage, {}, rootParamKeys, implicitTags);
+            const result = await callGenerateStaticParams(store.page, current.generateStaticParams, {}, rootParamKeys, implicitTags, isStaticExport);
             if (result.length === 0 && isRoutePPREnabled) {
-                (0, _emptygeneratestaticparamserror.throwEmptyGenerateStaticParamsError)();
+                (0, _emptygeneratestaticparamserror.throwEmptyGenerateStaticParamsError)(current.createEmptyParamsError);
             }
             nextParams.push(...result);
         }
@@ -531,7 +563,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, partialFallbacksEnabled = false, buildId, deploymentId, rootParamKeys }) {
+async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, useCacheTimeout, staticPageGenerationTimeout, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, buildId, deploymentId, rootParamKeys }) {
     if (segments.some((generate)=>{
         var _generate_config;
         return ((_generate_config = generate.config) == null ? void 0 : _generate_config.dynamicParams) === true;
@@ -564,10 +596,16 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         renderOpts: {
             incrementalCache,
             cacheLifeProfiles,
+            staticPageGenerationTimeout,
             supportsDynamicResponse: true,
             cacheComponents,
+            // generateStaticParams evaluation doesn't render pages, so instant
+            // validation never runs here. The level value is irrelevant.
+            // TODO: remove validationLevel and other global config out of renderOpts
+            validationLevel: 'warning',
             experimental: {
-                authInterrupts
+                authInterrupts,
+                useCacheTimeout
             },
             waitUntil: afterRunner.context.waitUntil,
             onClose: afterRunner.context.onClose,
@@ -577,7 +615,7 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         deploymentId,
         previouslyRevalidatedTags: []
     });
-    const routeParams = await ComponentMod.workAsyncStorage.run(store, generateRouteStaticParams, segments, store, ComponentMod.workUnitAsyncStorage, isRoutePPREnabled, rootParamKeys);
+    const routeParams = await _workasyncstorageexternal.workAsyncStorage.run(store, generateRouteStaticParams, segments, store, isRoutePPREnabled, rootParamKeys, nextConfigOutput === 'export');
     const generatedParamNames = new Set();
     for (const params of routeParams){
         for (const paramName of Object.keys(params)){
@@ -611,14 +649,23 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
             lastDynamicSegmentHadGenerateStaticParams = true;
         }
     }
-    // Determine if all the segments have had their parameters provided.
-    const hadAllParamsGenerated = pathnameRouteParamSegments.length === 0 || routeParams.length > 0 && routeParams.every((params)=>{
+    const missingParamNames = [];
+    if (routeParams.length > 0) {
         for (const { paramName } of pathnameRouteParamSegments){
-            if (paramName in params) continue;
-            return false;
+            if (routeParams.some((params)=>!(paramName in params))) {
+                missingParamNames.push(paramName);
+            }
         }
-        return true;
-    });
+    }
+    // Determine if all the segments have had their parameters provided.
+    const hadAllParamsGenerated = pathnameRouteParamSegments.length === 0 || routeParams.length > 0 && missingParamNames.length === 0;
+    if (nextConfigOutput === 'export' && routeParams.length > 0 && !hadAllParamsGenerated) {
+        throw Object.defineProperty(new Error(`Page "${page}" returned incomplete params from "generateStaticParams()". With "output: export", every params object must include all dynamic route parameters. Missing: ${missingParamNames.map((name)=>`"${name}"`).join(', ')}. See more info here: https://nextjs.org/docs/messages/generate-static-params`), "__NEXT_ERROR_CODE", {
+            value: "E1455",
+            enumerable: false,
+            configurable: true
+        });
+    }
     // TODO: dynamic params should be allowed to be granular per segment but
     // we need additional information stored/leveraged in the prerender
     // manifest to allow this behavior.
@@ -725,7 +772,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) {
-        assignStaticShellMetadata(prerenderedRoutes, prerenderablePathSegments, partialFallbacksEnabled);
+        assignStaticShellMetadata(prerenderedRoutes, prerenderablePathSegments);
     }
     return {
         fallbackMode,