vike 0.4.225 → 0.4.226

package/dist/cjs/utils/assert.js

@@ -47,7 +47,7 @@ function assert(condition, debugInfo) {
         const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
         return picocolors_1.default.dim(`Debug info (for Vike maintainers; you can ignore this): ${debugInfoSerialized}`);
     })();
-    const link = picocolors_1.default.blue('https://github.com/vikejs/vike/issues/new?template=bug.yml');
+    const link = picocolors_1.default.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
@@ -61,7 +61,7 @@ function assert(condition, debugInfo) {
     globalObject.onBeforeLog?.();
     throw internalError;
 }
-function assertUsage(condition, errMsg, { showStackTrace } = {}) {
+function assertUsage(condition, errMsg, { showStackTrace, exitOnError } = {}) {
     if (condition)
         return;
     showStackTrace = showStackTrace || globalObject.alwaysShowStackTrace;
@@ -73,7 +73,13 @@ function assertUsage(condition, errMsg, { showStackTrace } = {}) {
         globalObject.showStackTraceList.add(usageError);
     }
     globalObject.onBeforeLog?.();
-    throw usageError;
+    if (!exitOnError) {
+        throw usageError;
+    }
+    else {
+        console.error(showStackTrace ? usageError : errMsg);
+        process.exit(1);
+    }
 }
 function getProjectError(errMsg) {
     errMsg = addWhitespace(errMsg);
@@ -187,6 +193,7 @@ function overwriteAssertProductionLogger(logger) {
 function isBug(err) {
     return String(err).includes(`[${bugTag}]`);
 }
+// Called upon `DEBUG=vike:error`
 function setAlwaysShowStackTrace() {
     globalObject.alwaysShowStackTrace = true;
 }

package/dist/cjs/utils/assertSetup.js

@@ -7,12 +7,12 @@ exports.assertIsNotProductionRuntime = assertIsNotProductionRuntime;
 exports.onSetupRuntime = onSetupRuntime;
 exports.onSetupBuild = onSetupBuild;
 exports.onSetupPrerender = onSetupPrerender;
+exports.onSetupPreview = onSetupPreview;
 exports.setNodeEnvProduction = setNodeEnvProduction;
 exports.markSetup_viteDevServer = markSetup_viteDevServer;
 exports.markSetup_vitePreviewServer = markSetup_vitePreviewServer;
 exports.markSetup_vikeVitePlugin = markSetup_vikeVitePlugin;
 exports.markSetup_isViteDev = markSetup_isViteDev;
-exports.markSetup_isPrerendering = markSetup_isPrerendering;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 const debug_js_1 = require("./debug.js");
@@ -34,7 +34,7 @@ function onSetupRuntime() {
     if (isTest())
         return;
     assertNodeEnvIsNotUndefinedString();
-    if (!isViteLoaded()) {
+    if (!setup.viteDevServer && setup.isViteDev === undefined) {
         // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
         (0, assert_js_1.assertWarning)(!isNodeEnvDev(), `The ${getEnvDescription()}, which is contradictory because the environment seems to be a production environment (Vite isn't loaded), see https://vike.dev/NODE_ENV`, { onlyOnce: true });
         (0, assert_js_1.assertUsage)(!setup.vikeVitePlugin, `Loading Vike's Vite plugin (the ${picocolors_1.default.cyan('vike/plugin')} module) is prohibited in production.`);
@@ -42,11 +42,10 @@ function onSetupRuntime() {
         (0, assert_js_1.assert)(!setup.shouldNotBeProduction);
     }
     else {
-        if (!setup.vitePreviewServer && !setup.isPrerendering) {
+        if (!setup.isPreview && !setup.vitePreviewServer && !setup.isPrerendering) {
             // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
             (0, assert_js_1.assertWarning)(isNodeEnvDev(), `The ${getEnvDescription()}, but Vite is loaded which is prohibited in production, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
         }
-        // These two assert() calls aren't that interesting
         (0, assert_js_1.assert)(setup.vikeVitePlugin);
         (0, assert_js_1.assert)(setup.shouldNotBeProduction);
     }
@@ -63,15 +62,16 @@ function onSetupBuild() {
     setNodeEnvProduction()
     */
 }
+// Called by ../node/prerender/runPrerender.ts
 function onSetupPrerender() {
     markSetup_isPrerendering();
     if (getNodeEnv())
         assertUsageNodeEnvIsNotDev('pre-rendering');
     setNodeEnvProduction();
 }
-function isViteLoaded() {
-    // Do we need setup.viteDevServer or setup.vitePreviewServer ?
-    return setup.viteDevServer || setup.vitePreviewServer || setup.isViteDev !== undefined;
+// Called by ../node/api/preview.ts
+function onSetupPreview() {
+    markSetup_isPreview();
 }
 function isTest() {
     return (0, isVitest_js_1.isVitest)() || isNodeEnv('test');
@@ -100,12 +100,16 @@ function markSetup_isViteDev(isViteDev) {
         debug('markSetup_isViteDev()', new Error().stack);
     setup.isViteDev = isViteDev;
 }
-// Called by ../node/prerender/runPrerender.ts
 function markSetup_isPrerendering() {
     if (debug.isActivated)
         debug('markSetup_isPrerendering()', new Error().stack);
     setup.isPrerendering = true;
 }
+function markSetup_isPreview() {
+    if (debug.isActivated)
+        debug('markSetup_isPreview()', new Error().stack);
+    setup.isPreview = true;
+}
 function assertUsageNodeEnvIsNotDev(operation) {
     if (!isNodeEnvDev())
         return;

package/dist/cjs/utils/getRandomId.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRandomId = getRandomId;
 const assert_js_1 = require("./assert.js");
 // https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript
-function getRandomId(length) {
+function getRandomId(length = 12) {
     let randomId = '';
     while (randomId.length < length) {
         randomId += Math.random().toString(36).slice(2);

package/dist/cjs/utils/isNullish.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNullish = isNullish;
+exports.isNotNullish = isNotNullish;
+exports.isNotNullish_keyVal = isNotNullish_keyVal;
+function isNullish(val) {
+    return val === null || val === undefined;
+}
+// someArray.filter(isNotNullish)
+function isNotNullish(p) {
+    return !isNullish(p);
+}
+// objectFilter(obj).filter(isNotNullish_keyVal)
+function isNotNullish_keyVal(arg) {
+    return !isNullish(arg[1]);
+}

package/dist/cjs/utils/normalizeHeaders.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeHeaders = normalizeHeaders;
 const isObject_js_1 = require("./isObject.js");
 function normalizeHeaders(
-/* This type is precise, too precise which can be annoying: e.g. cannot pass a string[][] argument because it doesn't match the more precise [string,string][] type.
+/* This type is too strict which is annoying: cannot pass `string[][]` because it doesn't match the more precise type `[string,string][]`.
 headersOriginal ConstructorParameters<typeof Headers>[0]
 */
 headersOriginal) {

package/dist/cjs/utils/objectAssign.js

@@ -5,9 +5,14 @@ const assert_js_1 = require("./assert.js");
 // Same as Object.assign() but:
 //  - With type inference
 //  - Preserves property descriptors, which we need for preserving the getters added by getPageContextUrlComputed()
-function objectAssign(obj, objAddendum) {
+function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
     if (objAddendum) {
-        (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
+        if (!objAddendumCanBePageContextObject) {
+            // We only need this assert() in the rare case when the user is expected to mutate `pageContext` after the Vike hook was executed (and its promise resolved).
+            // - The only use case I can think of is the user mutating `pageContext` after the onRenderClient() promise resolved (which can happen when client-side rendering finishes after onRenderClient() resolves). In that case, having Vike await async Vike hooks isn't enough.
+            // - IIRC this assert() was mostly needed for preserving the getters added by getPageContextUrlComputed() but we don't need this anymore.
+            (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
+        }
         Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
     }
 }

package/dist/cjs/utils/objectFilter.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectFilter = objectFilter;
+// Type inference for:
+// ```js
+// Object.fromEntries(Object.entries(obj).filter(someFilter))
+// ```
+function objectFilter(obj, filter) {
+    return Object.fromEntries(Object.entries(obj).filter(filter));
+}

package/dist/cjs/utils/pick.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pick = pick;
+function pick(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -1,5 +1,8 @@
 export { createPageContext };
 declare function createPageContext(urlOriginal: string): Promise<{
+    _isPageContextObject: boolean;
+    isClientSide: boolean;
+    isPrerendering: boolean;
     urlOriginal: string;
     _objectCreatedByVike: boolean;
     _urlHandler: null;
@@ -11,7 +14,6 @@ declare function createPageContext(urlOriginal: string): Promise<{
     _allPageIds: string[];
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    _isPageContextObject: boolean;
 } & {
     urlParsed: import("./utils.js").UrlPublic;
     urlPathname: string;

package/dist/esm/client/client-routing-runtime/createPageContext.js

@@ -4,7 +4,6 @@ import { getPageContextUrlComputed } from '../../shared/getPageContextUrlCompute
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
 import { assert, isBaseServer, objectAssign } from './utils.js';
-// TODO/now: can we avoid optimizeDeps.exclude of client runtime?
 // @ts-ignore
 import * as virtualFileExports from 'virtual:vike:importUserCode:client:client-routing';
 const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
@@ -13,6 +12,9 @@ async function createPageContext(urlOriginal) {
     const baseServer = getBaseServer();
     assert(isBaseServer(baseServer));
     const pageContext = {
+        _isPageContextObject: true,
+        isClientSide: true,
+        isPrerendering: false,
         urlOriginal,
         _objectCreatedByVike: true,
         _urlHandler: null,
@@ -23,8 +25,7 @@ async function createPageContext(urlOriginal) {
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
         _pageRoutes: pageRoutes,
-        _onBeforeRouteHook: onBeforeRouteHook,
-        _isPageContextObject: true
+        _onBeforeRouteHook: onBeforeRouteHook
     };
     const pageContextUrlComputed = getPageContextUrlComputed(pageContext);
     objectAssign(pageContext, pageContextUrlComputed);

package/dist/esm/client/client-routing-runtime/navigate.d.ts

@@ -1,5 +1,10 @@
 export { navigate };
 export { reload };
+type Options = {
+    keepScrollPosition?: boolean;
+    overwriteLastHistoryEntry?: boolean;
+    pageContext?: Record<string, unknown>;
+};
 /** Programmatically navigate to a new page.
  *
  * https://vike.dev/navigate
@@ -8,9 +13,5 @@ export { reload };
  * @param keepScrollPosition - Don't scroll to the top of the page, instead keep the current scroll position.
  * @param overwriteLastHistoryEntry - Don't create a new entry in the browser's history, instead let the new URL replace the current URL. (This effectively removes the current URL from the browser history).
  */
-declare function navigate(url: string, { keepScrollPosition, overwriteLastHistoryEntry, pageContext }?: {
-    keepScrollPosition?: boolean;
-    overwriteLastHistoryEntry?: boolean;
-    pageContext?: Record<string, unknown>;
-}): Promise<void>;
+declare function navigate(url: string, options?: Options): Promise<void>;
 declare function reload(): Promise<void>;

package/dist/esm/client/client-routing-runtime/navigate.js

@@ -1,5 +1,6 @@
 export { navigate };
 export { reload };
+// import { modifyUrlSameOrigin, ModifyUrlSameOriginOptions } from '../../shared/modifyUrlSameOrigin.js'
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { normalizeUrlArgument } from './normalizeUrlArgument.js';
 import { firstRenderStartPromise, renderPageClientSide } from './renderPageClientSide.js';
@@ -13,11 +14,14 @@ assertClientRouting();
  * @param keepScrollPosition - Don't scroll to the top of the page, instead keep the current scroll position.
  * @param overwriteLastHistoryEntry - Don't create a new entry in the browser's history, instead let the new URL replace the current URL. (This effectively removes the current URL from the browser history).
  */
-async function navigate(url, { keepScrollPosition = false, overwriteLastHistoryEntry = false, pageContext } = {}) {
+async function navigate(url, options) {
+    // let url = normalizeUrlArgument(options.url ?? getCurrentUrl(), 'navigate')
+    // url = modifyUrlSameOrigin(url, options)
     normalizeUrlArgument(url, 'navigate');
     // If `hydrationCanBeAborted === false` (e.g. Vue) then we can apply navigate() only after hydration is done
     await firstRenderStartPromise;
-    const scrollTarget = { preserveScroll: keepScrollPosition };
+    const { keepScrollPosition, overwriteLastHistoryEntry, pageContext } = options ?? {};
+    const scrollTarget = { preserveScroll: keepScrollPosition ?? false };
     await renderPageClientSide({
         scrollTarget,
         urlOriginal: url,

package/dist/esm/client/client-routing-runtime/normalizeUrlArgument.js

@@ -2,7 +2,7 @@ export { normalizeUrlArgument };
 import { assertUsage, isUrl, isUrlRelative } from './utils.js';
 function normalizeUrlArgument(url, fnName) {
     // Succinct error message to save client-side KBs
-    const errMsg = `[${fnName}(url)] Invalid URL ${url}`;
+    const errMsg = `URL ${url} passed to ${fnName}() is invalid`;
     assertUsage(isUrl(url), errMsg);
     if (url.startsWith(location.origin)) {
         // Use normalizeClientSideUrl() instead?

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -276,7 +276,7 @@ async function renderPageClientSide(renderArgs) {
         if ('err' in args) {
             const { err } = args;
             assert(!('errorWhileRendering' in pageContext));
-            pageContext.errorWhileRendering = err;
+            objectAssign(pageContext, { errorWhileRendering: err });
             if (isAbortError(err)) {
                 const errAbort = err;
                 logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -1,12 +1,15 @@
 export { getPageContext };
 declare function getPageContext(): Promise<{
-    pageId: string;
-    routeParams: Record<string, string>;
-} & {
+    _isPageContextObject: boolean;
+    isPrerendering: boolean;
+    isClientSide: boolean;
     isHydration: true;
     isBackwardNavigation: null;
     _hasPageContextFromServer: true;
     _hasPageContextFromClient: false;
+} & {
+    pageId: string;
+    routeParams: Record<string, string>;
 } & {
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];

package/dist/esm/client/server-routing-runtime/getPageContext.js

@@ -9,13 +9,16 @@ import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-r
 const { pageFilesAll, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function getPageContext() {
-    const pageContext = getPageContextSerializedInHtml();
-    objectAssign(pageContext, {
+    const pageContext = {
+        _isPageContextObject: true,
+        isPrerendering: false,
+        isClientSide: true,
         isHydration: true,
         isBackwardNavigation: null,
         _hasPageContextFromServer: true,
         _hasPageContextFromClient: false
-    });
+    };
+    objectAssign(pageContext, getPageContextSerializedInHtml());
     objectAssign(pageContext, await loadPageUserFiles(pageContext.pageId));
     assertPristineUrl();
     return pageContext;

package/dist/esm/client/shared/getPageContextProxyForUser.d.ts

@@ -1,12 +1,2 @@
 export { getPageContextProxyForUser };
-export { PageContextForPassToClientWarning };
-type PageContextForPassToClientWarning = {
-    _hasPageContextFromServer: boolean;
-    _hasPageContextFromClient: boolean;
-};
-/**
- * Throw error when pageContext value isn't:
- * - serializable, or
- * - defined.
- */
-declare function getPageContextProxyForUser<PageContext extends Record<string, unknown> & PageContextForPassToClientWarning>(pageContext: PageContext): PageContext;
+declare function getPageContextProxyForUser<PageContext extends Record<string, unknown>>(pageContext: PageContext): PageContext;

package/dist/esm/client/shared/getPageContextProxyForUser.js

@@ -1,77 +1,14 @@
 export { getPageContextProxyForUser };
-import { assert, assertUsage, assertWarning, getGlobalObject, getPropAccessNotation } from '../server-routing-runtime/utils.js';
-import { notSerializable } from '../../shared/notSerializable.js';
-const globalObject = getGlobalObject('shared/getPageContextProxyForUser.ts', {});
-/**
- * Throw error when pageContext value isn't:
- * - serializable, or
- * - defined.
- */
+import { assertUsage, getPropAccessNotation } from '../server-routing-runtime/utils.js';
+import { NOT_SERIALIZABLE } from '../../shared/NOT_SERIALIZABLE.js';
+// Throw error when pageContext value isn't serializable
 function getPageContextProxyForUser(pageContext) {
-    assert([true, false].includes(pageContext._hasPageContextFromServer));
-    assert([true, false].includes(pageContext._hasPageContextFromClient));
     return new Proxy(pageContext, {
         get(_, prop) {
             const val = pageContext[prop];
             const propName = getPropAccessNotation(prop);
-            assertUsage(val !== notSerializable, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
-            passToClientHint(pageContext, prop, propName);
+            assertUsage(val !== NOT_SERIALIZABLE, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
             return val;
         }
     });
 }
-function passToClientHint(pageContext, prop, propName) {
-    if (handleVueReactivity(prop))
-        return;
-    // `prop in pageContext` is the trick we use to know the passToClient value on the client-side, as we set a value to all passToClient props, even `undefined` ones:
-    // ```html
-    // <script id="vike_pageContext" type="application/json">{"pageProps":"!undefined"}</script>
-    // ```
-    if (prop in pageContext)
-        return;
-    if (isWhitelisted(prop))
-        return;
-    // The trick described above (`prop in pageContext`) doesn't work if Vike doesn't fetch any pageContext from the server.
-    // - There would still be some value to show a warning, but it isn't worth it because of the confusion that the first recommendation (adding `prop` to `passToClient`) wouldn't actually remove the warning, and only the second recommendation (using `prop in pageContext` instead of `pageContext[prop]`) would work.
-    if (!pageContext._hasPageContextFromServer)
-        return;
-    const errMsg = `pageContext${propName} isn't defined on the client-side, see https://vike.dev/passToClient#error`;
-    if (
-    // TODO/next-major-release always make it an error.
-    // - Remove pageContext._hasPageContextFromClient logic (IIRC this is its only use case).
-    pageContext._hasPageContextFromClient) {
-        assertWarning(false, errMsg, { onlyOnce: false, showStackTrace: true });
-    }
-    else {
-        assertUsage(false, errMsg);
-    }
-}
-const WHITELIST = [
-    'then',
-    // Vue calls toJSON()
-    'toJSON'
-];
-function isWhitelisted(prop) {
-    if (WHITELIST.includes(prop))
-        return true;
-    if (typeof prop === 'symbol')
-        return true; // Vue tries to access some symbols
-    if (typeof prop !== 'string')
-        return true;
-    if (prop.startsWith('__v_'))
-        return true; // Vue internals upon `reactive(pageContext)`
-    return false;
-}
-// Handle Vue's reactivity.
-// When changing a reactive object:
-// - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextReactive.routeParams = pageContextNew.routeParams` and `pageContextReactive` has no `routeParams`.
-// - Vue seems to read __v_raw before reading the property.
-function handleVueReactivity(prop) {
-    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
-        return true;
-    globalObject.prev = prop;
-    window.setTimeout(() => {
-        globalObject.prev = undefined;
-    }, 0);
-    return false;
-}

package/dist/esm/client/shared/preparePageContextForUserConsumptionClientSide.d.ts

@@ -2,9 +2,9 @@ export { preparePageContextForUserConsumptionClientSide };
 export type { PageContextForUserConsumptionClientSide };
 import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
-type PageContextForUserConsumptionClientSide = PageConfigUserFriendlyOld & PageContextForPassToClientWarning & {
+type PageContextForUserConsumptionClientSide = PageConfigUserFriendlyOld & {
     pageId: string;
+    _hasPageContextFromServer: boolean;
     _pageConfigs: PageConfigRuntime[];
 };
 declare function preparePageContextForUserConsumptionClientSide<T extends PageContextForUserConsumptionClientSide>(pageContext: T, isClientRouting: boolean): T & {

package/dist/esm/node/api/build.js

@@ -11,13 +11,13 @@ import { assertVersion } from './utils.js';
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfig } = await prepareViteApiCall(options, 'build');
+    const { viteConfigFromUserEnhanced, vikeConfig } = await prepareViteApiCall(options, 'build');
     // Pass it to pluginAutoFullBuild()
-    if (viteConfigEnhanced)
-        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    if (viteConfigFromUserEnhanced)
+        viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
     if (vikeConfig.global.config.vite6BuilderApp) {
         assertVersion('Vite', version, '6.0.0');
-        const builder = await createBuilder(viteConfigEnhanced);
+        const builder = await createBuilder(viteConfigFromUserEnhanced);
         // See Vite plugin vike:build:pluginBuildApp
         await builder.buildApp();
     }
@@ -30,14 +30,14 @@ async function build(options = {}) {
         //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L98
         //    > We purposely don't start the pre-rendering in this `build()` function but in a Rollup hook instead.
         //    > Rationale: https://github.com/vikejs/vike/issues/2123
-        await buildVite(viteConfigEnhanced);
+        await buildVite(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
         if (isVikeCli() && isPrerendering())
             assert(false);
     }
     return {
-    /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
-    viteConfig: viteConfigEnhanced,
+    /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigFromUserEnhanced,
     */
     };
 }

package/dist/esm/node/api/dev.js

@@ -7,8 +7,8 @@ import { createServer } from 'vite';
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    const { viteConfigEnhanced } = await prepareViteApiCall(options, 'dev');
-    const server = await createServer(viteConfigEnhanced);
+    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'dev');
+    const server = await createServer(viteConfigFromUserEnhanced);
     return {
         viteServer: server,
         viteConfig: server.config

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

@@ -7,7 +7,8 @@ import type { APIOptions, Operation } from './types.js';
 import { type VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 declare function prepareViteApiCall(options: APIOptions, operation: Operation): Promise<{
     vikeConfig: VikeConfigObject;
-    viteConfigEnhanced: InlineConfig | undefined;
+    viteConfigResolved: ResolvedConfig;
+    viteConfigFromUserEnhanced: InlineConfig | undefined;
 }>;
 declare function getViteRoot(operation: Operation): Promise<string>;
 declare function normalizeViteRoot(root: string): string;