vike 0.4.259-commit-a909f04 → 0.4.259-commit-286bd57

package/dist/node/api/build.js

@@ -8,16 +8,16 @@ import './assertEnvApiDev.js';
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'build');
+    const { viteConfigUser } = await prepareViteApiCall(options, 'build');
     // Pass it to vike:build:pluginBuildApp
-    if (viteConfigFromUserResolved)
-        viteConfigFromUserResolved._viteConfigFromUserResolved = viteConfigFromUserResolved;
-    const builder = await createBuilder(viteConfigFromUserResolved);
+    if (viteConfigUser)
+        viteConfigUser._viteConfigUser = viteConfigUser;
+    const builder = await createBuilder(viteConfigUser);
     // buildApp() is implemented by vike:build:pluginBuildApp
     await builder.buildApp();
     return {
-    /* We don't return `viteConfig` because `viteConfigFromUserResolved` is `InlineConfig` not `ResolvedConfig`
-    viteConfig: viteConfigFromUserResolved,
+    /* We don't return `viteConfig` because `viteConfigUser` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigUser,
     */
     };
 }

package/dist/node/api/dev.js

@@ -15,8 +15,8 @@ assertIsNotProductionRuntime();
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'dev');
-    const server = await createServer(viteConfigFromUserResolved);
+    const { viteConfigUser } = await prepareViteApiCall(options, 'dev');
+    const server = await createServer(viteConfigUser);
     const viteServer = server;
     const viteConfig = server.config;
     const viteVersion = viteConfig._viteVersionResolved;

package/dist/node/api/prepareViteApiCall.d.ts

@@ -3,5 +3,5 @@ import type { ApiOptions, ApiOperation } from './types.js';
 import './assertEnvApiDevAndProd.js';
 declare function prepareViteApiCall(options: ApiOptions, operation: ApiOperation): Promise<{
     viteConfigResolved: import("vite").ResolvedConfig;
-    viteConfigFromUserResolved: import("vite").UserConfig;
+    viteConfigUser: import("vite").UserConfig;
 }>;

package/dist/node/api/prepareViteApiCall.js

@@ -1,12 +1,12 @@
 export { prepareViteApiCall };
 import { clearContextVikeApiOperation, setContextVikeApiOperation } from '../../shared-server-node/api-context.js';
 import { clearGlobalContext } from '../../server/runtime/globalContext.js';
-import { resolveViteConfigFromUser } from './resolveViteConfigFromUser.js';
+import { resolveViteConfigUser } from './resolveViteConfigUser.js';
 import './assertEnvApiDevAndProd.js';
 async function prepareViteApiCall(options, operation) {
     clear();
     setContextVikeApiOperation(operation, options);
-    return resolveViteConfigFromUser();
+    return resolveViteConfigUser();
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {

package/dist/node/api/prerender.js

@@ -8,8 +8,8 @@ import './assertEnvApiDevAndProd.js';
  * https://vike.dev/api#prerender
  */
 async function prerender(options = {}) {
-    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'prerender');
-    options.viteConfig = viteConfigFromUserResolved;
+    const { viteConfigUser } = await prepareViteApiCall(options, 'prerender');
+    options.viteConfig = viteConfigUser;
     const { viteConfig } = await runPrerenderFromAPI(options);
     return {
         viteConfig,

package/dist/node/api/preview.js

@@ -19,7 +19,7 @@ import { getStartupLogFirstLine } from './getStartupLogFirstLine.js';
  */
 async function preview(options = {}) {
     onSetupPreview();
-    const { viteConfigFromUserResolved, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
+    const { viteConfigUser, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
     const vikeConfig = await getVikeConfigInternal();
     const cliPreviewConfig = await resolveCliPreviewConfig(vikeConfig);
     assertUsage(cliPreviewConfig !== false, `${pc.cyan('$ vike preview')} isn't supported`);
@@ -53,7 +53,7 @@ async function preview(options = {}) {
     }
     else {
         // Use Vite's preview server
-        const server = await previewVite(viteConfigFromUserResolved);
+        const server = await previewVite(viteConfigUser);
         logHint(vikeConfig.prerenderContext.isPrerenderingEnabledForAllPages
             ? ' — your app is fully pre-rendered and can be statically deployed.'
             : '', isStartupLogCompact);

package/dist/node/api/{resolveViteConfigFromUser.d.ts → resolveViteConfigUser.d.ts}

@@ -1,17 +1,17 @@
-export { resolveViteConfigFromUser };
-export { isOnlyResolvingUserConfig };
+export { resolveViteConfigUser };
+export { isResolvingViteConfigUser };
 export { getVikeConfigInternalEarly };
 export { getViteRoot };
 export { assertViteRoot };
 export { normalizeViteRoot };
 import type { ResolvedConfig, UserConfig } from 'vite';
 import './assertEnvApiDevAndProd.js';
-declare function resolveViteConfigFromUser(): Promise<{
+declare function resolveViteConfigUser(): Promise<{
     viteConfigResolved: ResolvedConfig;
-    viteConfigFromUserResolved: UserConfig;
+    viteConfigUser: UserConfig;
 }>;
 declare function getVikeConfigInternalEarly(): Promise<import("../vite/shared/resolveVikeConfigInternal.js").VikeConfigInternal>;
-declare function isOnlyResolvingUserConfig(): boolean | undefined;
+declare function isResolvingViteConfigUser(): boolean | undefined;
 declare function getViteRoot(viteContext: ViteContext): Promise<string>;
 type ViteContext = 'build' | 'preview' | 'dev';
 declare function normalizeViteRoot(root: string): string;

package/dist/node/api/{resolveViteConfigFromUser.js → resolveViteConfigUser.js}

@@ -1,11 +1,11 @@
-export { resolveViteConfigFromUser };
-export { isOnlyResolvingUserConfig };
+export { resolveViteConfigUser };
+export { isResolvingViteConfigUser };
 export { getVikeConfigInternalEarly };
 export { getViteRoot };
 export { assertViteRoot };
 export { normalizeViteRoot };
 import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
-import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, isVikeConfigContextSet, } from '../vite/shared/resolveVikeConfigInternal.js';
+import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, isVikeConfigContextSet, EARLY_SETTINGS, } from '../vite/shared/resolveVikeConfigInternal.js';
 import path from 'node:path';
 import { assert, assertUsage, assertWarning } from '../../utils/assert.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
@@ -16,92 +16,95 @@ import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
 import { getVikeApiOperation, isVikeCliOrApi } from '../../shared-server-node/api-context.js';
 import { getViteCliCommand, getViteCliArgs } from '../vite/shared/isViteCli.js';
 import './assertEnvApiDevAndProd.js';
-const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
-async function resolveViteConfigFromUser() {
+const globalObject = getGlobalObject('resolveViteConfigUser.ts', {});
+async function resolveViteConfigUser() {
     const { viteContext } = getVikeApiContext();
     assert(viteContext);
-    const viteInfo = await getViteInfo(viteContext);
-    const { viteConfigFromUserResolved } = viteInfo;
-    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserResolved, viteContext);
+    const { viteConfigUser, root } = await resolve(viteContext);
+    const { viteConfigResolved } = await assertViteRoot2(root, viteConfigUser, viteContext);
     return {
         viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
-        viteConfigFromUserResolved,
+        viteConfigUser,
     };
 }
 async function getVikeConfigInternalEarly() {
-    assert(!globalObject.isOnlyResolvingUserConfig); // ensure no infinite loop
+    assert(!globalObject.isResolvingViteConfigUser); // ensure no infinite loop
     if (!isVikeConfigContextSet()) {
         const viteContext = getViteContext();
-        const viteInfo = await getViteInfo(viteContext);
-        setVikeConfigContext_(viteInfo, viteContext);
+        const resolved = await resolve(viteContext);
+        setVikeConfigContext_(resolved, viteContext);
     }
     return await getVikeConfigInternal();
 }
-function setVikeConfigContext_(viteInfo, viteContext) {
+function setVikeConfigContext_(resolved, viteContext) {
     setVikeConfigContext({
-        userRootDir: viteInfo.root,
+        userRootDir: resolved.root,
         isDev: viteContext === 'dev',
-        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
+        vikeVitePluginOptions: resolved.vikeVitePluginOptions,
     });
 }
-function isOnlyResolvingUserConfig() {
-    return globalObject.isOnlyResolvingUserConfig;
+function isResolvingViteConfigUser() {
+    return globalObject.isResolvingViteConfigUser;
 }
 async function getViteRoot(viteContext) {
     if (!globalObject.root)
-        await getViteInfo(viteContext);
+        await resolve(viteContext);
     assert(globalObject.root);
     return globalObject.root;
 }
-async function getViteInfo(viteContext) {
-    const { viteConfigFromUserVikeApiOptions } = getVikeApiContext();
-    let viteConfigFromUserResolved = clone(viteConfigFromUserVikeApiOptions ?? {});
+async function resolve(viteContext) {
     // Precedence:
-    // 1. (highest precedence)  |  viteConfigFromUserEnvVar          |  VITE_CONFIG
-    // 2.                       |  viteConfigFromUserVikeSettings    |  VIKE_CONFIG & Vike CLI options — only `+mode` & `+root`
-    // 3.                       |  viteConfigFromUserViteCli         |  Vite CLI args — `[root]` & `-c/--config`
-    // 4.                       |  viteConfigFromUserVikeApiOptions  |  Vike API options
-    // 5. (lowest precedence)   |  viteConfigFromUserViteConfigFile  |  vite.config.js
-    // Resolve Vite CLI args (when invoked via Vite's CLI rather than Vike's API).
-    // Without this, Vike loads vite.config.js blind to `vite [root]` / `-c <file>` and
-    // ends up with the wrong root when those Vite CLI args are used.
-    const viteConfigFromUserViteCli = getViteCliArgs();
-    if (viteConfigFromUserViteCli) {
-        viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserViteCli);
+    // 1. (highest precedence)  |  viteConfigFromViteEnv       |  VITE_CONFIG
+    // 2.                       |  viteConfigFromVikeCliOrEnv  |  VIKE_CONFIG & Vike CLI options — `+mode` & `+root`
+    // 3.                       |  viteConfigFromViteCli       |  Vite CLI args — `[root]` & `-c/--config`
+    // 4.                       |  viteConfigFromVikeApi       |  Vike API options — `viteConfig`, and `+mode` & `+root` from `vikeConfig`
+    // 5. (lowest precedence)   |  viteConfigFromViteFile      |  vite.config.js
+    let viteConfigUser = {};
+    const addConfig = (c) => {
+        // Merge `c` overriding viteConfigUser (`c` wins — higher precedence)
+        viteConfigUser = mergeConfig(viteConfigUser, c ?? {});
+    };
+    const underride = (c) => {
+        // Merge `c` underiding viteConfigUser (`c` loses — lower precedence)
+        return mergeConfig(c ?? {}, viteConfigUser);
+    };
+    // Vike API args
+    {
+        const { viteConfigFromVikeApi, vikeConfigFromApi } = getVikeApiContext();
+        addConfig(viteConfigFromVikeApi); // `viteConfig`
+        addConfig(pick(vikeConfigFromApi ?? {}, EARLY_SETTINGS)); // `+mode` & `+root`
     }
-    // Resolve Vike's +mode and +root settings.
-    // These alias Vite settings that need to be resolved early: +root determines where Vike looks for
-    // +config.js files (so it can't be defined inside +config.js itself), and +mode affects which
-    // vite.config.js environment is loaded. That's why — unlike +host/+port/+force which are applied
-    // later from the resolved Vike config — they're read here from Vike's CLI options & VIKE_CONFIG only.
+    // Vite CLI args (when invoked via Vite's CLI rather than Vike's API).
+    // - Without this, Vike loads vite.config.js blind to `vite [root]` / `-c <file>` and ends up with the wrong root when those Vite CLI args are used.
     {
-        const viteConfigFromUserVikeSettings = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, [
-            'mode',
-            'root',
-        ]);
-        if (Object.keys(viteConfigFromUserVikeSettings).length > 0) {
-            viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserVikeSettings);
-        }
+        const viteConfigFromViteCli = getViteCliArgs();
+        addConfig(viteConfigFromViteCli);
     }
-    // Resolve VITE_CONFIG
-    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
-    if (viteConfigFromUserEnvVar) {
-        viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserEnvVar);
+    // Vike's CLI and VIKE_CONFIG — `+mode` & `+root`
+    {
+        const viteConfigFromVikeCliOrEnv = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, EARLY_SETTINGS);
+        addConfig(viteConfigFromVikeCliOrEnv);
     }
-    // Resolve vite.config.js
-    globalObject.isOnlyResolvingUserConfig = true;
-    const viteConfigFromUserViteConfigFile = await loadViteConfigFile(viteConfigFromUserResolved, viteContext);
-    globalObject.isOnlyResolvingUserConfig = false;
-    // Correct precedence, replicates Vite:
-    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
-    const viteConfigResolved = merge(viteConfigFromUserViteConfigFile ?? {}, viteConfigFromUserResolved ?? {});
-    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
+    // VITE_CONFIG
+    {
+        const viteConfigFromViteEnv = getEnvVarObject('VITE_CONFIG');
+        addConfig(viteConfigFromViteEnv);
+    }
+    // vite.config.js — lowest precedence. Merged into a *separate* result (used only to compute `root` and to
+    // find the Vike plugin): it must not flow back into `viteConfigUser`, which is handed to Vite —
+    // Vite loads vite.config.js itself, so merging it here would add the Vike plugin twice.
+    // Replicates Vite: https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
+    globalObject.isResolvingViteConfigUser = true;
+    const viteConfigFromViteFile = await loadViteConfigFile(viteConfigUser, viteContext);
+    globalObject.isResolvingViteConfigUser = false;
+    const viteConfigAll = underride(viteConfigFromViteFile ?? {});
+    const root = normalizeViteRoot(viteConfigAll.root ?? process.cwd());
     globalObject.root = root;
     // - Find options `vike(options)` set in vite.config.js
     //   - TO-DO/next-major-release: remove
     // - Add Vike's Vite plugin if missing
     let vikeVitePluginOptions;
-    const found = findVikeVitePlugin(viteConfigResolved);
+    const found = findVikeVitePlugin(viteConfigAll);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -109,28 +112,21 @@ async function getViteInfo(viteContext) {
         // Show a warning because Vike supports Vite's CLI (as well as third-party CLIs).
         // - Encourage users to define a vite.config.js file that also works with Vite's CLI (and potentially other third-party CLIs).
         // - Vike-based frameworks, such as DocPress, allow their users to omit defining a vite.config.js file.
-        assertWarning(!viteConfigFromUserViteConfigFile, // Only show the warning if the user defined a vite.config.js file
+        assertWarning(!viteConfigFromViteFile, // Only show the warning if the user defined a vite.config.js file
         "Omitting Vike's Vite plugin (inside your vite.config.js) is deprecated — make sure to always add Vike's Vite plugin https://vike.dev/vite-plugin", { onlyOnce: true });
         // Add Vike to plugins if not present.
         // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await import('../vite/index.js');
-        viteConfigFromUserResolved = {
-            ...viteConfigFromUserResolved,
-            plugins: [...(viteConfigFromUserResolved?.plugins ?? []), vikePlugin()],
+        viteConfigUser = {
+            ...viteConfigUser,
+            plugins: [...(viteConfigUser?.plugins ?? []), vikePlugin()],
         };
-        const res = findVikeVitePlugin(viteConfigFromUserResolved);
+        const res = findVikeVitePlugin(viteConfigUser);
         assert(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     assert(vikeVitePluginOptions);
-    return { root, vikeVitePluginOptions, viteConfigFromUserResolved };
-}
-/** `c2` overrides `c1` */
-function merge(c1, c2) {
-    return mergeConfig(c1, c2);
-}
-function clone(c) {
-    return mergeConfig({}, c);
+    return { viteConfigUser, root, vikeVitePluginOptions };
 }
 function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
@@ -148,8 +144,8 @@ function findVikeVitePlugin(viteConfig) {
     return { vikeVitePluginOptions };
 }
 // Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfigFromUserResolved, viteContext) {
-    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+async function loadViteConfigFile(viteConfigUser, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigUser, viteContext);
     const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = viteContextResolved;
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
@@ -205,11 +201,12 @@ function getViteContextWithOperation(operation) {
 function getVikeApiContext() {
     const vikeApiOperation = getVikeApiOperation();
     if (!vikeApiOperation)
-        return { viteConfigFromUserVikeApiOptions: null, viteContext: null };
+        return { viteConfigFromVikeApi: null, vikeConfigFromApi: null, viteContext: null };
     const { options, operation } = vikeApiOperation;
-    const viteConfigFromUserVikeApiOptions = options.viteConfig;
+    const viteConfigFromVikeApi = options.viteConfig;
+    const vikeConfigFromApi = options.vikeConfig;
     const viteContext = getViteContextWithOperation(operation);
-    return { viteConfigFromUserVikeApiOptions, viteContext };
+    return { viteConfigFromVikeApi, vikeConfigFromApi, viteContext };
 }
 function resolveViteContext(inlineConfig = {}, viteContext) {
     const isBuild = viteContext === 'build';
@@ -222,15 +219,15 @@ function resolveViteContext(inlineConfig = {}, viteContext) {
     return viteContextResolved;
 }
 function normalizeViteRoot(root) {
-    // `path.resolve(viteConfigFromUserViteFile.configFile, root)` could be more intuitive than `path.resolve(process.cwd(), root)` but we replicate Vite's behavior (`vite.config.js` should follow Vite's API), see:
+    // `path.resolve(viteConfigUserViteFile.configFile, root)` could be more intuitive than `path.resolve(process.cwd(), root)` but we replicate Vite's behavior (`vite.config.js` should follow Vite's API), see:
     // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1063
     return toPosixPath(
     // Equivalent to `path.resolve(process.cwd(), root)`
     path.resolve(root));
 }
 const errMsg = `A Vite plugin is modifying the Vite setting ${pc.cyan('root')} which is forbidden`;
-async function assertViteRoot2(root, viteConfigFromUserResolved, viteContext) {
-    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+async function assertViteRoot2(root, viteConfigUser, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigUser, viteContext);
     // We can eventually remove this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering and preview which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
     const viteConfigResolved = await resolveConfig(...viteContextResolved);
     assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);

package/dist/node/cli/parseCli.js

@@ -78,10 +78,10 @@ function showHelp() {
         'Common CLI options:',
         [
             `vike dev ${pc.cyan('--host')}          ${TAB}${pc.dim('# Make server available over LAN and public addresses')}`,
-            `vike dev ${pc.cyan('--port')} 80       ${TAB}${pc.dim('# Change the server port')}`,
-            `vike build ${pc.cyan('--mode')} staging${TAB}${pc.dim('# Set the mode to run in')}`,
+            `vike dev ${pc.cyan('--port')} 80       ${TAB}${pc.dim('# Set server port')}`,
+            `vike build ${pc.cyan('--mode')} staging${TAB}${pc.dim('# Set mode (e.g. development, production, staging)')}`,
             `vike dev ${pc.cyan('--force')}         ${TAB}${pc.dim("# Disable Vite's cache")}`,
-            `vike dev ${pc.cyan('--root')} src      ${TAB}${pc.dim('# Set the project root directory')}`,
+            `vike dev ${pc.cyan('--root')} src      ${TAB}${pc.dim('# Set project root directory')}`,
         ]
             .map((o) => `  ${pc.dim('$')} ${o}`)
             .join('\n'),

package/dist/node/createDevMiddleware.js

@@ -18,8 +18,8 @@ async function createDevMiddleware(options = {}) {
             },
         },
     };
-    const { viteConfigFromUserResolved } = await prepareViteApiCall(optionsMod, 'dev');
-    const server = await createServer(viteConfigFromUserResolved);
+    const { viteConfigUser } = await prepareViteApiCall(optionsMod, 'dev');
+    const server = await createServer(viteConfigUser);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };
 }

package/dist/node/prerender/runPrerenderEntry.js

@@ -19,8 +19,8 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigFromUserResolved } = await prepareViteApiCall({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigFromUserResolved }, '$ vike prerender');
+        const { viteConfigUser } = await prepareViteApiCall({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigUser }, '$ vike prerender');
     }
     catch (err) {
         // Error may come from user-land

package/dist/node/vite/index.js

@@ -37,7 +37,7 @@ import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev
 import { isVikeCliOrApi } from '../../shared-server-node/api-context.js';
 import { pluginViteConfigVikeExtensions } from './plugins/pluginViteConfigVikeExtensions.js';
 import { pluginStripPointerImportAttribute } from './plugins/pluginStripPointerImportAttribute.js';
-import { getVikeConfigInternalEarly, isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
+import { getVikeConfigInternalEarly, isResolvingViteConfigUser } from '../api/resolveViteConfigUser.js';
 import './assertEnvVite.js';
 import { isStorybook } from '../../utils/isStorybook.js';
 import { pluginUniversalDeploy } from './plugins/pluginUniversalDeploy.js';
@@ -96,7 +96,7 @@ function pluginNonRunnabeDev() {
 }
 function removeVitePlugin() {
     // Early resolving of user Vite configs
-    if (isOnlyResolvingUserConfig()) {
+    if (isResolvingViteConfigUser()) {
         return true;
     }
     // *****************/

package/dist/node/vite/plugins/build/pluginBuildApp.js

@@ -166,8 +166,8 @@ function isPrerenderForceExit() {
 }
 function getFullBuildInlineConfig(config) {
     const configFromCli = !isViteCli() ? null : getViteBuildCliArgs();
-    if (config._viteConfigFromUserResolved) {
-        return config._viteConfigFromUserResolved;
+    if (config._viteConfigUser) {
+        return config._viteConfigUser;
     }
     else {
         return {

package/dist/node/vite/plugins/pluginCommon.d.ts

@@ -8,7 +8,7 @@ declare module 'vite' {
         _isDev?: boolean;
         _rootResolvedEarly?: string;
         _baseViteOriginal?: string;
-        _viteConfigFromUserResolved?: InlineConfig;
+        _viteConfigUser?: InlineConfig;
         _viteVersionResolved?: string;
     }
 }

package/dist/node/vite/plugins/pluginCommon.js

@@ -9,7 +9,7 @@ import { assertRollupInput } from './build/pluginBuildConfig.js';
 import pc from '@brillout/picocolors';
 import { assertResolveAlias } from './pluginCommon/assertResolveAlias.js';
 import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVikeConfigInternal.js';
-import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigFromUser.js';
+import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigUser.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 import { version as viteVersionVike } from 'vite';
 import '../assertEnvVite.js';

package/dist/node/vite/shared/resolveVikeConfigInternal/metaBuiltIn.js

@@ -198,7 +198,9 @@ const metaBuiltIn = {
     mode: {
         env: { config: true },
         global: true,
+        /* +mode can't be set in +config.js => a +config.js change never affects it — no Vite restart needed
         vite: true,
+        */
     },
     force: {
         env: { config: true },
@@ -208,7 +210,9 @@ const metaBuiltIn = {
     root: {
         env: { config: true },
         global: true,
+        /* +root can't be set in +config.js => a +config.js change never affects it — no Vite restart needed
         vite: true,
+        */
     },
     csp: {
         env: { server: true },

package/dist/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -9,6 +9,7 @@ export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
+export { EARLY_SETTINGS };
 export type { VikeConfigInternal };
 export type { PageConfigBuildTimeBeforeComputed };
 import type { PageConfigGlobalBuildTime, ConfigEnv, PageConfigBuildTime, DefinedAtFilePath } from '../../../types/PageConfig.js';
@@ -62,6 +63,7 @@ declare function getVikeConfigFromCliOrEnv(): {
     configFromCliOptions: import("../../cli/parseCli.js").CliOptions | null;
     configFromEnvVar: Record<string, unknown> | null;
 };
+declare const EARLY_SETTINGS: readonly ["root", "mode"];
 type PageConfigBuildTimeBeforeComputed = Omit<PageConfigBuildTime, 'configValuesComputed'>;
 declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitionsInternal, configName: string): {
     env: ConfigEnv;

package/dist/node/vite/shared/resolveVikeConfigInternal.js

@@ -10,6 +10,7 @@ export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
+export { EARLY_SETTINGS };
 import { deepEqual } from '../../../utils/deepEqual.js';
 import { assertKeys } from '../../../utils/assertKeys.js';
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
@@ -220,6 +221,7 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, pageConfigs, configDefinitionsResolved);
+    warnEarlySettingsInConfigFile(pageConfigGlobal);
     const globalConfigPublic = resolveGlobalConfig(pageConfigGlobal, pageConfigs);
     const prerenderContext = await resolvePrerenderContext({
         config: globalConfigPublic.config,
@@ -536,6 +538,30 @@ function getSourceNonConfigFile(configName, value, definedAt, configDefinitionsG
     };
     return source;
 }
+// Settings that must be resolved early before Vike crawls +config.js files:
+// - They can't be defined inside +config.js files.
+// - They must be set early (via Vike's CLI/API options or VIKE_CONFIG), and read early before Vike's main config resolution.
+const EARLY_SETTINGS = [
+    // +root determines where Vike looks for +config.js files (so it can't be defined inside +config.js itself)
+    'root',
+    // +mode affects which vite.config.js environment is loaded
+    'mode',
+];
+function warnEarlySettingsInConfigFile(pageConfigGlobal) {
+    for (const configName of EARLY_SETTINGS) {
+        const sources = pageConfigGlobal.configValueSources[configName];
+        if (!sources)
+            continue;
+        for (const source of sources) {
+            if (!source.plusFile) {
+                // `plusFile === null` => source comes from Vike CLI argument, Vike API option, or VIKE_CONFIG
+                continue;
+            }
+            const configDefinedAt = getConfigDefinedAt('Config', configName, source.definedAt);
+            assertWarning(false, `${configDefinedAt} has no effect: it can't be set from a ${pc.cyan('+')} file — see ${pc.underline(`https://vike.dev/${configName}`)}`, { onlyOnce: true });
+        }
+    }
+}
 function sortConfigValueSources(configValueSources, locationIdPage) {
     Object.entries(configValueSources).forEach(([configName, sources]) => {
         sources

package/dist/types/Config.d.ts

@@ -492,10 +492,6 @@ type ConfigBuiltIn = {
     /**
      * The root directory of your project.
      *
-     * Can be an absolute path, or a path relative to the current working directory.
-     *
-     * @default process.cwd()
-     *
      * https://vike.dev/root
      */
     root?: string;

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.259-commit-a909f04";
+export declare const PROJECT_VERSION: "0.4.259-commit-286bd57";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.259-commit-a909f04';
+export const PROJECT_VERSION = '0.4.259-commit-286bd57';

package/dist/utils/pick.d.ts

@@ -1 +1 @@
-export declare function pick<Obj extends object, Keys extends keyof Obj>(obj: Obj, keys: Keys[]): Pick<Obj, Keys>;
+export declare function pick<Obj extends object, Keys extends keyof Obj>(obj: Obj, keys: readonly Keys[]): Pick<Obj, Keys>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.259-commit-a909f04",
+  "version": "0.4.259-commit-286bd57",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {