vike 0.4.259-commit-85c5e84 → 0.4.259-commit-dcc116b

package/dist/node/api/resolveViteConfigFromUser.js

@@ -5,7 +5,7 @@ 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';
@@ -53,27 +53,38 @@ async function getViteRoot(viteContext) {
     assert(globalObject.root);
     return globalObject.root;
 }
+// TODO rename to resolveViteConfig
+// TODO rename_all viteConfigFromUser viteConfigFrom
+// TODO rename_all vikeConfigFromUser vikeConfigFrom
 async function getViteInfo(viteContext) {
-    const { viteConfigFromUserVikeApiOptions } = getVikeApiContext();
-    let viteConfigFromUserResolved = clone(viteConfigFromUserVikeApiOptions ?? {});
     // Precedence:
     // 1. (highest precedence)  |  viteConfigFromUserEnvVar          |  VITE_CONFIG
-    // 2.                       |  viteConfigFromUserVikeMode        |  VIKE_CONFIG & Vike CLI options — only `+mode`
+    // 2.                       |  viteConfigFromVikeCliOrEnv        |  VIKE_CONFIG & Vike CLI options — `+mode` & `+root`
     // 3.                       |  viteConfigFromUserViteCli         |  Vite CLI args — `[root]` & `-c/--config`
-    // 4.                       |  viteConfigFromUserVikeApiOptions  |  Vike API options
+    // 4.                       |  viteConfigFromUserVikeApiOptions  |  Vike API options — `viteConfig`, and `+mode` & `+root` from `vikeConfig`
     // 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.
+    let viteConfigFromUserResolved = {};
+    // Vike API args
+    const { viteConfigFromUserVikeApiOptions, vikeConfigFromUserVikeApiOptions } = getVikeApiContext();
+    // - Resolve `viteConfig` set over Vike's API
+    viteConfigFromUserResolved = merge(viteConfigFromUserResolved, viteConfigFromUserVikeApiOptions ?? {});
+    // - Resolve +mode/+root set over Vike's API
+    {
+        const viteConfigFromVikeApi2 = pick(vikeConfigFromUserVikeApiOptions ?? {}, EARLY_SETTINGS);
+        viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromVikeApi2);
+    }
+    // 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);
     }
-    // Resolve Vike's +mode setting
+    // Vike's CLI and VIKE_CONFIG
+    // - Resolve +mode/+root set over Vike's CLI or VIKE_CONFIG
     {
-        const viteConfigFromUserVikeMode = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
-        if (Object.keys(viteConfigFromUserVikeMode).length > 0) {
-            viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserVikeMode);
+        const viteConfigFromVikeCliOrEnv = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, EARLY_SETTINGS);
+        if (Object.keys(viteConfigFromVikeCliOrEnv).length > 0) {
+            viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromVikeCliOrEnv);
         }
     }
     // Resolve VITE_CONFIG
@@ -85,7 +96,7 @@ async function getViteInfo(viteContext) {
     globalObject.isOnlyResolvingUserConfig = true;
     const viteConfigFromUserViteConfigFile = await loadViteConfigFile(viteConfigFromUserResolved, viteContext);
     globalObject.isOnlyResolvingUserConfig = false;
-    // Correct precedence, replicates Vite:
+    // Lowest precedence. The `merge()` applies the correct precedence and 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());
@@ -122,9 +133,6 @@ async function getViteInfo(viteContext) {
 function merge(c1, c2) {
     return mergeConfig(c1, c2);
 }
-function clone(c) {
-    return mergeConfig({}, c);
-}
 function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
     let vikeVitePuginFound = false;
@@ -198,11 +206,12 @@ function getViteContextWithOperation(operation) {
 function getVikeApiContext() {
     const vikeApiOperation = getVikeApiOperation();
     if (!vikeApiOperation)
-        return { viteConfigFromUserVikeApiOptions: null, viteContext: null };
+        return { viteConfigFromUserVikeApiOptions: null, vikeConfigFromUserVikeApiOptions: null, viteContext: null };
     const { options, operation } = vikeApiOperation;
     const viteConfigFromUserVikeApiOptions = options.viteConfig;
+    const vikeConfigFromUserVikeApiOptions = options.vikeConfig;
     const viteContext = getViteContextWithOperation(operation);
-    return { viteConfigFromUserVikeApiOptions, viteContext };
+    return { viteConfigFromUserVikeApiOptions, vikeConfigFromUserVikeApiOptions, viteContext };
 }
 function resolveViteContext(inlineConfig = {}, viteContext) {
     const isBuild = viteContext === 'build';

package/dist/node/cli/parseCli.js

@@ -29,28 +29,41 @@ function getCommand() {
 function getCliOptions() {
     let cliOptions = {};
     let configNameCurrent;
-    const commitIfDefinedWithoutValue = () => {
+    const addConfig = (configValue) => {
+        assert(configNameCurrent);
+        cliOptions[configNameCurrent] = configValue;
+        configNameCurrent = undefined;
+    };
+    const addConfigWithoutValue = () => {
         if (configNameCurrent)
-            commit(true);
+            addConfig(true);
     };
-    const commit = (val) => {
+    const addConfigWithValue = (configValueStr) => {
         assert(configNameCurrent);
-        cliOptions[configNameCurrent] = val;
-        configNameCurrent = undefined;
+        addConfig(parseJson5(configValueStr, `CLI option --${configNameCurrent}`));
     };
     for (const arg of process.argv.slice(3)) {
         showHelpOrVersion(arg);
         if (arg.startsWith('--')) {
-            commitIfDefinedWithoutValue();
-            configNameCurrent = arg.slice('--'.length);
+            addConfigWithoutValue();
+            const str = arg.slice('--'.length);
+            const eqIdx = str.indexOf('=');
+            if (eqIdx === -1) {
+                configNameCurrent = str;
+            }
+            else {
+                configNameCurrent = str.slice(0, eqIdx);
+                const configValueStr = str.slice(eqIdx + 1);
+                addConfigWithValue(configValueStr);
+            }
         }
         else {
             if (!configNameCurrent)
                 wrongUsage(`Unknown option ${pc.bold(arg)}`);
-            commit(parseJson5(arg, `CLI option --${configNameCurrent}`));
+            addConfigWithValue(arg);
         }
     }
-    commitIfDefinedWithoutValue();
+    addConfigWithoutValue();
     return cliOptions;
 }
 function showHelp() {
@@ -65,9 +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 project root directory')}`,
         ]
             .map((o) => `  ${pc.dim('$')} ${o}`)
             .join('\n'),

package/dist/node/vite/plugins/pluginDev/optimizeDeps.js

@@ -3,6 +3,7 @@ export { resolveOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert } from '../../../../utils/assert.js';
 import { createDebug } from '../../../../utils/debug.js';
+import { deepEqual } from '../../../../utils/deepEqual.js';
 import { isArray } from '../../../../utils/isArray.js';
 import { isFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
 import { assertImportIsNpmPackage, getNpmPackageName } from '../../../../utils/parseNpmPackage.js';
@@ -70,9 +71,9 @@ const optimizeDeps = {
 // - Make server environments inherit from ssr.optimizeDeps (it isn't the case by default)
 async function resolveOptimizeDeps(config) {
     const vikeConfig = await getVikeConfigInternal();
-    const { _pageConfigs: pageConfigs } = vikeConfig;
+    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
     // Retrieve user's + files (i.e. Vike entries)
-    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
+    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs, pageConfigGlobal);
     // Add late discovered dependencies, if they exist
     LATE_DISCOVERED.forEach((dep) => {
         const userRootDir = config.root;
@@ -114,18 +115,19 @@ async function resolveOptimizeDeps(config) {
         env.optimizeDeps.entries = remove(env.optimizeDeps.entries ?? []);
     }
     // Debug
-    if (debug.isActivated)
-        debug('optimizeDeps', {
-            'config.optimizeDeps.entries': config.optimizeDeps.entries,
-            'config.optimizeDeps.include': config.optimizeDeps.include,
-            'config.optimizeDeps.exclude': config.optimizeDeps.exclude,
-            // @ts-ignore Vite doesn't seem to support ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
-            'config.ssr.optimizeDeps.entries': config.ssr.optimizeDeps.entries,
-            'config.ssr.optimizeDeps.include': config.ssr.optimizeDeps.include,
-            'config.ssr.optimizeDeps.exclude': config.ssr.optimizeDeps.exclude,
-        });
+    if (debug.isActivated) {
+        const envs = {};
+        for (const envName in config.environments) {
+            const env = config.environments[envName];
+            envs[`config.environments.${envName}.optimizeDeps.entries`] = env.optimizeDeps.entries;
+            envs[`config.environments.${envName}.optimizeDeps.include`] = env.optimizeDeps.include;
+            envs[`config.environments.${envName}.optimizeDeps.exclude`] = env.optimizeDeps.exclude;
+        }
+        debug('optimizeDeps', envs);
+        assertEnvsInSyncWithLegacy(config);
+    }
 }
-async function getPageDeps(config, pageConfigs) {
+async function getPageDeps(config, pageConfigs, pageConfigGlobal) {
     let entriesClient = [];
     let entriesServer = [];
     let includeClient = [];
@@ -181,7 +183,8 @@ async function getPageDeps(config, pageConfigs) {
     {
         ;
         [true, false].forEach((isForClientSide) => {
-            pageConfigs.forEach((pageConfig) => {
+            ;
+            [...pageConfigs, pageConfigGlobal].forEach((pageConfig) => {
                 Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
                     const runtimeEnv = {
                         isForClientSide,
@@ -213,10 +216,15 @@ async function getPageDeps(config, pageConfigs) {
         });
     }
     // Add virtual files.
-    // - This doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
-    //   - Should we make it work? E.g. by creating a temporary file at node_modules/.vike/virtualFiles.js
-    //   - Or should we remove it? And make sure getPageDeps() also works for aliased import paths
-    //     - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
+    // - Vite 8+ (Rolldown-based dep scanner) crawls virtual IDs natively — its scanner routes
+    //   through `environment.pluginContainer.resolveId()`, so Vike's resolveId/load handlers
+    //   run during the scan and the virtual file's transitive deps are seen.
+    // - Vite ≤7 (esbuild-based dep scanner) cannot crawl virtual IDs — those virtuals' deps
+    //   surface lazily and trigger "✨ new dependencies optimized" reload cycles. As a
+    //   workaround we could materialize each virtual to a real file under
+    //   `node_modules/.vike/optimizeDeps-virtuals/`; an implementation lives in the reverted
+    //   commit https://github.com/vikejs/vike/commit/b068009c3 (re-apply if Vite ≤7 support
+    //   matters).
     {
         const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
         Object.values(clientEntries).forEach(({ entryTarget, entryFilePath }) => {
@@ -265,3 +273,20 @@ function remove(input) {
     list = list.filter((e) => !ALWAYS_REMOVE.includes(e));
     return list;
 }
+// Sanity-check that the legacy `config.optimizeDeps` and `config.ssr.optimizeDeps` slots
+// stay in sync with the corresponding environment values — so logging only the env values
+// (above) isn't hiding anything.
+function assertEnvsInSyncWithLegacy(config) {
+    const client = config.environments.client?.optimizeDeps;
+    assert(client);
+    assert(deepEqual(config.optimizeDeps.entries, client.entries));
+    assert(deepEqual(config.optimizeDeps.include, client.include));
+    assert(deepEqual(config.optimizeDeps.exclude, client.exclude));
+    const ssr = config.environments.ssr?.optimizeDeps;
+    assert(ssr);
+    /* Vite doesn't seem to support config.ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
+    assert(deepEqual(config.ssr.optimizeDeps.entries, ssr.entries))
+    */
+    assert(deepEqual(config.ssr.optimizeDeps.include, ssr.include));
+    assert(deepEqual(config.ssr.optimizeDeps.exclude, ssr.exclude));
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerConfig.d.ts

@@ -7,6 +7,5 @@ declare function getServerConfig(vikeConfig: VikeConfigInternal): {
     serverEntryId: string;
     serverEntryVike: string;
     serverFilePath: string | null;
-    isServerEntry: boolean;
 } | undefined;
 declare function isUniversalDeployVitePreview(vikeConfig: VikeConfigInternal, viteConfigResolved: ResolvedConfig): boolean | null;

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerConfig.js

@@ -1,6 +1,5 @@
 export { getServerConfig };
 export { isUniversalDeployVitePreview };
-import { dirname, resolve } from 'node:path';
 import { catchAllEntry } from '@universal-deploy/store';
 import { assert } from '../../../../utils/assert.js';
 import '../../assertEnvVite.js';
@@ -8,7 +7,6 @@ function getServerConfig(vikeConfig) {
     let serverEntryId;
     let serverFilePath = null;
     let serverEntryVike;
-    let isServerEntry = false;
     // universal-deploy support must be manually enabled
     const serverConfig = 
     // +config.js > `export default { server: true }`
@@ -23,13 +21,8 @@ function getServerConfig(vikeConfig) {
         assert('filePathAbsoluteFilesystem' in serverPlusFile.definedAt);
         serverFilePath = serverPlusFile.definedAt.filePathAbsoluteFilesystem;
         assert(serverFilePath);
-        assert(serverPlusFile.valueIsLoaded);
-        assert(typeof serverPlusFile.value === 'object');
-        // +server.js > `export default { entry: './server/entrypoint.ts' }`
-        const entry = serverPlusFile.value.entry;
-        isServerEntry = typeof entry === 'string';
-        assert(entry === undefined || isServerEntry);
-        serverEntryVike = serverEntryId = isServerEntry ? resolve(dirname(serverFilePath), entry) : serverFilePath;
+        serverEntryId = serverFilePath;
+        serverEntryVike = serverFilePath;
     }
     else {
         serverEntryId = catchAllEntry;
@@ -43,7 +36,6 @@ function getServerConfig(vikeConfig) {
         // It either points to the default fetchable endpoint (vike/fetch), or one defined by the user through +server.
         serverEntryVike,
         serverFilePath,
-        isServerEntry,
     };
 }
 function isUniversalDeployVitePreview(vikeConfig, viteConfigResolved) {

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

@@ -24,9 +24,9 @@ function pluginUniversalDeploy(vikeConfig) {
                 assertUsage(target === undefined, `${target} requires +server — see https://vike.dev/server`);
             }),
         ];
-    const { serverEntryVike, serverEntryId, serverFilePath, isServerEntry } = serverConfig;
+    const { serverEntryVike, serverEntryId, serverFilePath } = serverConfig;
     return [
-        ...universalDeploy({ entry: isServerEntry ? serverEntryVike : undefined }),
+        ...universalDeploy(),
         {
             name: 'vike:pluginUniversalDeploy:entries',
             config() {

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFilePageEntry.js

@@ -1,5 +1,5 @@
 export { generateVirtualFilePageEntry };
-import { assert, getProjectError } from '../../../../utils/assert.js';
+import { assert, getDebugInfoStr, getProjectError } from '../../../../utils/assert.js';
 import { parseVirtualFileId, generateVirtualFileId } from '../../../../shared-server-node/virtualFileId.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { extractAssetsAddQuery } from '../../../../shared-server-node/extractAssetsQuery.js';
@@ -26,12 +26,10 @@ async function generateVirtualFilePageEntry(id, isDev) {
         assert(pageConfig);
     }
     else {
-        /* This assertion sometimes fail. It happens very seldom and I couldn't reproduce it (https://gist.github.com/brillout/9e212ce829f4d62a912ca163ffa8881a). I suspect some kind of HMR race condition. UPDATE: [December 2024] This just happened at test/@cloudflare_vite-plugin/ — it isn't blocking, reloading the page fixes the issue.
-        assert(pageConfig, { id, pageId })
-        /*/
-        if (!pageConfig)
-            throw getProjectError('Outdated request');
-        //*/
+        if (!pageConfig) {
+            // Happens very seldom and can't reproduce reliably. Some kind of HMR race condition? It still happens as of June 2026 with Cloudflare Workers in development — but it isn't blocking, reloading the page fixes the issue.
+            throw getProjectError(`Outdated request. Try again. ${getDebugInfoStr({ id, pageId })}`);
+        }
     }
     const code = getCode(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);

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

@@ -198,13 +198,22 @@ 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 },
         global: true,
         vite: true,
     },
+    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 },
     },
@@ -227,7 +236,7 @@ const metaBuiltIn = {
         global: true,
     },
     server: {
-        env: { server: true, config: true },
+        env: { server: true },
         global: true,
     },
     cli: {

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';
@@ -219,7 +220,8 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
         globalObject.isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
-    setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
+    setCliAndApiOptions(pageConfigGlobal, pageConfigs, configDefinitionsResolved);
+    warnEarlySettingsInConfigFile(pageConfigGlobal);
     const globalConfigPublic = resolveGlobalConfig(pageConfigGlobal, pageConfigs);
     const prerenderContext = await resolvePrerenderContext({
         config: globalConfigPublic.config,
@@ -283,7 +285,7 @@ async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbu
         configNamesKnownAll,
         configNamesKnownGlobal,
     };
-    assertKnownConfigs(configDefinitionsResolved);
+    warnUnknownConfigs(configDefinitionsResolved);
     return configDefinitionsResolved;
 }
 // Load value files (with `env.config===true`) of *custom* configs.
@@ -464,29 +466,47 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
         }, pageConfigGlobal.configDefinitions));
     });
 }
-function setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved) {
+function setCliAndApiOptions(pageConfigGlobal, pageConfigs, configDefinitionsResolved) {
     // Vike API — passed options [lowest precedence]
     const vikeApiOperation = getVikeApiOperation();
     if (vikeApiOperation?.options.vikeConfig) {
-        addSources(vikeApiOperation.options.vikeConfig, { definedBy: 'api', operation: vikeApiOperation.operation }, false);
+        addSources(vikeApiOperation.options.vikeConfig, {
+            definedBy: 'api',
+            operation: vikeApiOperation.operation,
+        });
     }
     const { configFromCliOptions, configFromEnvVar } = getVikeConfigFromCliOrEnv();
     // Vike CLI options
     if (configFromCliOptions) {
-        addSources(configFromCliOptions, { definedBy: 'cli' }, true);
+        addSources(configFromCliOptions, { definedBy: 'cli' });
     }
     // VIKE_CONFIG [highest precedence]
     if (configFromEnvVar) {
-        addSources(configFromEnvVar, { definedBy: 'env' }, false);
+        addSources(configFromEnvVar, { definedBy: 'env' });
     }
     return;
-    function addSources(configValues, definedBy, exitOnError) {
+    function addSources(configValues, definedBy) {
         Object.entries(configValues).forEach(([configName, value]) => {
             var _a;
             const sourceName = `The ${getDefinedByString(definedBy, configName)}`;
-            assertKnownConfig(configName, configDefinitionsResolved.configNamesKnownGlobal, configDefinitionsResolved, '/', false, sourceName, exitOnError);
-            const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
-            sources.unshift(getSourceNonConfigFile(configName, value, definedBy, pageConfigGlobal.configDefinitions));
+            const isUnknown = isUnknownConfig(configName, configDefinitionsResolved.configNamesKnownAll, configDefinitionsResolved, '/', false, sourceName);
+            if (isUnknown)
+                return;
+            if (configName in pageConfigGlobal.configDefinitions) {
+                const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+                const source = getSourceNonConfigFile(configName, value, definedBy, pageConfigGlobal.configDefinitions);
+                sources.unshift(source);
+                return;
+            }
+            // Non-global config: inject into every page config that knows about it (highest precedence)
+            pageConfigs.forEach((pageConfig) => {
+                var _a;
+                if (!(configName in pageConfig.configDefinitions))
+                    return;
+                const sources = ((_a = pageConfig.configValueSources)[configName] ?? (_a[configName] = []));
+                const source = getSourceNonConfigFile(configName, value, definedBy, pageConfig.configDefinitions);
+                sources.unshift(source);
+            });
         });
     }
 }
@@ -518,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
@@ -973,29 +1017,32 @@ function getComputed(pageConfig) {
     });
     return configValuesComputed;
 }
-// Show error message upon unknown config
-function assertKnownConfigs(configDefinitionsResolved) {
+function warnUnknownConfigs(configDefinitionsResolved) {
     objectEntries(configDefinitionsResolved.configDefinitionsLocal).forEach(([_locationId, { configNamesKnownLocal, plusFiles }]) => {
         plusFiles.forEach((plusFile) => {
             const configNames = getConfigNamesSetByPlusFile(plusFile);
             configNames.forEach((configName) => {
                 const { locationId } = plusFile;
                 const sourceName = plusFile.filePath.filePathToShowToUser;
-                assertKnownConfig(configName, configNamesKnownLocal, configDefinitionsResolved, locationId, true, sourceName, false);
+                isUnknownConfig(configName, configNamesKnownLocal, configDefinitionsResolved, locationId, true, sourceName);
             });
         });
     });
 }
-function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitionsResolved, locationId, isPlusFile, sourceName, exitOnError) {
+function isUnknownConfig(configName, configNamesKnownRelevant, configDefinitionsResolved, locationId, isPlusFile, sourceName) {
     const { configNamesKnownAll } = configDefinitionsResolved;
     if (configNamesKnownRelevant.includes(configName)) {
         assert(configNamesKnownAll.includes(configName));
-        return;
+        return false;
     }
     const configNameColored = pc.cyan(configName);
+    const warn = (msg) => {
+        assertWarning(false, msg, { onlyOnce: true });
+        return true;
+    };
     // Inheritance issue: config is known but isn't defined at `locationId`
     if (configNamesKnownAll.includes(configName)) {
-        assertUsage(false, `${sourceName} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`, { exitOnError });
+        return warn(`${sourceName} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`);
     }
     const errMsg = isPlusFile
         ? `${sourceName} sets an unknown config ${configNameColored}`
@@ -1018,7 +1065,7 @@ function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitio
         if (configName in knownVikeExntensionConfigs) {
             const requiredVikeExtension = joinEnglish(knownVikeExntensionConfigs[configName].map((e) => pc.bold(e)), 'or');
             const errMsgEnhanced = `${errMsg}. If you want to use the configuration ${configNameColored} documented at ${pc.underline(`https://vike.dev/${configName}`)} then make sure to install ${requiredVikeExtension}. (Alternatively, you can define ${configNameColored} yourself by using ${pc.cyan('meta')}, see ${pc.underline('https://vike.dev/meta')} for more information.)`;
-            assertUsage(false, errMsgEnhanced, { exitOnError });
+            return warn(errMsgEnhanced);
         }
     }
     // Similarity hint
@@ -1035,9 +1082,9 @@ function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitio
         if (configName === 'page') {
             errMsgEnhanced += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.cyan('P')} because it defines a UI component: a ubiquitous JavaScript convention is that the name of UI components start with a capital letter.)`;
         }
-        assertUsage(false, errMsgEnhanced, { exitOnError });
+        return warn(errMsgEnhanced);
     }
-    assertUsage(false, errMsg, { exitOnError });
+    return warn(errMsg);
 }
 function determineRouteFilesystem(locationId, configValueSources) {
     const configName = 'filesystemRoutingRoot';

package/dist/types/Config.d.ts

@@ -489,6 +489,12 @@ type ConfigBuiltIn = {
      * https://vike.dev/force
      */
     force?: boolean;
+    /**
+     * The root directory of your project.
+     *
+     * https://vike.dev/root
+     */
+    root?: string;
     /**
      * Content Security Policy (CSP).
      *

package/dist/types/Server.d.ts

@@ -8,6 +8,5 @@ import type { Fetchable, ServerOptions } from '@universal-deploy/store';
 interface Server extends Fetchable {
     prod?: Omit<ServerOptions, 'fetch'> & {
         static?: boolean | string;
-        entry?: string;
     };
 }

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.259-commit-85c5e84";
+export declare const PROJECT_VERSION: "0.4.259-commit-dcc116b";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.259-commit-85c5e84';
+export const PROJECT_VERSION = '0.4.259-commit-dcc116b';

package/dist/utils/assert.d.ts

@@ -3,6 +3,7 @@ export { assertUsage };
 export { assertWarning };
 export { assertInfo };
 export { getProjectError };
+export { getDebugInfoStr };
 export { isVikeBug };
 export { setAssertOnBeforeLog };
 export { setAssertOnBeforeErr };
@@ -10,6 +11,7 @@ export { setAssertAlwaysShowStackTrace };
 export { setAssertAddAssertTagsDev };
 import type { AddAssertTagsDev } from '../node/vite/shared/loggerDev.js';
 declare function assert(condition: unknown, debugInfo?: unknown): asserts condition;
+declare function getDebugInfoStr(debugInfo: unknown): string | null;
 declare function assertUsage(condition: unknown, errMsg: string, { showStackTrace, exitOnError }?: {
     showStackTrace?: true;
     exitOnError?: boolean;

package/dist/utils/assert.js

@@ -3,6 +3,7 @@ export { assertUsage };
 export { assertWarning };
 export { assertInfo };
 export { getProjectError };
+export { getDebugInfoStr };
 export { isVikeBug };
 export { setAssertOnBeforeLog };
 export { setAssertOnBeforeErr };
@@ -24,17 +25,10 @@ const tagTypeBug = 'Bug';
 function assert(condition, debugInfo) {
     if (condition)
         return;
-    const debugStr = (() => {
-        if (!debugInfo) {
-            return null;
-        }
-        const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
-        return pc.dim(`Debug for maintainers (you can ignore this): ${debugInfoSerialized}`);
-    })();
     const link = pc.underline('https://github.com/vikejs/vike/issues/new?template=bug.yml');
     let errMsg = [
         `You stumbled upon a Vike bug. Go to ${link} and copy-paste this error. A maintainer will fix the bug (usually within 24 hours).`,
-        debugStr,
+        getDebugInfoStr(debugInfo),
     ]
         .filter(Boolean)
         .join(' ');
@@ -44,6 +38,12 @@ function assert(condition, debugInfo) {
     globalObject.onBeforeErr?.(internalError);
     throw internalError;
 }
+function getDebugInfoStr(debugInfo) {
+    if (!debugInfo)
+        return null;
+    const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
+    return pc.dim(`Debug for maintainers (you can ignore this): ${debugInfoSerialized}`);
+}
 function assertUsage(condition, errMsg, { showStackTrace, exitOnError } = {}) {
     if (condition)
         return;

package/dist/utils/getViteRPC.js

@@ -36,7 +36,7 @@ function createRpcClient() {
                 const hot = import.meta.hot;
                 assert(hot);
                 const callId = getRandomId();
-                const { promise, resolve } = genPromise({ timeout: 3 * 1000 });
+                const { promise, resolve } = genPromise({ timeout: 10 * 1000 });
                 listeners.push({
                     callId,
                     cb: (functionReturn) => {

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-85c5e84",
+  "version": "0.4.259-commit-dcc116b",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -146,7 +146,7 @@
     "semver": "^7.8.1",
     "sirv": "^3.0.2",
     "source-map-support": "^0.5.0",
-    "tinyglobby": "^0.2.16",
+    "tinyglobby": "^0.2.17",
     "vite": ">=6.3.0",
     "vite-plugin-wrapper": "^0.1.0"
   },