vike 0.4.241 → 0.4.242

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

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

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 { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'dev');
-    const server = await createServer(viteConfigFromUserEnhanced);
+    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'dev');
+    const server = await createServer(viteConfigFromUserResolved);
     return {
         viteServer: server,
         viteConfig: server.config,

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

@@ -1,13 +1,6 @@
 export { prepareViteApiCall };
-export { getViteRoot };
-export { assertViteRoot };
-export { normalizeViteRoot };
-import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { ApiOptions, ApiOperation } from './types.js';
 declare function prepareViteApiCall(options: ApiOptions, operation: ApiOperation): Promise<{
-    viteConfigResolved: ResolvedConfig;
-    viteConfigFromUserEnhanced: InlineConfig | undefined;
+    viteConfigResolved: import("vite").ResolvedConfig;
+    viteConfigFromUserResolved: import("vite").InlineConfig | undefined;
 }>;
-declare function getViteRoot(operation: ApiOperation): Promise<string>;
-declare function normalizeViteRoot(root: string): string;
-declare function assertViteRoot(root: string, config: ResolvedConfig): void;

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

@@ -1,168 +1,16 @@
 export { prepareViteApiCall };
-export { getViteRoot };
-export { assertViteRoot };
-export { normalizeViteRoot };
-import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
 import { clearContextVikeApiOperation, setContextVikeApiOperation } from './context.js';
-import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, } from '../vite/shared/resolveVikeConfigInternal.js';
-import path from 'node:path';
-import { assert, assertUsage, getGlobalObject, isObject, pick, toPosixPath } from './utils.js';
-import pc from '@brillout/picocolors';
 import { clearGlobalContext } from '../runtime/globalContext.js';
-import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
-const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
+import { getViteContextWithOperation, resolveViteConfigFromUser } from './resolveViteConfigFromUser.js';
 async function prepareViteApiCall(options, operation) {
     clear();
     setContextVikeApiOperation(operation, options);
-    const viteConfigFromUserApiOptions = options.viteConfig;
-    return resolveConfigs(viteConfigFromUserApiOptions, operation);
+    const viteConfigFromUserVikeApiOptions = options.viteConfig;
+    const viteContext = getViteContextWithOperation(operation);
+    return resolveViteConfigFromUser(viteConfigFromUserVikeApiOptions, viteContext);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
     clearContextVikeApiOperation();
     clearGlobalContext();
 }
-async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
-    const viteInfo = await getViteInfo(viteConfigFromUserApiOptions, operation);
-    setVikeConfigContext({
-        userRootDir: viteInfo.root,
-        isDev: operation === 'dev',
-        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
-    });
-    const vikeConfig = await getVikeConfigInternal();
-    const viteConfigFromUserEnhanced = applyVikeViteConfig(viteInfo.viteConfigFromUserEnhanced, vikeConfig);
-    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserEnhanced, operation);
-    return {
-        viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
-        viteConfigFromUserEnhanced,
-    };
-}
-// Apply +vite
-// - For example, Vike extensions adding Vite plugins
-function applyVikeViteConfig(viteConfigFromUserEnhanced, vikeConfig) {
-    const viteConfigs = vikeConfig._from.configsCumulative.vite;
-    if (!viteConfigs)
-        return viteConfigFromUserEnhanced;
-    viteConfigs.values.forEach((v) => {
-        assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
-        viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, v.value);
-        assertUsage(!findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
-    });
-    return viteConfigFromUserEnhanced;
-}
-async function getViteRoot(operation) {
-    if (!globalObject.root)
-        await getViteInfo(undefined, operation);
-    assert(globalObject.root);
-    return globalObject.root;
-}
-async function getViteInfo(viteConfigFromUserApiOptions, operation) {
-    let viteConfigFromUserEnhanced = viteConfigFromUserApiOptions;
-    // Precedence:
-    //  1) viteConfigFromUserEnvVar (highest precedence)
-    //  2) viteConfigFromUserVikeConfig
-    //  2) viteConfigFromUserApiOptions
-    //  3) viteConfigFromUserViteFile (lowest precedence)
-    // Resolve Vike's +mode setting
-    {
-        const viteConfigFromUserVikeConfig = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
-        if (Object.keys(viteConfigFromUserVikeConfig).length > 0) {
-            viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserVikeConfig);
-        }
-    }
-    // Resolve VITE_CONFIG
-    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
-    if (viteConfigFromUserEnvVar) {
-        viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserEnvVar);
-    }
-    // Resolve vite.config.js
-    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromUserEnhanced, operation);
-    // Correct precedence, replicates Vite:
-    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
-    const viteConfigResolved = mergeConfig(viteConfigFromUserViteFile ?? {}, viteConfigFromUserEnhanced ?? {});
-    const root = normalizeViteRoot(viteConfigResolved.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);
-    if (found) {
-        vikeVitePluginOptions = found.vikeVitePluginOptions;
-    }
-    else {
-        // 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');
-        viteConfigFromUserEnhanced = {
-            ...viteConfigFromUserEnhanced,
-            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()],
-        };
-        const res = findVikeVitePlugin(viteConfigFromUserEnhanced);
-        assert(res);
-        vikeVitePluginOptions = res.vikeVitePluginOptions;
-    }
-    assert(vikeVitePluginOptions);
-    return { root, vikeVitePluginOptions, viteConfigFromUserEnhanced };
-}
-function findVikeVitePlugin(viteConfig) {
-    let vikeVitePluginOptions;
-    let vikeVitePuginFound = false;
-    viteConfig?.plugins?.forEach((p) => {
-        if (p && '_vikeVitePluginOptions' in p) {
-            vikeVitePuginFound = true;
-            const options = p._vikeVitePluginOptions;
-            vikeVitePluginOptions ?? (vikeVitePluginOptions = {});
-            Object.assign(vikeVitePluginOptions, options);
-        }
-    });
-    if (!vikeVitePuginFound)
-        return null;
-    return { vikeVitePluginOptions };
-}
-// Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfigFromUserApiOptions, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromUserApiOptions, operation);
-    let config = inlineConfig;
-    let mode = inlineConfig.mode || defaultMode;
-    const configEnv = {
-        mode,
-        command,
-        isSsrBuild: command === 'build' && !!config.build?.ssr,
-        isPreview,
-    };
-    let { configFile } = config;
-    if (configFile !== false) {
-        const loadResult = await loadConfigFromFile(configEnv, configFile, config.root, config.logLevel, config.customLogger);
-        return loadResult?.config;
-    }
-    return null;
-}
-function getResolveConfigArgs(viteConfig = {}, operation) {
-    const inlineConfig = viteConfig;
-    const command = operation === 'build' || operation === 'prerender' ? 'build' : 'serve';
-    const defaultMode = operation === 'dev' ? 'development' : 'production';
-    const defaultNodeEnv = defaultMode;
-    const isPreview = operation === 'preview';
-    return [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
-}
-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:
-    // 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 Vite's setting ${pc.cyan('root')} which is forbidden`;
-async function assertViteRoot2(root, viteConfigFromUserEnhanced, operation) {
-    const args = getResolveConfigArgs(viteConfigFromUserEnhanced, operation);
-    // 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(...args);
-    assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
-    return { viteConfigResolved };
-}
-function assertViteRoot(root, config) {
-    if (globalObject.root)
-        assert(normalizeViteRoot(globalObject.root) === normalizeViteRoot(root));
-    assertUsage(normalizeViteRoot(root) === normalizeViteRoot(config.root), errMsg);
-}

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

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

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

@@ -13,7 +13,7 @@ import path from 'node:path';
  */
 async function preview(options = {}) {
     onSetupPreview();
-    const { viteConfigFromUserEnhanced, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
+    const { viteConfigFromUserResolved, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
     if (viteConfigResolved.vitePluginServerEntry?.inject) {
         const outDir = getOutDirs(viteConfigResolved, undefined).outDirRoot;
         const { outServerIndex } = await importServerProductionIndex({ outDir });
@@ -24,7 +24,7 @@ async function preview(options = {}) {
         };
     }
     else {
-        const server = await previewVite(viteConfigFromUserEnhanced);
+        const server = await previewVite(viteConfigFromUserResolved);
         return {
             viteServer: server,
             viteConfig: server.config,

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

@@ -0,0 +1,20 @@
+export { resolveViteConfigFromUser };
+export { isOnlyResolvingUserConfig };
+export { getVikeConfigInternalEarly };
+export { getViteContextWithOperation };
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+import type { InlineConfig, ResolvedConfig } from 'vite';
+import type { ApiOperation } from './types.js';
+declare function resolveViteConfigFromUser(viteConfigFromUserVikeApiOptions: InlineConfig | undefined, viteContext: ViteContext): Promise<{
+    viteConfigResolved: ResolvedConfig;
+    viteConfigFromUserResolved: InlineConfig | undefined;
+}>;
+declare function getVikeConfigInternalEarly(): Promise<import("../vite/shared/resolveVikeConfigInternal.js").VikeConfigInternal>;
+declare function isOnlyResolvingUserConfig(): boolean | undefined;
+declare function getViteRoot(viteContext: ViteContext): Promise<string>;
+type ViteContext = 'build' | 'preview' | 'dev';
+declare function getViteContextWithOperation(operation: ApiOperation): ViteContext;
+declare function normalizeViteRoot(root: string): string;
+declare function assertViteRoot(root: string, config: ResolvedConfig): void;

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

@@ -0,0 +1,207 @@
+export { resolveViteConfigFromUser };
+export { isOnlyResolvingUserConfig };
+export { getVikeConfigInternalEarly };
+export { getViteContextWithOperation };
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
+import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, isVikeConfigContextSet, } from '../vite/shared/resolveVikeConfigInternal.js';
+import path from 'node:path';
+import { assert, assertUsage, assertWarning, getGlobalObject, pick, toPosixPath } from './utils.js';
+import pc from '@brillout/picocolors';
+import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
+import { getVikeApiOperation, isVikeCliOrApi } from './context.js';
+import { getViteCommandFromCli } from '../vite/shared/isViteCli.js';
+const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
+async function resolveViteConfigFromUser(viteConfigFromUserVikeApiOptions, viteContext) {
+    const viteInfo = await getViteInfo(viteConfigFromUserVikeApiOptions, viteContext);
+    setVikeConfigContext_(viteInfo, viteContext);
+    const { viteConfigFromUserResolved } = viteInfo;
+    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserResolved, viteContext);
+    return {
+        viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
+        viteConfigFromUserResolved,
+    };
+}
+async function getVikeConfigInternalEarly() {
+    assert(!globalObject.isOnlyResolvingUserConfig); // ensure no infinite loop
+    if (!isVikeConfigContextSet()) {
+        const viteContext = getViteContext();
+        const viteInfo = await getViteInfo(undefined, viteContext);
+        setVikeConfigContext_(viteInfo, viteContext);
+    }
+    return await getVikeConfigInternal();
+}
+function setVikeConfigContext_(viteInfo, viteContext) {
+    setVikeConfigContext({
+        userRootDir: viteInfo.root,
+        isDev: viteContext === 'dev',
+        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
+    });
+}
+function isOnlyResolvingUserConfig() {
+    return globalObject.isOnlyResolvingUserConfig;
+}
+async function getViteRoot(viteContext) {
+    if (!globalObject.root)
+        await getViteInfo(undefined, viteContext);
+    assert(globalObject.root);
+    return globalObject.root;
+}
+async function getViteInfo(viteConfigFromUserVikeApiOptions, viteContext) {
+    let viteConfigFromUserResolved = viteConfigFromUserVikeApiOptions;
+    // Precedence:
+    //  1) viteConfigFromUserEnvVar (highest precedence)
+    //  2) viteConfigFromUserVikeConfig
+    //  2) viteConfigFromUserVikeApiOptions
+    //  3) viteConfigFromUserViteFile (lowest precedence)
+    // Resolve Vike's +mode setting
+    {
+        const viteConfigFromUserVikeConfig = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
+        if (Object.keys(viteConfigFromUserVikeConfig).length > 0) {
+            viteConfigFromUserResolved = mergeConfig(viteConfigFromUserResolved ?? {}, viteConfigFromUserVikeConfig);
+        }
+    }
+    // Resolve VITE_CONFIG
+    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
+    if (viteConfigFromUserEnvVar) {
+        viteConfigFromUserResolved = mergeConfig(viteConfigFromUserResolved ?? {}, viteConfigFromUserEnvVar);
+    }
+    // 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 = mergeConfig(viteConfigFromUserViteConfigFile ?? {}, viteConfigFromUserResolved ?? {});
+    const root = normalizeViteRoot(viteConfigResolved.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);
+    if (found) {
+        vikeVitePluginOptions = found.vikeVitePluginOptions;
+    }
+    else {
+        // 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
+        "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()],
+        };
+        const res = findVikeVitePlugin(viteConfigFromUserResolved);
+        assert(res);
+        vikeVitePluginOptions = res.vikeVitePluginOptions;
+    }
+    assert(vikeVitePluginOptions);
+    return { root, vikeVitePluginOptions, viteConfigFromUserResolved };
+}
+function findVikeVitePlugin(viteConfig) {
+    let vikeVitePluginOptions;
+    let vikeVitePuginFound = false;
+    viteConfig?.plugins?.forEach((p) => {
+        if (p && '_vikeVitePluginOptions' in p) {
+            vikeVitePuginFound = true;
+            const options = p._vikeVitePluginOptions;
+            vikeVitePluginOptions ?? (vikeVitePluginOptions = {});
+            Object.assign(vikeVitePluginOptions, options);
+        }
+    });
+    if (!vikeVitePuginFound)
+        return null;
+    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);
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = viteContextResolved;
+    let config = inlineConfig;
+    let mode = inlineConfig.mode || defaultMode;
+    const configEnv = {
+        mode,
+        command,
+        isSsrBuild: command === 'build' && !!config.build?.ssr,
+        isPreview,
+    };
+    let { configFile } = config;
+    if (configFile !== false) {
+        const loadResult = await loadConfigFromFile(configEnv, configFile, config.root, config.logLevel, config.customLogger);
+        if (!loadResult)
+            return null;
+        assert(loadResult.config);
+        return loadResult.config;
+    }
+    return null;
+}
+function getViteContext() {
+    const vikeApiOperation = getVikeApiOperation();
+    const viteCommand = getViteCommandFromCli();
+    assert(!(viteCommand && vikeApiOperation));
+    if (vikeApiOperation)
+        return getViteContextWithOperation(vikeApiOperation.operation);
+    assert(!isVikeCliOrApi());
+    if (viteCommand === 'dev' || viteCommand === 'optimize') {
+        return 'dev';
+    }
+    if (viteCommand === 'build') {
+        return 'build';
+    }
+    if (viteCommand === 'preview') {
+        return 'preview';
+    }
+    // Third-party CLIs.
+    // - Component development (e.g. Storybook) => let's consider it development
+    // - Testing (e.g. Vitest) => let's consider it development
+    return 'dev';
+}
+function getViteContextWithOperation(operation) {
+    if (operation === 'build' || operation === 'prerender') {
+        return 'build';
+    }
+    if (operation === 'preview') {
+        return 'preview';
+    }
+    if (operation === 'dev') {
+        return 'dev';
+    }
+    assert(false);
+}
+function resolveViteContext(inlineConfig = {}, viteContext) {
+    const isBuild = viteContext === 'build';
+    const isPreview = viteContext === 'preview';
+    const isDev = viteContext === 'dev';
+    const command = isBuild ? 'build' : 'serve';
+    const defaultMode = isDev ? 'development' : 'production';
+    const defaultNodeEnv = defaultMode;
+    const viteContextResolved = [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
+    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:
+    // 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 Vite's setting ${pc.cyan('root')} which is forbidden`;
+async function assertViteRoot2(root, viteConfigFromUserResolved, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, 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);
+    return { viteConfigResolved };
+}
+function assertViteRoot(root, config) {
+    if (globalObject.root)
+        assert(normalizeViteRoot(globalObject.root) === normalizeViteRoot(root));
+    assertUsage(normalizeViteRoot(root) === normalizeViteRoot(config.root), errMsg);
+}

package/dist/esm/node/prerender/runPrerenderEntry.js

@@ -6,7 +6,7 @@ import { assert } from './utils.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 import { isVikeCli } from '../cli/context.js';
-import { isViteCliCall } from '../vite/shared/isViteCliCall.js';
+import { isViteCli } from '../vite/shared/isViteCli.js';
 import { runPrerender } from './runPrerender.js';
 async function runPrerenderFromAPI(options = {}) {
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -16,8 +16,8 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigFromUserEnhanced } = await prepareViteApiCall({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
+        const { viteConfigFromUserResolved } = await prepareViteApiCall({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigFromUserResolved }, '$ vike prerender');
     }
     catch (err) {
         console.error(err);
@@ -38,7 +38,7 @@ async function runPrerenderFromAutoRun(viteConfig) {
         logErrorHint(err);
         process.exit(1);
     }
-    const forceExit = isVikeCli() || isViteCliCall();
+    const forceExit = isVikeCli() || isViteCli();
     return { forceExit };
 }
 function runPrerender_forceExit() {

package/dist/esm/node/runtime/logErrorServer.js

@@ -1,9 +1,16 @@
 export { logErrorServer };
 import pc from '@brillout/picocolors';
-import { isObject } from './utils.js';
+import { isCallable, isObject } from './utils.js';
 import { execHookOnError } from './renderPage/execHookOnError.js';
 function logErrorServer(err) {
     execHookOnError(err);
+    // Set by react-streaming
+    // - https://github.com/brillout/react-streaming/blob/0fb5510d0a5a614f577668a519bccd62de40aed8/src/server/renderToStream/common.ts#L59-L62
+    // - https://gist.github.com/brillout/066293a687ab7cf695e62ad867bc6a9c
+    // - It doesn't seem to be needed? (The error Vike receives is already enhanced.) Should we remove this?
+    if (isObject(err) && isCallable(err.getEnhancedError)) {
+        err = err.getEnhancedError(err);
+    }
     // We ensure we print a string; Cloudflare Workers doesn't seem to properly stringify `Error` objects.
     // - TO-DO/eventually: is that still true? Let's eventually remove it and see if it crashes Cloudflare.
     const errStr = isObject(err) && 'stack' in err ? String(err.stack) : String(err);

package/dist/esm/node/runtime-dev/createDevMiddleware.js

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

package/dist/esm/node/vite/index.d.ts

@@ -8,7 +8,7 @@ export type { VikeVitePluginOptions };
 type PluginInterop = Record<string, unknown> & {
     name: string;
 };
-declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): PluginInterop[];
+declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): Promise<PluginInterop[]>;
 /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
 type VikeVitePluginOptions = {
     /** @deprecated Define Vike settings in +config.js instead of vite.config.js */

package/dist/esm/node/vite/index.js

@@ -6,7 +6,7 @@ export { getVikeConfig } from './shared/resolveVikeConfigInternal.js';
 export { PROJECT_VERSION as version } from './utils.js';
 import { getClientEntrySrcDev } from './shared/getClientEntrySrcDev.js';
 import { setGetClientEntrySrcDev } from '../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
-import { assertIsNotProductionRuntime, assertUsage } from './utils.js';
+import { assertIsNotProductionRuntime, assertUsage, isVitest } from './utils.js';
 import pc from '@brillout/picocolors';
 import { pluginPreview } from './plugins/pluginPreview.js';
 import { pluginDev } from './plugins/pluginDev.js';
@@ -31,31 +31,40 @@ import { pluginProdBuildEntry } from './plugins/build/pluginProdBuildEntry.js';
 import { pluginBuildConfig } from './plugins/build/pluginBuildConfig.js';
 import { pluginModuleBanner } from './plugins/build/pluginModuleBanner.js';
 import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js';
+import { isVikeCliOrApi } from '../api/context.js';
+import { pluginViteConfigVikeExtensions } from './plugins/pluginViteConfigVikeExtensions.js';
+import { isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setGetClientEntrySrcDev(getClientEntrySrcDev);
 assertIsNotProductionRuntime();
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
 function plugin(vikeVitePluginOptions = {}) {
-    const plugins = [
-        ...pluginCommon(vikeVitePluginOptions),
-        ...pluginVirtualFiles(),
-        ...pluginDev(),
-        ...pluginBuild(),
-        ...pluginPreview(),
-        ...pluginExtractAssets(),
-        ...pluginExtractExportNames(),
-        ...pluginSetGlobalContext(),
-        ...pluginBaseUrls(),
-        ...pluginReplaceConstantsEnvVars(),
-        ...pluginFileEnv(),
-        ...pluginWorkaroundCssModuleHmr(),
-        ...pluginWorkaroundVite6HmrRegression(),
-        ...pluginReplaceConstantsPageContext(),
-        ...pluginReplaceConstantsGlobalThis(),
-        ...pluginNonRunnabeDev(),
-    ];
-    Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });
-    return plugins;
+    const promise = (async () => {
+        if (skip())
+            return [];
+        const plugins = [
+            ...pluginCommon(vikeVitePluginOptions),
+            ...pluginVirtualFiles(),
+            ...pluginDev(),
+            ...pluginBuild(),
+            ...pluginPreview(),
+            ...pluginExtractAssets(),
+            ...pluginExtractExportNames(),
+            ...pluginSetGlobalContext(),
+            ...pluginBaseUrls(),
+            ...pluginReplaceConstantsEnvVars(),
+            ...pluginFileEnv(),
+            ...pluginWorkaroundCssModuleHmr(),
+            ...pluginWorkaroundVite6HmrRegression(),
+            ...pluginReplaceConstantsPageContext(),
+            ...pluginReplaceConstantsGlobalThis(),
+            ...pluginNonRunnabeDev(),
+            ...(await pluginViteConfigVikeExtensions()),
+        ];
+        return plugins;
+    })();
+    Object.assign(promise, { _vikeVitePluginOptions: vikeVitePluginOptions });
+    return promise;
 }
 function pluginBuild() {
     return [
@@ -71,6 +80,28 @@ function pluginBuild() {
 function pluginNonRunnabeDev() {
     return [...pluginViteRPC(), ...pluginReplaceConstantsNonRunnableDev()];
 }
+function skip() {
+    // Early resolving of user Vite configs
+    if (isOnlyResolvingUserConfig()) {
+        return true;
+    }
+    // For Vitest, we only add Vike's Vite plugin if Vike's JavaScript API is used.
+    // - In the context of running unit tests with Vitest, Vike's Vite plugin doesn't add any value AFAICT.
+    // - If the user calls Vike's JavaScript API inside Vitest (e.g. `build()` inside `beforeAll()`)  => vite.config.js is loaded twice: once by Vitest and once by Vike => problematic because Vitest's environment is `development` whereas Vike's `build()` environment is `production` => the globalContext.ts isProd() function throws an assertion fail (I don't know why the two globalContext.ts instances aren't independent from each other) => that's why we skip Vike's Vite plugin when it's Vitest that loads vite.config.js
+    //   - When calling `$ vitest` Vitest loads vite.config.js if it lives at process.cwd()
+    // - The user is supposed to use Vike's API instead of Vite's API. Vike supports Vite's API only for third parties (e.g. Vitest or Storybook).
+    // - https://vike.dev/vitest
+    if (
+    /* Maybe also all third party tools such as Storybook?
+    !isViteCli() &&
+    /*/
+    isVitest() &&
+        ///*/
+        !isVikeCliOrApi()) {
+        return true;
+    }
+    return false;
+}
 // Error upon wrong usage
 Object.defineProperty(plugin, 'apply', {
     enumerable: true,

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

@@ -3,7 +3,7 @@ import { runPrerender_forceExit } from '../../../prerender/runPrerenderEntry.js'
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { assert, assertWarning, getGlobalObject, onSetupBuild } from '../../utils.js';
 import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
-import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
+import { isViteCli, getViteConfigForBuildFromCli } from '../../shared/isViteCli.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
@@ -142,7 +142,7 @@ async function triggerPrerendering(config, viteEnv, bundle) {
 }
 async function abortViteBuildSsr() {
     const vikeConfig = await getVikeConfigInternal();
-    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCli() && getViteConfigForBuildFromCli()?.build.ssr) {
         assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
         process.exit(0);
     }
@@ -150,7 +150,7 @@ async function abortViteBuildSsr() {
 function isDisabled(vikeConfig) {
     const { disableAutoFullBuild } = vikeConfig.config;
     if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
-        const isUserUsingViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        const isUserUsingViteApi = !isViteCli() && !isVikeCliOrApi();
         return isUserUsingViteApi;
     }
     else {
@@ -161,9 +161,9 @@ function isPrerenderForceExit() {
     return globalObject.forceExit;
 }
 function getFullBuildInlineConfig(config) {
-    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
-    if (config._viteConfigFromUserEnhanced) {
-        return config._viteConfigFromUserEnhanced;
+    const configFromCli = !isViteCli() ? null : getViteConfigForBuildFromCli();
+    if (config._viteConfigFromUserResolved) {
+        return config._viteConfigFromUserResolved;
     }
     else {
         return {

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

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

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

@@ -1,13 +1,13 @@
 export { pluginCommon };
-import { assert, assertUsage, assertWarning, hasProp, isDevCheck, isDocker, isObject, isVitest } from '../utils.js';
+import { assert, assertUsage, assertWarning, hasProp, isDevCheck, isDocker, isExactlyOneTruthy, isObject, isVitest, } from '../utils.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
 import { assertResolveAlias } from './pluginCommon/assertResolveAlias.js';
-import { isViteCliCall } from '../shared/isViteCliCall.js';
+import { isViteCli } from '../shared/isViteCli.js';
 import { isVikeCliOrApi } from '../../api/context.js';
 import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVikeConfigInternal.js';
-import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
+import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigFromUser.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 const pluginName = 'vike:pluginCommon';
 globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
@@ -20,12 +20,14 @@ function pluginCommon(vikeVitePluginOptions) {
                 order: 'pre',
                 async handler(configFromUser, env) {
                     const isDev = isDevCheck(env);
-                    const operation = env.command === 'build' ? 'build' : env.isPreview ? 'preview' : 'dev';
+                    const isBuild = env.command === 'build';
+                    const isPreview = env.isPreview;
+                    assert(isExactlyOneTruthy(isDev, isBuild, isPreview));
+                    const viteContext = isBuild ? 'build' : isPreview ? 'preview' : 'dev';
                     const rootResolvedEarly = configFromUser.root
                         ? normalizeViteRoot(configFromUser.root)
-                        : await getViteRoot(operation);
+                        : await getViteRoot(viteContext);
                     assert(rootResolvedEarly);
-                    // TO-DO/next-major-release: we can remove setVikeConfigContext() call here since with Vike's CLI it's already called at vike/node/api/prepareViteApiCall.ts
                     setVikeConfigContext({ userRootDir: rootResolvedEarly, isDev, vikeVitePluginOptions });
                     const vikeConfig = await getVikeConfigInternal();
                     return {
@@ -132,7 +134,7 @@ function assertSingleInstance(config) {
 function assertVikeCliOrApi(config) {
     if (isVikeCliOrApi())
         return;
-    if (isViteCliCall()) {
+    if (isViteCli()) {
         assert(!isVitest());
         return;
     }

package/dist/esm/node/vite/plugins/pluginReplaceConstantsGlobalThis.d.ts

@@ -1,4 +1,5 @@
 export { pluginReplaceConstantsGlobalThis };
+export type _LoadDeclareGlobal__VIKE__IS = never;
 import type { Plugin } from 'vite';
 declare global {
     /** Like `import.meta.env.DEV` but works for `node_modules/` packages with `ssr.external` */

package/dist/esm/node/vite/plugins/pluginViteConfigVikeExtensions.d.ts

@@ -0,0 +1,3 @@
+export { pluginViteConfigVikeExtensions };
+import type { Plugin } from 'vite';
+declare function pluginViteConfigVikeExtensions(): Promise<Plugin[]>;

package/dist/esm/node/vite/plugins/pluginViteConfigVikeExtensions.js

@@ -0,0 +1,32 @@
+export { pluginViteConfigVikeExtensions };
+import { mergeConfig } from 'vite';
+import { assertUsage, isObject } from '../utils.js';
+import { getVikeConfigInternalEarly } from '../../api/resolveViteConfigFromUser.js';
+// Apply +vite
+// - For example, Vike extensions adding Vite plugins
+async function pluginViteConfigVikeExtensions() {
+    const vikeConfig = await getVikeConfigInternalEarly();
+    if (vikeConfig === null)
+        return [];
+    let viteConfigFromExtensions = {};
+    const viteConfigsExtensions = vikeConfig._from.configsCumulative.vite;
+    if (!viteConfigsExtensions)
+        return [];
+    viteConfigsExtensions.values.forEach((v) => {
+        assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
+        viteConfigFromExtensions = mergeConfig(viteConfigFromExtensions, v.value);
+    });
+    const pluginsFromExtensions = (viteConfigFromExtensions.plugins ?? []);
+    delete viteConfigFromExtensions.plugins;
+    return [
+        ...pluginsFromExtensions,
+        {
+            name: 'vike:pluginViteConfigVikeExtensions',
+            config: {
+                handler(_config) {
+                    return viteConfigFromExtensions;
+                },
+            },
+        },
+    ];
+}

package/dist/esm/node/vite/shared/isViteCli.d.ts

@@ -0,0 +1,13 @@
+export { isViteCli };
+export { getViteConfigForBuildFromCli };
+export { getViteCommandFromCli };
+declare function isViteCli(): boolean;
+type ConfigFromCli = {
+    root: undefined | string;
+    configFile: undefined | string;
+} & Record<string, unknown> & {
+    build: Record<string, unknown>;
+};
+type ViteCommand = 'dev' | 'build' | 'optimize' | 'preview';
+declare function getViteCommandFromCli(): ViteCommand | null;
+declare function getViteConfigForBuildFromCli(): null | ConfigFromCli;

package/dist/esm/node/vite/shared/isViteCli.js

@@ -0,0 +1,143 @@
+export { isViteCli };
+export { getViteConfigForBuildFromCli };
+export { getViteCommandFromCli };
+import { assert, isObject, toPosixPath } from '../utils.js';
+import { cac } from 'cac';
+const desc = 'vike:vite-cli-simulation';
+function isViteCli() {
+    let execPath = process.argv[1];
+    assert(execPath);
+    execPath = toPosixPath(execPath);
+    return (
+    // pnpm
+    execPath.endsWith('/bin/vite.js') ||
+        // npm & yarn
+        execPath.endsWith('/.bin/vite') ||
+        // Global install
+        execPath.endsWith('/bin/vite'));
+}
+function getViteCommandFromCli() {
+    if (!isViteCli())
+        return null;
+    let command;
+    const setCommand = (cmd) => {
+        assert(command === undefined);
+        command = cmd;
+    };
+    // Copied & adapted from Vite
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L186-L188
+    const cli = cac(desc);
+    // dev
+    cli
+        .command('[root]', desc)
+        .alias('serve')
+        .alias('dev')
+        .action(() => {
+        setCommand('dev');
+    });
+    // build
+    cli.command('build [root]', desc).action(() => {
+        setCommand('build');
+    });
+    // optimize
+    cli.command('optimize [root]', desc).action(() => {
+        setCommand('optimize');
+    });
+    // preview
+    cli.command('preview [root]', desc).action(() => {
+        setCommand('preview');
+    });
+    cli.parse();
+    assert(command);
+    return command;
+}
+function getViteConfigForBuildFromCli() {
+    if (!isViteCli())
+        return null;
+    // Copied & adapted from Vite
+    const cli = cac(desc);
+    // Common configs
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L169-L182
+    cli
+        .option('-c, --config <file>', desc)
+        .option('--base <path>', desc)
+        .option('-l, --logLevel <level>', desc)
+        .option('--clearScreen', desc)
+        .option('--configLoader <loader>', desc)
+        .option('-d, --debug [feat]', desc)
+        .option('-f, --filter <filter>', desc)
+        .option('-m, --mode <mode>', desc);
+    // Build configs
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L286-L322
+    cli
+        .command('build [root]', desc)
+        .option('--target <target>', desc)
+        .option('--outDir <dir>', desc)
+        .option('--assetsDir <dir>', desc)
+        .option('--assetsInlineLimit <number>', desc)
+        .option('--ssr [entry]', desc)
+        .option('--sourcemap', desc)
+        .option('--minify [minifier]', desc)
+        .option('--manifest [name]', desc)
+        .option('--ssrManifest [name]', desc)
+        .option('--emptyOutDir', desc)
+        .option('-w, --watch', desc)
+        .option('--app', desc)
+        .action((root, options) => {
+        assert(isObject(options));
+        assert(root === undefined || typeof root === 'string');
+        assert(options.config === undefined || typeof options.config === 'string');
+        // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L331-L346
+        const buildOptions = cleanGlobalCLIOptions(cleanBuilderCLIOptions(options));
+        configFromCli = {
+            root,
+            base: options.base,
+            mode: options.mode,
+            configFile: options.config,
+            configLoader: options.configLoader,
+            logLevel: options.logLevel,
+            clearScreen: options.clearScreen,
+            build: buildOptions,
+            ...(options.app ? { builder: {} } : {}),
+        };
+    });
+    let configFromCli = null;
+    cli.parse();
+    return configFromCli;
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L99
+    function cleanGlobalCLIOptions(options) {
+        const ret = { ...options };
+        delete ret['--'];
+        delete ret.c;
+        delete ret.config;
+        delete ret.base;
+        delete ret.l;
+        delete ret.logLevel;
+        delete ret.clearScreen;
+        delete ret.configLoader;
+        delete ret.d;
+        delete ret.debug;
+        delete ret.f;
+        delete ret.filter;
+        delete ret.m;
+        delete ret.mode;
+        delete ret.force;
+        delete ret.w;
+        // convert the sourcemap option to a boolean if necessary
+        if ('sourcemap' in ret) {
+            const sourcemap = ret.sourcemap;
+            ret.sourcemap = sourcemap === 'true' ? true : sourcemap === 'false' ? false : ret.sourcemap;
+        }
+        if ('watch' in ret) {
+            const watch = ret.watch;
+            ret.watch = watch ? {} : undefined;
+        }
+        return ret;
+    }
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L141
+    function cleanBuilderCLIOptions(options) {
+        const ret = { ...options };
+        delete ret.app;
+        return ret;
+    }
+}

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

@@ -141,6 +141,15 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         return resolved;
                     }
                     assert(resolved.path);
+                    // Built-in modules e.g. node:fs
+                    if (resolved.path === args.path) {
+                        const isPointerImport = false;
+                        pointerImports[args.path] = isPointerImport;
+                        if (debug.isActivated)
+                            debug('onResolve() [built-in module]', { args, resolved });
+                        assert(resolved.external);
+                        return resolved;
+                    }
                     const importPathResolved = toPosixPath(resolved.path);
                     const importPathOriginal = args.path;
                     // Esbuild resolves path aliases.
@@ -185,7 +194,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         // User-land config code (i.e. not runtime code) => let esbuild transpile it
                         assert(!isPointerImport && !isNpmPkgImport);
                         if (debug.isActivated)
-                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                            debug('onResolve() [non-external]', { args, resolved, isPointerImport, isExternal });
                         return resolved;
                     }
                     let importPathTranspiled;
@@ -217,7 +226,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         }
                     }
                     if (debug.isActivated)
-                        debug('onResolved()', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
+                        debug('onResolve() [external]', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
                     assert(isExternal);
                     assert(
                     // Import of runtime code => handled by Vike

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

@@ -4,6 +4,7 @@ export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { getVikeConfigInternalSync };
 export { setVikeConfigContext };
+export { isVikeConfigContextSet };
 export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
@@ -45,6 +46,7 @@ declare function getVikeConfigInternalSync(): VikeConfigInternal;
 declare function getVikeConfig(config: ResolvedConfig | UserConfig): VikeConfig;
 type VikeConfig = Pick<VikeConfigInternal, 'config' | 'pages' | 'prerenderContext'>;
 declare function setVikeConfigContext(vikeConfigCtx_: VikeConfigContext): void;
+declare function isVikeConfigContextSet(): boolean;
 declare function getVikeConfigInternalOptional(): Promise<null | VikeConfigInternal>;
 declare function isV1Design(): boolean;
 declare function getVikeConfigFromCliOrEnv(): {

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

@@ -5,6 +5,7 @@ export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { getVikeConfigInternalSync };
 export { setVikeConfigContext };
+export { isVikeConfigContextSet };
 export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
@@ -83,6 +84,9 @@ function setVikeConfigContext(vikeConfigCtx_) {
     // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
     globalObject.vikeConfigCtx = vikeConfigCtx_;
 }
+function isVikeConfigContextSet() {
+    return !!globalObject.vikeConfigCtx;
+}
 async function getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     if (!globalObject.vikeConfigPromise) {
         resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);

package/dist/esm/node/vite/utils.d.ts

@@ -20,3 +20,4 @@ export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
 export * from '../../utils/virtualFileId.js';
+export * from '../../utils/isExactlyOneTruthy.js';

package/dist/esm/node/vite/utils.js

@@ -27,3 +27,4 @@ export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
 export * from '../../utils/virtualFileId.js';
+export * from '../../utils/isExactlyOneTruthy.js';

package/dist/esm/types/index.d.ts

@@ -13,6 +13,7 @@ export type { VikeConfig } from '../node/vite/shared/resolveVikeConfigInternal.j
 export type { UrlPublic as Url } from '../utils/parseUrl.js';
 export type { InjectFilterEntry } from '../node/runtime/renderPage/html/injectAssets/getHtmlTags.js';
 export { defineConfig } from './defineConfig.js';
+export type { _LoadDeclareGlobal__VIKE__IS } from '../node/vite/plugins/pluginReplaceConstantsGlobalThis.js';
 import type { ConfigEnv } from './PageConfig.js';
 /** @deprecated Replace:
  *   `import type { Env } from 'vike/types'`

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.241";
+export declare const PROJECT_VERSION: "0.4.242";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.241';
+export const PROJECT_VERSION = '0.4.242';

package/dist/esm/utils/isExactlyOneTruthy.d.ts

@@ -0,0 +1 @@
+export declare function isExactlyOneTruthy(...values: unknown[]): boolean;

package/dist/esm/utils/isExactlyOneTruthy.js

@@ -0,0 +1,4 @@
+// Aka XOR
+export function isExactlyOneTruthy(...values) {
+    return values.filter(Boolean).length === 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.241",
+  "version": "0.4.242",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/esm/node/vite/shared/isViteCliCall.d.ts

@@ -1,10 +0,0 @@
-export { isViteCliCall };
-export { getViteConfigFromCli };
-declare function isViteCliCall(): boolean;
-type ConfigFromCli = {
-    root: undefined | string;
-    configFile: undefined | string;
-} & Record<string, unknown> & {
-    build: Record<string, unknown>;
-};
-declare function getViteConfigFromCli(): null | ConfigFromCli;

package/dist/esm/node/vite/shared/isViteCliCall.js

@@ -1,81 +0,0 @@
-export { isViteCliCall };
-export { getViteConfigFromCli };
-import { assert, isObject, toPosixPath } from '../utils.js';
-import { cac } from 'cac';
-function isViteCliCall() {
-    let execPath = process.argv[1];
-    assert(execPath);
-    execPath = toPosixPath(execPath);
-    return (
-    // pnpm
-    execPath.endsWith('/bin/vite.js') ||
-        // npm & yarn
-        execPath.endsWith('/.bin/vite') ||
-        // Global install
-        execPath.endsWith('/bin/vite'));
-}
-function getViteConfigFromCli() {
-    if (!isViteCliCall())
-        return null;
-    // Copied and adapted from https://github.com/vitejs/vite/blob/8d0a9c1ab8ddd26973509ca230b29604e872e2cd/packages/vite/src/node/cli.ts#L137-L197
-    const cli = cac('vike:vite-simulation');
-    const desc = 'FAKE_CLI';
-    cli
-        .option('-c, --config <file>', desc)
-        .option('--base <path>', desc)
-        .option('-l, --logLevel <level>', desc)
-        .option('--clearScreen', desc)
-        .option('-d, --debug [feat]', desc)
-        .option('-f, --filter <filter>', desc)
-        .option('-m, --mode <mode>', desc);
-    cli
-        .command('build [root]', desc)
-        .option('--target <target>', desc)
-        .option('--outDir <dir>', desc)
-        .option('--assetsDir <dir>', desc)
-        .option('--assetsInlineLimit <number>', desc)
-        .option('--ssr [entry]', desc)
-        .option('--sourcemap', desc)
-        .option('--minify [minifier]', desc)
-        .option('--manifest [name]', desc)
-        .option('--ssrManifest [name]', desc)
-        .option('--force', desc)
-        .option('--emptyOutDir', desc)
-        .option('-w, --watch', desc)
-        .action((root, options) => {
-        assert(isObject(options));
-        const buildOptions = cleanOptions(options);
-        assert(root === undefined || typeof root === 'string');
-        assert(options.config === undefined || typeof options.config === 'string');
-        configFromCli = {
-            root,
-            base: options.base,
-            mode: options.mode,
-            configFile: options.config,
-            logLevel: options.logLevel,
-            clearScreen: options.clearScreen,
-            optimizeDeps: { force: options.force },
-            build: buildOptions,
-        };
-    });
-    let configFromCli = null;
-    cli.parse();
-    return configFromCli;
-    function cleanOptions(options) {
-        const ret = { ...options };
-        delete ret['--'];
-        delete ret.c;
-        delete ret.config;
-        delete ret.base;
-        delete ret.l;
-        delete ret.logLevel;
-        delete ret.clearScreen;
-        delete ret.d;
-        delete ret.debug;
-        delete ret.f;
-        delete ret.filter;
-        delete ret.m;
-        delete ret.mode;
-        return ret;
-    }
-}