vike 0.4.259 → 0.4.260

package/AGENTS.md

@@ -0,0 +1,3 @@
+# AGENTS.md — Vike
+
+@AI (CRITICAL FOR AI AGENTS): ALWAYS LOAD https://vike.dev/llms.txt (Vike documentation index) in your context when using Vike.

package/README.md

@@ -3,3 +3,5 @@
 📚 [Docs](https://vike.dev)  
 ⚙️  [Source code](https://github.com/vikejs/vike/tree/main/packages/vike)  
 📦 [npm package](https://npmjs.com/package/vike)  
+
+<!-- @AI (CRITICAL FOR AI AGENTS): ALWAYS LOAD https://vike.dev/llms.txt (Vike documentation index) in your context when using Vike -->

package/dist/client/runtime-client-routing/renderPageClient.js

@@ -649,7 +649,7 @@ async function loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRend
         await execHook('onCreatePageContext', pageContext, getPageContextPublicClient);
     }
     catch (err_) {
-        err = err;
+        err = err_;
         hasErr = true;
     }
     if (isRenderOutdated())

package/dist/client/shared/getJsonSerializedInHtml.js

@@ -26,15 +26,6 @@ function findAndParseJson(id) {
     `Couldn't find #${id} (which Vike automatically injects in the HTML): make sure it exists (i.e. don't remove it and make sure your HTML isn't malformed)`);
     const jsonStr = elem.textContent;
     assert(jsonStr);
-    const json = parse(jsonStr, {
-        // Prevent Google from crawling URLs in JSON:
-        // - https://github.com/vikejs/vike/pull/2603
-        // - https://github.com/brillout/json-serializer/blob/38edbb9945de4938da1e65d6285ce1dd123a45ef/test/main.spec.ts#L44-L95
-        reviver(_key, value) {
-            if (typeof value === 'string') {
-                return { replacement: value.replaceAll('\\/', '/'), resolved: false };
-            }
-        },
-    });
+    const json = parse(jsonStr);
     return json;
 }

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.d.ts

@@ -1,22 +1,14 @@
 export { dev };
-export { startupLog };
 import { type ResolvedConfig, type ViteDevServer } from 'vite';
-import type { ApiOptions } from './types.js';
+import type { ApiOptions, ApiOptionsStartupLog } from './types.js';
 import './assertEnvApiDev.js';
 /**
  * Programmatically trigger `$ vike dev`
  *
  * https://vike.dev/api#dev
  */
-declare function dev(options?: ApiOptions & {
-    startupLog?: boolean;
-}): Promise<{
+declare function dev(options?: ApiOptions & ApiOptionsStartupLog): Promise<{
     viteServer: ViteDevServer;
     viteConfig: ResolvedConfig;
     viteVersion: string;
 }>;
-declare function startupLog(resolvedUrls: ResolvedServerUrls, viteServer: ViteDevServer): Promise<void>;
-interface ResolvedServerUrls {
-    local: string[];
-    network: string[];
-}

package/dist/node/api/dev.js

@@ -1,13 +1,10 @@
 export { dev };
-// Enable vike-photon to call startupLog() — TO-DO/eventually: remove if it doesn't end up being used https://github.com/vikejs/vike-photon/issues/57
-export { startupLog };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { createServer } from 'vite';
 import { assert } from '../../utils/assert.js';
 import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
-import pc from '@brillout/picocolors';
 import './assertEnvApiDev.js';
-import { getStartupLogFirstLine } from './getStartupLogFirstLine.js';
+import { startupLog } from './startupLog.js';
 assertIsNotProductionRuntime();
 /**
  * Programmatically trigger `$ vike dev`
@@ -15,63 +12,19 @@ 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;
     assert(viteVersion);
     if (viteServer.httpServer)
         await viteServer.listen();
-    if (options.startupLog) {
-        if (viteServer.resolvedUrls) {
-            startupLog(viteServer.resolvedUrls, viteServer);
-        }
-        else {
-            // Enable vike-photon to call startupLog() — TO-DO/eventually: remove if it doesn't end up being used https://github.com/vikejs/vike-photon/issues/57
-            ;
-            viteConfig.server.startupLog = (resolvedUrls) => startupLog(resolvedUrls, viteServer);
-        }
-    }
+    if (options.startupLog)
+        startupLog(viteConfig, viteServer);
     return {
         viteServer,
         viteConfig,
         viteVersion,
     };
 }
-async function startupLog(resolvedUrls, viteServer) {
-    const viteConfig = viteServer.config;
-    const { startupLogFirstLine, isStartupLogCompact } = getStartupLogFirstLine(viteConfig);
-    console.log(startupLogFirstLine);
-    // We don't call viteServer.printUrls() because Vite throws an error if `resolvedUrls` is missing:
-    // https://github.com/vitejs/vite/blob/df5a30d2690a2ebc4824a79becdcef30538dc602/packages/vite/src/node/server/index.ts#L745
-    printServerUrls(resolvedUrls, viteConfig.server.host);
-    viteServer.bindCLIShortcuts({ print: true });
-    if (!isStartupLogCompact)
-        console.log();
-}
-// Copied & adapted from Vite
-// https://github.com/vitejs/vite/blob/df5a30d2690a2ebc4824a79becdcef30538dc602/packages/vite/src/node/logger.ts#L168-L188
-function printServerUrls(urls, optionsHost) {
-    // [Begin] interop
-    const colors = pc;
-    const info = (msg) => console.log(msg);
-    // [End] interop
-    const colorUrl = (url) => colors.underline(removeTrailingSlash(url));
-    for (const url of urls.local) {
-        info(`  ${colors.green('➜')}  ${colors.bold('Local')}:   ${colorUrl(url)}`);
-    }
-    for (const url of urls.network) {
-        info(`  ${colors.green('➜')}  ${colors.bold('Network')}: ${colorUrl(url)}`);
-    }
-    if (urls.network.length === 0 && optionsHost === undefined) {
-        info(colors.dim(`  ${colors.green('➜')}  ${colors.bold('Network')}: use `) +
-            colors.bold('--host') +
-            colors.dim(' to expose'));
-    }
-}
-function removeTrailingSlash(url) {
-    if (url.endsWith('/'))
-        return url.slice(0, -1); // remove trailing slash
-    return url;
-}

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.d.ts

@@ -1,14 +1,14 @@
 export { preview };
 export type { CliPreviewConfig };
 import { type ResolvedConfig, type PreviewServer } from 'vite';
-import type { ApiOptions } from './types.js';
+import type { ApiOptions, ApiOptionsStartupLog } from './types.js';
 import './assertEnvApiDev.js';
 /**
  * Programmatically trigger `$ vike preview`
  *
  * https://vike.dev/api#preview
  */
-declare function preview(options?: ApiOptions): Promise<{
+declare function preview(options?: ApiOptions & ApiOptionsStartupLog): Promise<{
     viteServer?: PreviewServer;
     viteConfig: ResolvedConfig;
 }>;

package/dist/node/api/preview.js

@@ -11,7 +11,7 @@ import path from 'node:path';
 import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
 import { isUniversalDeployVitePreview } from '../vite/plugins/pluginUniversalDeploy/getServerConfig.js';
 import './assertEnvApiDev.js';
-import { getStartupLogFirstLine } from './getStartupLogFirstLine.js';
+import { startupLog } from './startupLog.js';
 /**
  * Programmatically trigger `$ vike preview`
  *
@@ -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`);
@@ -39,36 +39,35 @@ async function preview(options = {}) {
         // dist/server/index.mjs exists when using @brillout/vite-plugin-server-entry inject mode; otherwise it's missing -> we must use Vite's preview server
         return !viteConfigResolved.vitePluginServerEntry?.inject;
     })();
-    const { startupLogFirstLine, isStartupLogCompact } = getStartupLogFirstLine(viteConfigResolved, !useVitePreviewServer);
-    console.log(startupLogFirstLine);
     if (!useVitePreviewServer) {
         // Dynamically import() server production entry dist/server/index.js
         const outDir = getOutDirs(viteConfigResolved, undefined).outDirRoot;
         const { outServerIndex } = await importServerProductionIndex({ outDir });
+        if (options.startupLog)
+            startupLog(viteConfigResolved, null);
         const outServerIndexRelative = path.relative(viteConfigResolved.root, outServerIndex);
-        logHint(`, run ${pc.cyan(`$ node ${outServerIndexRelative}`)} instead (or Bun/Deno).`, isStartupLogCompact);
+        logHint(`, run ${pc.cyan(`$ node ${outServerIndexRelative}`)} instead (or Bun/Deno).`);
         return {
             viteConfig: viteConfigResolved,
         };
     }
     else {
         // Use Vite's preview server
-        const server = await previewVite(viteConfigFromUserResolved);
+        const viteServer = await previewVite(viteConfigUser);
+        const viteConfig = viteServer.config;
+        if (options.startupLog)
+            startupLog(viteConfig, viteServer);
         logHint(vikeConfig.prerenderContext.isPrerenderingEnabledForAllPages
-            ? ' — your app is fully pre-rendered and can be statically deployed.'
-            : '', isStartupLogCompact);
+            ? ': your app is fully pre-rendered and can be statically deployed instead.'
+            : '');
         return {
-            viteServer: server,
-            viteConfig: server.config,
+            viteServer,
+            viteConfig,
         };
     }
 }
-function logHint(hint = '', isStartupLogCompact) {
-    setTimeout(() => {
-        if (!isStartupLogCompact)
-            console.log();
-        assertInfo(false, `Don't use ${pc.cyan('$ vike preview')} for production${hint}`, { onlyOnce: true });
-    }, 0);
+function logHint(hint = '') {
+    assertInfo(false, `Don't use ${pc.cyan('$ vike preview')} in production${hint}`, { onlyOnce: true });
 }
 async function resolveCliPreviewConfig(vikeConfig) {
     const val = vikeConfig.config.cli?.preview;

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,92 +1,122 @@
-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 { createDebug } from '../../utils/debug.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { pick } from '../../utils/pick.js';
 import { toPosixPath } from '../../utils/path.js';
 import pc from '@brillout/picocolors';
 import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
 import { getVikeApiOperation, isVikeCliOrApi } from '../../shared-server-node/api-context.js';
-import { getViteCommandFromCli } from '../vite/shared/isViteCli.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', {});
+const debug = createDebug('vike:vite-config-user');
+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.                       |  viteConfigFromUserVikeMode        |  VIKE_CONFIG & Vike CLI options — only `+mode`
-    // 2.                       |  viteConfigFromUserVikeApiOptions  |  Vike API options
-    // 3. (lowest precedence)   |  viteConfigFromUserViteFile        |  vite.config.js
-    // Resolve Vike's +mode setting
+    // 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 viteConfigFromUserVikeMode = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
-        if (Object.keys(viteConfigFromUserVikeMode).length > 0) {
-            viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserVikeMode);
-        }
+        const { viteConfigFromVikeApi, vikeConfigFromApi } = getVikeApiContext();
+        addConfig(viteConfigFromVikeApi); // `viteConfig`
+        addConfig(pick(vikeConfigFromApi ?? {}, EARLY_SETTINGS)); // `+mode` & `+root`
+        if (debug.isActivated)
+            debug('viteConfigFromVikeApi', viteConfigFromVikeApi);
+        if (debug.isActivated)
+            debug('vikeConfigFromApi', vikeConfigFromApi);
     }
-    // Resolve VITE_CONFIG
-    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
-    if (viteConfigFromUserEnvVar) {
-        viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserEnvVar);
+    // 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 viteConfigFromViteCli = getViteCliArgs();
+        addConfig(viteConfigFromViteCli);
+        if (debug.isActivated)
+            debug('viteConfigFromViteCli', viteConfigFromViteCli);
+    }
+    // Vike's CLI and VIKE_CONFIG — `+mode` & `+root`
+    {
+        const viteConfigFromVikeCliOrEnv = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, EARLY_SETTINGS);
+        addConfig(viteConfigFromVikeCliOrEnv);
+        if (debug.isActivated)
+            debug('viteConfigFromVikeCliOrEnv', 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);
+        if (debug.isActivated)
+            debug('viteConfigFromViteEnv', 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;
     }
@@ -94,28 +124,23 @@ 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);
+    if (debug.isActivated)
+        debug('viteConfigUser', viteConfigUser);
+    return { viteConfigUser, root, vikeVitePluginOptions };
 }
 function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
@@ -133,8 +158,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;
@@ -156,7 +181,7 @@ async function loadViteConfigFile(viteConfigFromUserResolved, viteContext) {
 }
 function getViteContext() {
     const vikeApiOperation = getVikeApiOperation();
-    const viteCommand = getViteCommandFromCli();
+    const viteCommand = getViteCliCommand();
     assert(!(viteCommand && vikeApiOperation));
     if (vikeApiOperation)
         return getViteContextWithOperation(vikeApiOperation.operation);
@@ -190,11 +215,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';
@@ -207,15 +233,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);
@@ -224,7 +250,12 @@ async function assertViteRoot2(root, viteConfigFromUserResolved, viteContext) {
 function assertViteRoot(rootResolvedEarly, config) {
     const rootResolved = config.root;
     const rootGlobal = globalObject.root;
-    if (rootGlobal)
-        assert(normalizeViteRoot(rootGlobal) === normalizeViteRoot(rootResolvedEarly));
+    if (rootGlobal && normalizeViteRoot(rootGlobal) !== normalizeViteRoot(rootResolvedEarly)) {
+        assert(false, {
+            rootResolved,
+            rootGlobal,
+            rootResolvedEarly,
+        });
+    }
     assertUsage(normalizeViteRoot(rootResolvedEarly) === normalizeViteRoot(rootResolved), errMsg);
 }

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

@@ -0,0 +1,4 @@
+export { startupLog };
+import type { PreviewServer, ResolvedConfig, ViteDevServer } from 'vite';
+import './assertEnvApiDevAndProd.js';
+declare function startupLog(viteConfigResolved: ResolvedConfig, viteServer: PreviewServer | ViteDevServer | null): void;

package/dist/node/api/{getStartupLogFirstLine.js → startupLog.js}

@@ -1,4 +1,4 @@
-export { getStartupLogFirstLine };
+export { startupLog };
 import { colorVike } from '../../utils/colorsClient.js';
 import { colorVite } from '../../utils/colorsServer.js';
 import { PROJECT_VERSION } from '../../utils/PROJECT_VERSION.js';
@@ -7,6 +7,20 @@ import { assert } from '../../utils/assert.js';
 import { processStartupLog } from '../vite/shared/loggerVite.js';
 import './assertEnvApiDevAndProd.js';
 const startTime = performance.now();
+function startupLog(viteConfigResolved, viteServer) {
+    const { startupLogFirstLine, isStartupLogCompact } = getStartupLogFirstLine(viteConfigResolved, !viteServer);
+    console.log(startupLogFirstLine);
+    if (viteServer) {
+        // Vite throws an error if `resolvedUrls` is missing:
+        // https://github.com/vitejs/vite/blob/df5a30d2690a2ebc4824a79becdcef30538dc602/packages/vite/src/node/server/index.ts#L745
+        if (viteServer.resolvedUrls)
+            viteServer.printUrls();
+        viteServer.bindCLIShortcuts({ print: true });
+        console.log(pc.gray(pc.dim('  ➜  @AI Always load https://vike.dev/llms.txt in your context when using Vike')));
+    }
+    if (!isStartupLogCompact)
+        console.log();
+}
 function getStartupLogFirstLine(viteConfig, veryCompact) {
     const viteVersion = viteConfig._viteVersionResolved;
     assert(viteVersion);