@evoscientist/webui 0.2.5 → 0.2.6

package/dist/node_modules/next/dist/server/config.js

@@ -49,11 +49,15 @@ const _dset = require("../shared/lib/dset");
 const _zod = require("../shared/lib/zod");
 const _isbot = require("../shared/lib/router/utils/is-bot");
 const _findpagesdir = require("../lib/find-pages-dir");
+const _constants1 = require("../lib/constants");
+const _cachelifeprofile = require("./use-cache/cache-life-profile");
+const _formatdynamicimportpath = require("../lib/format-dynamic-import-path");
 const _interopdefault = require("../lib/interop-default");
 const _hash = require("../shared/lib/hash");
 const _harddeprecatedconfigerror = require("../shared/lib/errors/hard-deprecated-config-error");
 const _nextinstanceerrorstate = require("./mcp/tools/next-instance-error-state");
 const _bundler = require("../lib/bundler");
+const _durationtostring = require("../build/duration-to-string");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -122,6 +126,10 @@ function normalizeNextConfigZodErrors(error) {
                 shouldExit = true;
                 message += "\nUse 'experimental.turbopackFileSystemCacheForDev' instead.";
                 message += '\nLearn more: https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopackFileSystemCache';
+            } else if (message.includes('dynamicIO')) {
+                shouldExit = true;
+                message += '\n`experimental.dynamicIO` has been replaced by `cacheComponents`. Please update your next.config file accordingly.';
+                message += '\nLearn more: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheComponents';
             }
         }
         if (shouldExit) {
@@ -135,6 +143,21 @@ function normalizeNextConfigZodErrors(error) {
         fatalErrors
     ];
 }
+// Infinity means "never", but turns into null when serialized as JSON (e.g.
+// for build workers or the prerender manifest), unlike INFINITE_CACHE.
+function normalizeInfiniteDuration(value, name) {
+    if (value === undefined || Number.isFinite(value)) {
+        return value;
+    }
+    if (value === Infinity) {
+        return _constants1.INFINITE_CACHE;
+    }
+    throw Object.defineProperty(new Error(`Invalid "${name}" provided, expected a finite number of seconds or Infinity, received ${value}`), "__NEXT_ERROR_CODE", {
+        value: "E1416",
+        enumerable: false,
+        configurable: true
+    });
+}
 function warnOptionHasBeenDeprecated(config, nestedPropertyKey, reason, silent) {
     let hasWarned = false;
     if (!silent) {
@@ -164,6 +187,7 @@ function checkDeprecations(userConfig, configFileName, silent, dir) {
     warnOptionHasBeenDeprecated(userConfig, 'skipMiddlewareUrlNormalize', `\`skipMiddlewareUrlNormalize\` is deprecated. Please use \`skipProxyUrlNormalize\` instead in ${configFileName}.`, silent);
     warnOptionHasBeenDeprecated(userConfig, 'experimental.instrumentationHook', `\`experimental.instrumentationHook\` is no longer needed, because \`instrumentation.js\` is available by default. You can remove it from ${configFileName}.`, silent);
     warnOptionHasBeenDeprecated(userConfig, 'experimental.after', `\`experimental.after\` is no longer needed, because \`after\` is available by default. You can remove it from ${configFileName}.`, silent);
+    warnOptionHasBeenDeprecated(userConfig, 'experimental.rootParams', `\`experimental.rootParams\` is no longer needed, because \`next/root-params\` is available by default. You can remove it from ${configFileName}.`, silent);
     warnOptionHasBeenDeprecated(userConfig, 'eslint', `\`eslint\` configuration in ${configFileName} is no longer supported. See more info here: https://nextjs.org/docs/app/api-reference/cli/next#next-lint-options`, silent);
     if ((_userConfig_images = userConfig.images) == null ? void 0 : (_userConfig_images_domains = _userConfig_images.domains) == null ? void 0 : _userConfig_images_domains.length) {
         warnOptionHasBeenDeprecated(userConfig, 'images.domains', `\`images.domains\` is deprecated in favor of \`images.remotePatterns\`. Please update ${configFileName} to protect your application from malicious users.`, silent);
@@ -219,7 +243,7 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
  * @param silent - Whether to suppress warnings.
  * @returns The complete config.
  */ function assignDefaultsAndValidate(dir, userConfig, silent, phase) {
-    var _result_experimental, _result_experimental1, _result_experimental_serverActions, _result_experimental2, _userConfig_experimental, _userConfig_experimental1, _userConfig_experimental2, _userConfig_experimental3, _userConfig_experimental4, _userConfig_experimental5, _userConfig_experimental6, _userConfig_experimental7, _userConfig_experimental8, _userConfig_experimental9, _userConfig_experimental10, _userConfig_experimental11, _userConfig_experimental12, _userConfig_experimental13, _userConfig_experimental14, _userConfig_experimental15, _result_experimental3, _result_turbopack, _result_turbopack1, _result_devIndicators, _result_experimental4;
+    var _result_experimental, _result_experimental1, _result_experimental_serverActions, _result_experimental2, _userConfig_experimental, _userConfig_experimental1, _userConfig_experimental2, _userConfig_experimental3, _userConfig_experimental4, _userConfig_experimental5, _userConfig_experimental6, _userConfig_experimental7, _userConfig_experimental8, _userConfig_experimental9, _userConfig_experimental10, _userConfig_experimental11, _userConfig_experimental12, _userConfig_experimental13, _userConfig_experimental14, _userConfig_experimental15, _result_experimental3, _result_turbopack, _result_turbopack1, _result_turbopack2, _result_devIndicators, _result_experimental4;
     const configFileName = userConfig.configFileName;
     if (typeof userConfig.exportTrailingSlash !== 'undefined') {
         if (!silent) {
@@ -331,6 +355,25 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
     if (!result.experimental.trustHostHeader && _ciinfo.hasNextSupport) {
         result.experimental.trustHostHeader = true;
     }
+    // Normalize the user-facing `turbopackMemoryEviction` (`false | 'full' |
+    // 'auto' | undefined`) into the `turbopackMemoryEvictionMode` enum expected by
+    // napi (`'off' | 'full' | 'auto'`).
+    let turbopackMemoryEvictionMode;
+    switch(result.experimental.turbopackMemoryEviction){
+        case false:
+            turbopackMemoryEvictionMode = 'off';
+            break;
+        case 'full':
+        case 'auto':
+            turbopackMemoryEvictionMode = result.experimental.turbopackMemoryEviction;
+            break;
+        case undefined:
+        default:
+            // Not set by the user, or an invalid value, use the default.
+            turbopackMemoryEvictionMode = 'auto';
+    }
+    ;
+    result.experimental.turbopackMemoryEvictionMode = turbopackMemoryEvictionMode;
     // Normalize experimental.browserDebugInfoInTerminal to logging.browserToTerminal
     if (result.logging !== false && ((_result_experimental = result.experimental) == null ? void 0 : _result_experimental.browserDebugInfoInTerminal) !== undefined) {
         const loggingConfig = result.logging || {};
@@ -361,6 +404,51 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
             configurable: true
         });
     }
+    // Validate experimental.cssChunking compatibility with the active bundler. Graph mode is
+    // Turbopack-only; strict mode and `false` (single-chunk-per-module) are webpack-only.
+    // Only validate during build/dev — `next start` doesn't pick a bundler and would otherwise
+    // see `process.env.TURBOPACK` unset and reject a valid `cssChunking: "graph"` config.
+    if (phase !== _constants.PHASE_PRODUCTION_SERVER && phase !== _constants.PHASE_INFO) {
+        const cssChunkingValue = result.experimental.cssChunking;
+        const cssChunkingMode = (0, _configshared.resolveCssChunkingMode)(cssChunkingValue);
+        if (cssChunkingMode === 'graph' && !process.env.TURBOPACK) {
+            throw Object.defineProperty(new Error(`\`experimental.cssChunking: "graph"\` is only supported with Turbopack. ` + `Please remove the option or run Next.js with Turbopack in ${configFileName}.`), "__NEXT_ERROR_CODE", {
+                value: "E1273",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (cssChunkingMode === 'strict' && process.env.TURBOPACK) {
+            throw Object.defineProperty(new Error(`\`experimental.cssChunking: "strict"\` is only supported with webpack. ` + `Please remove the option or run Next.js with webpack in ${configFileName}.`), "__NEXT_ERROR_CODE", {
+                value: "E1274",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        // Only error when `false` was set explicitly. `undefined` (the default) also resolves to
+        // `'off'` but that's the implicit default and must not error on Turbopack.
+        if (cssChunkingValue === false && process.env.TURBOPACK) {
+            throw Object.defineProperty(new Error(`\`experimental.cssChunking: false\` is only supported with webpack. ` + `Please remove the option or run Next.js with webpack in ${configFileName}.`), "__NEXT_ERROR_CODE", {
+                value: "E1275",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (result.experimental.turbopackRustReactCompiler && !process.env.TURBOPACK) {
+            throw Object.defineProperty(new Error(`\`experimental.turbopackRustReactCompiler\` is only supported with Turbopack. ` + `Please remove the option or run Next.js with Turbopack in ${configFileName}.`), "__NEXT_ERROR_CODE", {
+                value: "E1363",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (result.experimental.turbopackRustReactCompiler && !result.reactCompiler) {
+            throw Object.defineProperty(new Error(`\`experimental.turbopackRustReactCompiler\` requires \`reactCompiler\` to be enabled. ` + `Please add \`reactCompiler: true\` in ${configFileName}.`), "__NEXT_ERROR_CODE", {
+                value: "E1364",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
     if (result.experimental.cachedNavigations && !result.cacheComponents) {
         throw Object.defineProperty(new Error(`\`experimental.cachedNavigations\` requires \`cacheComponents\` to be enabled. Please update your ${configFileName} accordingly.`), "__NEXT_ERROR_CODE", {
             value: "E1089",
@@ -368,6 +456,13 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
             configurable: true
         });
     }
+    if (result.partialPrefetching && !result.cacheComponents) {
+        throw Object.defineProperty(new Error(`\`partialPrefetching\` requires \`cacheComponents\` to be enabled. Please update your ${configFileName} accordingly.`), "__NEXT_ERROR_CODE", {
+            value: "E1321",
+            enumerable: false,
+            configurable: true
+        });
+    }
     if (result.experimental.ppr) {
         throw new _harddeprecatedconfigerror.HardDeprecatedConfigError(`\`experimental.ppr\` has been merged into \`cacheComponents\`. The Partial Prerendering feature is still available, but is now enabled via \`cacheComponents\`. Please update your ${configFileName} accordingly.`);
     }
@@ -451,14 +546,20 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
                 });
             }
             // avoid double-pushing the same pattern if it already exists
-            const hasMatch = images.localPatterns.some((pattern)=>pattern.pathname === '/_next/static/media/**' && pattern.search === '');
-            if (!hasMatch) {
+            if (!images.localPatterns.some((pattern)=>pattern.pathname === '/_next/static/media/**' && pattern.search === '')) {
                 // static import images are automatically allowed
                 images.localPatterns.push({
                     pathname: '/_next/static/media/**',
                     search: ''
                 });
             }
+            if (!images.localPatterns.some((pattern)=>pattern.pathname === '/_next/static/immutable/media/**' && pattern.search === '')) {
+                // static import images are automatically allowed
+                images.localPatterns.push({
+                    pathname: '/_next/static/immutable/media/**',
+                    search: ''
+                });
+            }
         } else {
             // All paths are not allowed for a search query by default.
             images.localPatterns = [
@@ -706,6 +807,12 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
             _log.warn(`turbopack.root should be absolute, using: ${result.turbopack.root}`);
         }
     }
+    if (result == null ? void 0 : (_result_turbopack1 = result.turbopack) == null ? void 0 : _result_turbopack1.chunkLoadingGlobal) {
+        const g = result.turbopack.chunkLoadingGlobal;
+        if (!g.startsWith('TURBOPACK_')) {
+            result.turbopack.chunkLoadingGlobal = `TURBOPACK_${g}`;
+        }
+    }
     if (result.experimental.runtimeServerDeploymentId == null && phase === _constants.PHASE_PRODUCTION_BUILD && _ciinfo.hasNextSupport && process.env.NEXT_DEPLOYMENT_ID) {
         if (result.deploymentId != null && result.deploymentId !== process.env.NEXT_DEPLOYMENT_ID) {
             throw Object.defineProperty(new Error(`The NEXT_DEPLOYMENT_ID environment variable value "${process.env.NEXT_DEPLOYMENT_ID}" does not match the provided deploymentId "${result.deploymentId}" in the config.`), "__NEXT_ERROR_CODE", {
@@ -720,23 +827,31 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
     if (process.env.NEXT_DEPLOYMENT_ID) {
         result.deploymentId = process.env.NEXT_DEPLOYMENT_ID;
     }
-    // Only read process.env.__NEXT_IMMUTABLE_ASSET_TOKEN to make our testing setup easier. This is
-    // actually done by the adapter's modifyConfig
-    if (process.env.__NEXT_TEST_MODE && process.env.IS_TURBOPACK_TEST && result.deploymentId && process.env.__NEXT_IMMUTABLE_ASSET_TOKEN) {
-        result.experimental.immutableAssetToken = process.env.__NEXT_IMMUTABLE_ASSET_TOKEN;
+    if (process.env.NEXT_HASH_SALT) {
+        result.outputHashSalt = (result.outputHashSalt ?? '') + (process.env.NEXT_HASH_SALT ?? '');
     }
     const tracingRoot = result == null ? void 0 : result.outputFileTracingRoot;
-    const turbopackRoot = result == null ? void 0 : (_result_turbopack1 = result.turbopack) == null ? void 0 : _result_turbopack1.root;
+    const turbopackRoot = result == null ? void 0 : (_result_turbopack2 = result.turbopack) == null ? void 0 : _result_turbopack2.root;
+    let repoRoot = process.env.NEXT_PRIVATE_OUTPUT_TRACE_ROOT;
+    let rootDirResult;
+    if (!repoRoot) {
+        rootDirResult = (0, _findroot.findRootDirAndLockFiles)(dir);
+        repoRoot = rootDirResult.rootDir;
+    }
+    ;
+    result.repoRoot = repoRoot;
     // If both provided, validate they match. If not, use outputFileTracingRoot.
     if (tracingRoot && turbopackRoot && tracingRoot !== turbopackRoot) {
         _log.warn(`Both \`outputFileTracingRoot\` and \`turbopack.root\` are set, but they must have the same value.\n` + `Using \`outputFileTracingRoot\` value: ${tracingRoot}.`);
     }
     let rootDir = tracingRoot || turbopackRoot;
     if (!rootDir) {
-        const { rootDir: foundRootDir, lockFiles } = (0, _findroot.findRootDirAndLockFiles)(dir);
-        rootDir = foundRootDir;
-        if (!silent) {
-            (0, _findroot.warnDuplicatedLockFiles)(lockFiles);
+        rootDir = repoRoot;
+        if (rootDirResult && !silent) {
+            if (rootDirResult.boundary) {
+                (0, _findroot.warnRootBoundary)(rootDirResult.boundary);
+            }
+            (0, _findroot.warnDuplicatedLockFiles)(rootDirResult.lockFiles);
         }
     }
     if (!rootDir) {
@@ -897,12 +1012,33 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
             });
         }
     }
+    result.expireTime = normalizeInfiniteDuration(result.expireTime, 'expireTime');
+    const staleTimes = result.experimental.staleTimes;
+    if (staleTimes) {
+        staleTimes.dynamic = normalizeInfiniteDuration(staleTimes.dynamic, 'experimental.staleTimes.dynamic');
+        staleTimes.static = normalizeInfiniteDuration(staleTimes.static, 'experimental.staleTimes.static');
+    }
     if (result.cacheLife) {
         var _defaultConfig_cacheLife, _defaultConfig_experimental_staleTimes, _defaultConfig_experimental;
-        result.cacheLife = {
-            ..._configshared.defaultConfig.cacheLife,
-            ...result.cacheLife
+        const userCacheLifeProfiles = result.cacheLife;
+        // The default profiles are cloned because the backfill below mutates the
+        // default profile, and multiple next() instances in the same process must
+        // not observe each other's config through the shared objects.
+        const cacheLifeProfiles = {
+            ...structuredClone(_configshared.defaultConfig.cacheLife),
+            ...userCacheLifeProfiles
         };
+        result.cacheLife = cacheLifeProfiles;
+        // Only validate values the user wrote themselves. Backfilling the
+        // default profile below can produce a revalidate that's larger than a
+        // user-provided expire (e.g. for `default: { expire: 0 }`), which is
+        // fine — the expire wins — but would fail validation.
+        for (const [profileName, profile] of Object.entries(userCacheLifeProfiles)){
+            cacheLifeProfiles[profileName] = (0, _cachelifeprofile.validateAndNormalizeCacheLifeProfile)(profile, {
+                kind: 'config',
+                profileName
+            });
+        }
         const defaultDefault = (_defaultConfig_cacheLife = _configshared.defaultConfig.cacheLife) == null ? void 0 : _defaultConfig_cacheLife['default'];
         if (!defaultDefault || defaultDefault.revalidate === undefined || defaultDefault.expire === undefined || !((_defaultConfig_experimental = _configshared.defaultConfig.experimental) == null ? void 0 : (_defaultConfig_experimental_staleTimes = _defaultConfig_experimental.staleTimes) == null ? void 0 : _defaultConfig_experimental_staleTimes.static)) {
             throw Object.defineProperty(new Error('No default cacheLife profile.'), "__NEXT_ERROR_CODE", {
@@ -929,7 +1065,7 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
         }
     }
     if (result.cacheHandlers) {
-        const allowedHandlerNameRegex = /[a-z-]/;
+        const allowedHandlerNameRegex = /^[a-z-]+$/;
         if (typeof result.cacheHandlers !== 'object') {
             throw Object.defineProperty(new Error(`Invalid "cacheHandlers" provided, expected an object e.g. { default: '/my-handler.js' }, received ${JSON.stringify(result.cacheHandlers)}`), "__NEXT_ERROR_CODE", {
                 value: "E901",
@@ -952,7 +1088,8 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
                 });
             } else {
                 const handlerPath = result.cacheHandlers[key];
-                if (handlerPath && !(0, _fs.existsSync)(handlerPath)) {
+                const resolvedHandlerPath = handlerPath && (0, _formatdynamicimportpath.resolveCacheHandlerPathToFilesystem)(handlerPath);
+                if (resolvedHandlerPath && !(0, _fs.existsSync)(resolvedHandlerPath)) {
                     invalidHandlerItems.push({
                         key,
                         reason: `cache handler path provided does not exist, received ${handlerPath}`
@@ -1076,9 +1213,27 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
     if (result.cacheComponents) {
         // TODO: remove once we've finished migrating internally to cacheComponents.
         result.experimental.ppr = true;
-        // Prerender sourcemaps are enabled by default when using cacheComponents, unless explicitly disabled.
-        if (result.enablePrerenderSourceMaps === undefined) {
-            result.enablePrerenderSourceMaps = true;
+    }
+    // `experimental.useCache` is deprecated in favor of the top-level
+    // `cacheComponents` option. A defined value means the user set the option
+    // explicitly, because it's only backfilled from `cacheComponents` below.
+    if (result.experimental.useCache !== undefined) {
+        // Disabling the directive that Cache Components is built around leaves the
+        // app in a state where every `"use cache"` fails to compile with an error
+        // that asks for the already-enabled `cacheComponents` option.
+        if (!result.experimental.useCache && result.cacheComponents) {
+            throw Object.defineProperty(new Error(`\`experimental.useCache\` cannot be disabled when \`cacheComponents\` is enabled, because Cache Components relies on the \`"use cache"\` directive. Please remove it from ${configFileName}.`), "__NEXT_ERROR_CODE", {
+                value: "E1465",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (!silent) {
+            if (result.cacheComponents) {
+                _log.warnOnce(`\`experimental.useCache\` is no longer needed, because \`cacheComponents\` already enables the \`"use cache"\` directive. You can remove it from ${configFileName}.`);
+            } else {
+                _log.warnOnce(`\`experimental.useCache\` is deprecated. Please use the top-level \`cacheComponents\` option instead in ${configFileName}.`);
+            }
         }
     }
     // "use cache" was originally implicitly enabled with the cacheComponents flag, so
@@ -1093,9 +1248,53 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
     if (phase === _constants.PHASE_DEVELOPMENT_SERVER) {
         result.distDir = (0, _path.join)(result.distDir, 'dev');
     }
+    // Derive the `'use cache'` fill timeout from `staticPageGenerationTimeout`
+    // if the user didn't set one explicitly. 90% leaves headroom for the
+    // cache-fill error to surface before the build worker kills the page.
+    if (result.experimental.useCacheTimeout === undefined) {
+        result.experimental.useCacheTimeout = result.staticPageGenerationTimeout * 0.9;
+    }
     return result;
 }
-async function applyModifyConfig(config, phase, silent) {
+/**
+ * Post-processing applied by `loadConfig` after `applyModifyConfig`, so that
+ * any mutations the user made through `modifyConfig` still flow through the
+ * same defaulting rules. Keep framework-default resolution in one place so
+ * consumers don't each need to know the current framework default (which may
+ * evolve over time).
+ */ function finalizeConfig(config, bundler) {
+    var _config_experimental_instantInsights, _config_experimental;
+    config.experimental.instantInsights = {
+        validationLevel: ((_config_experimental_instantInsights = config.experimental.instantInsights) == null ? void 0 : _config_experimental_instantInsights.validationLevel) ?? 'warning'
+    };
+    // Only read process.env.__NEXT_IMMUTABLE_ASSET_TOKEN to make our testing setup easier. In the
+    // real world, this is done by the adapter's modifyConfig
+    if (process.env.__NEXT_TEST_MODE && process.env.IS_TURBOPACK_TEST && config.deploymentId && process.env.__NEXT_SUPPORTS_IMMUTABLE_ASSETS) {
+        config.supportsImmutableAssets = true;
+    }
+    // Normalize again for Adapters that only set config.experimental.supportsImmutableAssets for now.
+    if (config.supportsImmutableAssets !== ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.supportsImmutableAssets)) {
+        var _config_experimental1;
+        config.supportsImmutableAssets = config.supportsImmutableAssets ?? ((_config_experimental1 = config.experimental) == null ? void 0 : _config_experimental1.supportsImmutableAssets);
+    }
+    if (bundler !== undefined && bundler !== _bundler.Bundler.Turbopack) {
+        // Silently ignore that flag for Webpack/Rspack since the server code assumes that all files
+        // in `static/chunks` are always immutable without checking the manifest.
+        config.supportsImmutableAssets = false;
+    }
+    if (config.supportsImmutableAssets && (config.output === 'export' || config.output === 'standalone')) {
+        // supportsImmutableAssets is designed to work with adapters. Disable it for output=export and
+        // output=standalone, which are currently using a non-adapter codepath.
+        // Particularly output=export should just run through the adapter, with only static assets.
+        // TODO remove again once output=export (and output=standalone) are using adapters.
+        config.supportsImmutableAssets = false;
+    }
+    if (config.experimental.outputHashSalt !== undefined) {
+        config.outputHashSalt = (config.outputHashSalt ?? '') + config.experimental.outputHashSalt;
+    }
+    return config;
+}
+async function applyModifyConfig(config, phase, silent, dir) {
     // we always call modify config  and phase can be used to only
     // modify for specific times
     if (config.adapterPath) {
@@ -1106,7 +1305,8 @@ async function applyModifyConfig(config, phase, silent) {
             }
             config = await adapterMod.modifyConfig(config, {
                 phase,
-                nextVersion: "16.2.6"
+                nextVersion: "16.3.3",
+                projectDir: dir
             });
         }
     }
@@ -1129,22 +1329,41 @@ function getCacheKey(phase, dir, customConfig, reactProductionProfiling, debugPr
     });
     return (0, _hash.djb2Hash)(keyData).toString(36);
 }
-async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true, reportExperimentalFeatures, reactProductionProfiling, debugPrerender, bundler } = {}) {
+async function loadConfig(phase, dir, opts = {}) {
+    // Test for an explicit `silent == false` since the default in loadConfig is true
+    const logTiming = opts.silent === false;
+    const startTimeNanos = logTiming ? process.hrtime.bigint() : undefined;
+    const [config, meta] = await loadConfigImpl(phase, dir, opts);
+    if (!meta.cacheHit && logTiming) {
+        const durationNanos = process.hrtime.bigint() - startTimeNanos;
+        _log.event(`Running ${meta.configFileName ?? 'next.config'} took ${(0, _durationtostring.hrtimeBigIntDurationToString)(durationNanos)}`);
+    }
+    return config;
+}
+async function loadConfigImpl(phase, dir, { customConfig, rawConfig, silent = true, reportExperimentalFeatures, reactProductionProfiling, debugPrerender, bundler }) {
+    const meta = {};
     // Generate cache key based on parameters that affect config output
     // Include process.pid to invalidate cache on server restart
     const cacheKey = getCacheKey(phase, dir, customConfig, reactProductionProfiling, debugPrerender, process.pid);
     // Check if we have a cached result
     const cachedResult = configCache.get(cacheKey);
     if (cachedResult) {
+        meta.cacheHit = true;
         // Call the experimental features callback if provided
         if (reportExperimentalFeatures) {
             reportExperimentalFeatures(cachedResult.configuredExperimentalFeatures);
         }
         // Return raw config if requested and available
         if (rawConfig && cachedResult.rawConfig) {
-            return cachedResult.rawConfig;
+            return [
+                cachedResult.rawConfig,
+                meta
+            ];
         }
-        return cachedResult.config;
+        return [
+            cachedResult.config,
+            meta
+        ];
     } else {
         // Reset next.config errors before loading config
         // This happens on every config load to ensure fresh validation
@@ -1172,7 +1391,10 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
             rawConfig: standaloneConfig,
             configuredExperimentalFeatures: []
         });
-        return standaloneConfig;
+        return [
+            standaloneConfig,
+            meta
+        ];
     }
     const curLog = silent ? {
         warn: ()=>{},
@@ -1185,11 +1407,11 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
     if (customConfig) {
         // Check deprecation warnings on the custom config before merging with defaults
         checkDeprecations(customConfig, configFileName, silent, dir);
-        const config = await applyModifyConfig(assignDefaultsAndValidate(dir, {
+        const config = finalizeConfig(await applyModifyConfig(assignDefaultsAndValidate(dir, {
             configOrigin: 'server',
             configFileName,
             ...customConfig
-        }, silent, phase), phase, silent);
+        }, silent, phase), phase, silent, dir), bundler);
         // Cache the custom config result
         configCache.set(cacheKey, {
             config,
@@ -1197,16 +1419,21 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
             configuredExperimentalFeatures
         });
         reportExperimentalFeatures == null ? void 0 : reportExperimentalFeatures(configuredExperimentalFeatures);
-        return config;
+        return [
+            config,
+            meta
+        ];
     }
     const path = await (0, _findup.default)(_constants.CONFIG_FILES, {
         cwd: dir
     });
     // If config file was found
     if (path == null ? void 0 : path.length) {
-        var _userConfig_experimental, _userConfig_experimental1, _userConfig_experimental2, _userConfig_experimental3;
+        var _userConfig_experimental, _userConfig_experimental1, _userConfig_experimental2, _userConfig_experimental3, _userConfig_experimental4, _userConfig_experimental5, _userConfig_experimental6;
         configFileName = (0, _path.basename)(path);
+        meta.configFileName = configFileName;
         let userConfigModule;
+        let loadedConfig;
         try {
             const envBefore = Object.assign({}, process.env);
             // `import()` expects url-encoded strings, so the path must be properly
@@ -1240,8 +1467,17 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
                     configuredExperimentalFeatures
                 });
                 reportExperimentalFeatures == null ? void 0 : reportExperimentalFeatures(configuredExperimentalFeatures);
-                return userConfigModule;
+                return [
+                    userConfigModule,
+                    meta
+                ];
             }
+            // `normalizeConfig` invokes the user's exported config function (or
+            // awaits its returned promise) if it is one. Errors thrown from that
+            // call belong to the same "failed to load config" category as parse
+            // errors from `import()` above, so we keep them inside this try/catch
+            // to attach the same framing message.
+            loadedConfig = Object.freeze(await (0, _configshared.normalizeConfig)(phase, (0, _interopdefault.interopDefault)(userConfigModule)));
         } catch (err) {
             // Capture the error for MCP tool reporting
             _nextinstanceerrorstate.NextInstanceErrorState.nextConfig.push(err);
@@ -1249,7 +1485,6 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
             curLog.error(`Failed to load ${configFileName}, see more info here https://nextjs.org/docs/messages/next-config-error`);
             throw err;
         }
-        const loadedConfig = Object.freeze(await (0, _configshared.normalizeConfig)(phase, (0, _interopdefault.interopDefault)(userConfigModule)));
         if (loadedConfig.experimental) {
             for (const name of Object.keys(loadedConfig.experimental)){
                 const value = loadedConfig.experimental[name];
@@ -1263,6 +1498,27 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
         const userConfig = cloneObject(loadedConfig);
         // Check deprecation warnings on the actual user config before merging with defaults
         checkDeprecations(userConfig, configFileName, silent, dir);
+        if (userConfig.supportsImmutableAssets === undefined && ((_userConfig_experimental = userConfig.experimental) == null ? void 0 : _userConfig_experimental.supportsImmutableAssets) !== undefined) {
+            userConfig.supportsImmutableAssets = userConfig.experimental.supportsImmutableAssets;
+        }
+        // `experimental.turbopackGenerateComponentChunks` has moved into
+        // `experimental.turbopackChunking.generateComponentChunks`.
+        if (((_userConfig_experimental1 = userConfig.experimental) == null ? void 0 : _userConfig_experimental1.turbopackGenerateComponentChunks) !== undefined) {
+            throw Object.defineProperty(new Error(`\`experimental.turbopackGenerateComponentChunks\` has been moved to \`experimental.turbopackChunking.generateComponentChunks\`. Please update your ${configFileName} file accordingly.`), "__NEXT_ERROR_CODE", {
+                value: "E1463",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        // `experimental.turbopackChunkingHeuristics` has been renamed to
+        // `experimental.turbopackChunking`.
+        if (((_userConfig_experimental2 = userConfig.experimental) == null ? void 0 : _userConfig_experimental2.turbopackChunkingHeuristics) !== undefined) {
+            throw Object.defineProperty(new Error(`\`experimental.turbopackChunkingHeuristics\` has been renamed to \`experimental.turbopackChunking\`. Please update your ${configFileName} file accordingly.`), "__NEXT_ERROR_CODE", {
+                value: "E1464",
+                enumerable: false,
+                configurable: true
+            });
+        }
         // Always validate the config against schema in non minimal mode
         if (!process.env.NEXT_MINIMAL && !silent) {
             await validateConfigSchema(userConfig, configFileName, curLog.warn, (messages)=>{
@@ -1284,21 +1540,16 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
                 configurable: true
             });
         }
-        if (phase === _constants.PHASE_PRODUCTION_BUILD && bundler !== _bundler.Bundler.Turbopack && ((_userConfig_experimental = userConfig.experimental) == null ? void 0 : _userConfig_experimental.immutableAssetToken)) {
-            // Silently ignore that flag for Webpack/Rspack since the server code assumes that all files
-            // in `static/chunks` are always immutable without checking the manifest.
-            userConfig.experimental.immutableAssetToken = undefined;
-        }
         if (reactProductionProfiling) {
             userConfig.reactProductionProfiling = reactProductionProfiling;
         }
-        if (((_userConfig_experimental1 = userConfig.experimental) == null ? void 0 : _userConfig_experimental1.lightningCssFeatures) && !((_userConfig_experimental2 = userConfig.experimental) == null ? void 0 : _userConfig_experimental2.useLightningcss) && bundler !== _bundler.Bundler.Turbopack) {
+        if (((_userConfig_experimental3 = userConfig.experimental) == null ? void 0 : _userConfig_experimental3.lightningCssFeatures) && !((_userConfig_experimental4 = userConfig.experimental) == null ? void 0 : _userConfig_experimental4.useLightningcss) && bundler !== _bundler.Bundler.Turbopack) {
             curLog.warn(`experimental.lightningCssFeatures is set but experimental.useLightningcss is not enabled. ` + `The lightningCssFeatures option has no effect without useLightningcss.`);
         }
-        if ((_userConfig_experimental3 = userConfig.experimental) == null ? void 0 : _userConfig_experimental3.useLightningcss) {
-            var _css, _this, _userConfig_experimental4;
+        if (phase !== _constants.PHASE_PRODUCTION_SERVER && ((_userConfig_experimental5 = userConfig.experimental) == null ? void 0 : _userConfig_experimental5.useLightningcss)) {
+            var _css, _this, _userConfig_experimental7;
             const { loadBindings } = require('../build/swc');
-            const isLightningSupported = (_this = await loadBindings((_userConfig_experimental4 = userConfig.experimental) == null ? void 0 : _userConfig_experimental4.useWasmBinary)) == null ? void 0 : (_css = _this.css) == null ? void 0 : _css.lightning;
+            const isLightningSupported = (_this = await loadBindings((_userConfig_experimental7 = userConfig.experimental) == null ? void 0 : _userConfig_experimental7.useWasmBinary)) == null ? void 0 : (_css = _this.css) == null ? void 0 : _css.lightning;
             if (!isLightningSupported) {
                 curLog.warn(`experimental.useLightningcss is set, but the setting is disabled because next-swc/wasm does not support it yet.`);
                 userConfig.experimental.useLightningcss = false;
@@ -1321,7 +1572,15 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
             configFileName,
             ...userConfig
         }, silent, phase);
-        const finalConfig = await applyModifyConfig(completeConfig, phase, silent);
+        const finalConfig = finalizeConfig(await applyModifyConfig(completeConfig, phase, silent, dir), bundler);
+        // Normalize so that also Adapters can still see userConfig.experimental.supportsImmutableAssets for now
+        if (userConfig.supportsImmutableAssets === undefined || ((_userConfig_experimental6 = userConfig.experimental) == null ? void 0 : _userConfig_experimental6.supportsImmutableAssets) === undefined) {
+            var _userConfig_experimental8;
+            const value = userConfig.supportsImmutableAssets ?? ((_userConfig_experimental8 = userConfig.experimental) == null ? void 0 : _userConfig_experimental8.supportsImmutableAssets);
+            userConfig.supportsImmutableAssets = value;
+            userConfig.experimental ??= {};
+            userConfig.experimental.supportsImmutableAssets = value;
+        }
         // Cache the final result
         configCache.set(cacheKey, {
             config: finalConfig,
@@ -1331,7 +1590,10 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
         if (reportExperimentalFeatures) {
             reportExperimentalFeatures(configuredExperimentalFeatures);
         }
-        return finalConfig;
+        return [
+            finalConfig,
+            meta
+        ];
     } else {
         const configBaseName = (0, _path.basename)(_constants.CONFIG_FILES[0], (0, _path.extname)(_constants.CONFIG_FILES[0]));
         const unsupportedConfig = _findup.default.sync([
@@ -1369,7 +1631,7 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
         configFileName
     }, silent, phase);
     (0, _setuphttpagentenv.setHttpClientAndAgentOptions)(completeConfig);
-    const finalConfig = await applyModifyConfig(completeConfig, phase, silent);
+    const finalConfig = finalizeConfig(await applyModifyConfig(completeConfig, phase, silent, dir), bundler);
     // Cache the default config result
     configCache.set(cacheKey, {
         config: finalConfig,
@@ -1379,14 +1641,15 @@ async function loadConfig(phase, dir, { customConfig, rawConfig, silent = true,
     if (reportExperimentalFeatures) {
         reportExperimentalFeatures(configuredExperimentalFeatures);
     }
-    return finalConfig;
+    return [
+        finalConfig,
+        meta
+    ];
 }
 function enforceExperimentalFeatures(config, options) {
     const { configuredExperimentalFeatures, debugPrerender, isDefaultConfig, phase } = options;
     config.experimental ??= {};
     if (debugPrerender && (phase === _constants.PHASE_PRODUCTION_BUILD || phase === _constants.PHASE_EXPORT)) {
-        // TODO: This is not an experimental feature, but should be enabled alongside other prerender debugging features.
-        config.enablePrerenderSourceMaps = true;
         setExperimentalFeatureForDebugPrerender(config.experimental, 'serverSourceMaps', true, configuredExperimentalFeatures);
         setExperimentalFeatureForDebugPrerender(config.experimental, process.env.TURBOPACK ? 'turbopackMinify' : 'serverMinification', false, configuredExperimentalFeatures);
         setExperimentalFeatureForDebugPrerender(config.experimental, 'prerenderEarlyExit', false, configuredExperimentalFeatures);
@@ -1397,6 +1660,9 @@ function enforceExperimentalFeatures(config, options) {
     (config.cacheComponents === undefined || isDefaultConfig && !config.cacheComponents)) {
         config.cacheComponents = true;
     }
+    if (process.env.__NEXT_PARTIAL_PREFETCHING === 'true') {
+        config.partialPrefetching = true;
+    }
     // TODO: Remove this once cachedNavigations is the default.
     if (process.env.__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS === 'true' && // We do respect an explicit value in the user config.
     (config.experimental.cachedNavigations === undefined || isDefaultConfig && !config.experimental.cachedNavigations)) {
@@ -1405,12 +1671,37 @@ function enforceExperimentalFeatures(config, options) {
             addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'cachedNavigations', true, 'enabled by `__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS`');
         }
     }
-    // TODO: Remove this once appNewScrollHandler is the default.
-    if (process.env.__NEXT_EXPERIMENTAL_APP_NEW_SCROLL_HANDLER === 'true' && // We do respect an explicit value in the user config.
-    (config.experimental.appNewScrollHandler === undefined || isDefaultConfig && !config.experimental.appNewScrollHandler)) {
-        config.experimental.appNewScrollHandler = true;
+    // TODO: Remove this once serverComponentsHmrCancellation is the default.
+    if (process.env.__NEXT_EXPERIMENTAL_SERVER_COMPONENTS_HMR_CANCELLATION === 'true' && // We do respect an explicit value in the user config.
+    (config.experimental.serverComponentsHmrCancellation === undefined || isDefaultConfig && !config.experimental.serverComponentsHmrCancellation)) {
+        config.experimental.serverComponentsHmrCancellation = true;
+        if (configuredExperimentalFeatures) {
+            addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'serverComponentsHmrCancellation', true, 'enabled by `__NEXT_EXPERIMENTAL_SERVER_COMPONENTS_HMR_CANCELLATION`');
+        }
+    }
+    // Enable cachedNavigations by default when cacheComponents is enabled.
+    // cachedNavigations relies on Cache Components rendering to do anything
+    // useful, so the two features are tied together: we only flip the default
+    // for projects that are already using Cache Components. Done silently —
+    // we don't report this through `configuredExperimentalFeatures` because
+    // (a) the existing `cacheComponents` env-var auto-enable above is also
+    // silent, and (b) reporting it would force every snapshot test that has
+    // `cacheComponents: true` to take on a new line.
+    // TODO: Remove this once cachedNavigations is unconditionally the default.
+    if (config.cacheComponents && (config.experimental.cachedNavigations === undefined || isDefaultConfig && !config.experimental.cachedNavigations)) {
+        config.experimental.cachedNavigations = true;
+    }
+    // appNewScrollHandler defaults to `true`. The env var lets us opt back out to
+    // keep test coverage of the old scroll handler on the non-experimental CI
+    // shards. Like the other env-var experimental toggles, opting out is surfaced
+    // in the reported experimental features.
+    // TODO: Remove this once the appNewScrollHandler opt-out is no longer needed
+    // for test coverage.
+    if (process.env.__NEXT_EXPERIMENTAL_APP_NEW_SCROLL_HANDLER === 'false' && // We do respect an explicit value in the user config.
+    (config.experimental.appNewScrollHandler === undefined || isDefaultConfig && config.experimental.appNewScrollHandler)) {
+        config.experimental.appNewScrollHandler = false;
         if (configuredExperimentalFeatures) {
-            addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'appNewScrollHandler', true, 'enabled by `__NEXT_EXPERIMENTAL_APP_NEW_SCROLL_HANDLER`');
+            addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'appNewScrollHandler', false, 'disabled by `__NEXT_EXPERIMENTAL_APP_NEW_SCROLL_HANDLER`');
         }
     }
     // TODO: Remove this once strictRouteTypes is the default.