vike 0.4.225 → 0.4.226-commit-a0035ee

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

@@ -2,78 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageContextProxyForUser = getPageContextProxyForUser;
 const utils_js_1 = require("../server-routing-runtime/utils.js");
-const notSerializable_js_1 = require("../../shared/notSerializable.js");
-const globalObject = (0, utils_js_1.getGlobalObject)('shared/getPageContextProxyForUser.ts', {});
-/**
- * Throw error when pageContext value isn't:
- * - serializable, or
- * - defined.
- */
+const NOT_SERIALIZABLE_js_1 = require("../../shared/NOT_SERIALIZABLE.js");
+// Throw error when pageContext value isn't serializable
 function getPageContextProxyForUser(pageContext) {
-    (0, utils_js_1.assert)([true, false].includes(pageContext._hasPageContextFromServer));
-    (0, utils_js_1.assert)([true, false].includes(pageContext._hasPageContextFromClient));
     return new Proxy(pageContext, {
         get(_, prop) {
             const val = pageContext[prop];
             const propName = (0, utils_js_1.getPropAccessNotation)(prop);
-            (0, utils_js_1.assertUsage)(val !== notSerializable_js_1.notSerializable, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
-            passToClientHint(pageContext, prop, propName);
+            (0, utils_js_1.assertUsage)(val !== NOT_SERIALIZABLE_js_1.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) {
-        (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: false, showStackTrace: true });
-    }
-    else {
-        (0, utils_js_1.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/cjs/node/api/build.js

@@ -16,13 +16,13 @@ const utils_js_1 = require("./utils.js");
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfig } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'build');
+    const { viteConfigFromUserEnhanced, vikeConfig } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'build');
     // Pass it to pluginAutoFullBuild()
-    if (viteConfigEnhanced)
-        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    if (viteConfigFromUserEnhanced)
+        viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
     if (vikeConfig.global.config.vite6BuilderApp) {
         (0, utils_js_1.assertVersion)('Vite', vite_1.version, '6.0.0');
-        const builder = await (0, vite_1.createBuilder)(viteConfigEnhanced);
+        const builder = await (0, vite_1.createBuilder)(viteConfigFromUserEnhanced);
         // See Vite plugin vike:build:pluginBuildApp
         await builder.buildApp();
     }
@@ -35,14 +35,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 (0, vite_1.build)(viteConfigEnhanced);
+        await (0, vite_1.build)(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
         if ((0, context_js_1.isVikeCli)() && (0, context_js_2.isPrerendering)())
             (0, assert_1.default)(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/cjs/node/api/dev.js

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

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

@@ -47,56 +47,80 @@ const path_1 = __importDefault(require("path"));
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const globalContext_js_1 = require("../runtime/globalContext.js");
+const getEnvVarObject_js_1 = require("../plugin/shared/getEnvVarObject.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('api/prepareViteApiCall.ts', {});
 async function prepareViteApiCall(options, operation) {
     clear();
     (0, context_js_1.setContextApiOperation)(operation, options);
-    const viteConfigFromOptions = options.viteConfig;
-    return enhanceViteConfig(viteConfigFromOptions, operation);
+    const viteConfigFromUserApiOptions = options.viteConfig;
+    return resolveConfigs(viteConfigFromUserApiOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
     (0, context_js_1.clearContextApiOperation)();
     (0, globalContext_js_1.clearGlobalContext)();
 }
-async function enhanceViteConfig(viteConfigFromOptions, operation) {
-    const viteInfo = await getInfoFromVite(viteConfigFromOptions, operation);
-    await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
+async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
+    const viteInfo = await getViteInfo(viteConfigFromUserApiOptions, operation);
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig2)(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
-    const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
+    const viteConfigFromUserEnhanced = applyVikeViteConfig(viteInfo.viteConfigFromUserEnhanced, vikeConfig);
+    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserEnhanced, operation);
     return {
         vikeConfig,
-        viteConfigEnhanced
+        viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
+        viteConfigFromUserEnhanced
     };
 }
-function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
+// Apply +vite
+// - For example, Vike extensions adding Vite plugins
+function applyVikeViteConfig(viteConfigFromUserEnhanced, vikeConfig) {
     const viteConfigs = vikeConfig.global._from.configsCumulative.vite;
     if (!viteConfigs)
-        return viteConfigEnhanced;
+        return viteConfigFromUserEnhanced;
     viteConfigs.values.forEach((v) => {
         (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(v.value), `${v.definedAt} should be an object`);
-        viteConfigEnhanced = (0, vite_1.mergeConfig)(viteConfigEnhanced ?? {}, v.value);
+        viteConfigFromUserEnhanced = (0, vite_1.mergeConfig)(viteConfigFromUserEnhanced ?? {}, v.value);
         (0, utils_js_1.assertUsage)(!findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
     });
-    return viteConfigEnhanced;
+    return viteConfigFromUserEnhanced;
 }
 async function getViteRoot(operation) {
     if (!globalObject.root)
-        await getInfoFromVite(undefined, operation);
+        await getViteInfo(undefined, operation);
     (0, utils_js_1.assert)(globalObject.root);
     return globalObject.root;
 }
-async function getInfoFromVite(viteConfigFromOptions, operation) {
-    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
-    const root = normalizeViteRoot(
-    // `viteConfigFromOptions.root` before `viteConfigFromUserViteFile.root` replicates Vite's precedence:
+async function getViteInfo(viteConfigFromUserApiOptions, operation) {
+    let viteConfigFromUserEnhanced = viteConfigFromUserApiOptions;
+    // Precedence:
+    //  1) viteConfigFromUserEnvVar (highest precendence)
+    //  2) viteConfigFromUserVikeConfig
+    //  2) viteConfigFromUserApiOptions
+    //  3) viteConfigFromUserViteFile (lowest precendence)
+    // Resolve Vike's +mode setting
+    {
+        const viteConfigFromUserVikeConfig = (0, utils_js_1.pick)((0, getVikeConfig_js_1.getVikeConfigFromCliOrEnv)().vikeConfigFromCliOrEnv, ['mode']);
+        if (Object.keys(viteConfigFromUserVikeConfig).length > 0) {
+            viteConfigFromUserEnhanced = (0, vite_1.mergeConfig)(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserVikeConfig);
+        }
+    }
+    // Resolve VITE_CONFIG
+    const viteConfigFromUserEnvVar = (0, getEnvVarObject_js_1.getEnvVarObject)('VITE_CONFIG');
+    if (viteConfigFromUserEnvVar) {
+        viteConfigFromUserEnhanced = (0, vite_1.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
-    viteConfigFromOptions?.root ?? viteConfigFromUserViteFile?.root ?? process.cwd());
+    const viteConfigResolved = (0, vite_1.mergeConfig)(viteConfigFromUserViteFile ?? {}, viteConfigFromUserEnhanced ?? {});
+    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
     globalObject.root = root;
+    // - Find options `vike(options)` set in vite.config.js
+    //   - TODO/next-major: remove
+    // - Add Vike's Vite plugin if missing
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfigFromOptions;
-    // If Vike's Vite plugin is found in both viteConfigFromOptions and viteConfigFromUserViteFile then Vike will later throw an error
-    const found = findVikeVitePlugin(viteConfigFromOptions) || findVikeVitePlugin(viteConfigFromUserViteFile);
+    const found = findVikeVitePlugin(viteConfigResolved);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -104,16 +128,16 @@ async function getInfoFromVite(viteConfigFromOptions, operation) {
         // 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 Promise.resolve().then(() => __importStar(require('../plugin/index.js')));
-        viteConfigEnhanced = {
-            ...viteConfigFromOptions,
-            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
+        viteConfigFromUserEnhanced = {
+            ...viteConfigFromUserEnhanced,
+            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()]
         };
-        const res = findVikeVitePlugin(viteConfigEnhanced);
+        const res = findVikeVitePlugin(viteConfigFromUserEnhanced);
         (0, utils_js_1.assert)(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     (0, utils_js_1.assert)(vikeVitePluginOptions);
-    return { root, vikeVitePluginOptions, viteConfigEnhanced };
+    return { root, vikeVitePluginOptions, viteConfigFromUserEnhanced };
 }
 function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
@@ -131,8 +155,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(viteConfigFromOptions, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromOptions, operation);
+async function loadViteConfigFile(viteConfigFromUserApiOptions, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromUserApiOptions, operation);
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
     const configEnv = {
@@ -164,11 +188,12 @@ function normalizeViteRoot(root) {
     path_1.default.resolve(root));
 }
 const errMsg = `A Vite plugin is modifying Vite's setting ${picocolors_1.default.cyan('root')} which is forbidden`;
-async function assertViteRoot2(root, viteConfigEnhanced, operation) {
-    const args = getResolveConfigArgs(viteConfigEnhanced, operation);
-    // We can eventually 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 which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
+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 (0, vite_1.resolveConfig)(...args);
     (0, utils_js_1.assertUsage)(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
+    return { viteConfigResolved };
 }
 function assertViteRoot(root, config) {
     if (globalObject.root)

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

@@ -3,15 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prerender = prerender;
 const runPrerender_js_1 = require("../prerender/runPrerender.js");
 const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
-// TODO/soon use importServerProductionIndex()
 /**
  * Programmatically trigger `$ vike prerender`
  *
  * https://vike.dev/api#prerender
  */
 async function prerender(options = {}) {
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'prerender');
-    options.viteConfig = viteConfigEnhanced;
+    const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'prerender');
+    options.viteConfig = viteConfigFromUserEnhanced;
     const { viteConfig } = await (0, runPrerender_js_1.runPrerenderFromAPI)(options);
     return {
         viteConfig

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

@@ -1,18 +1,39 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preview = preview;
 const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
 const vite_1 = require("vite");
+const runtime_1 = require("@brillout/vite-plugin-server-entry/runtime");
+const getOutDirs_js_1 = require("../plugin/shared/getOutDirs.js");
+const utils_js_1 = require("./utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_js_2 = require("../runtime/utils.js");
 /**
  * Programmatically trigger `$ vike preview`
  *
  * https://vike.dev/api#preview
  */
 async function preview(options = {}) {
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'preview');
-    const server = await (0, vite_1.preview)(viteConfigEnhanced);
-    return {
-        viteServer: server,
-        viteConfig: server.config
-    };
+    (0, utils_js_2.onSetupPreview)();
+    const { viteConfigFromUserEnhanced, viteConfigResolved } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'preview');
+    if (viteConfigResolved.vitePluginServerEntry?.inject) {
+        const outDir = (0, getOutDirs_js_1.getOutDirs)(viteConfigResolved).outDirRoot;
+        const { outServerIndex } = await (0, runtime_1.importServerProductionIndex)({ outDir });
+        const outServerIndexRelative = node_path_1.default.relative(viteConfigResolved.root, outServerIndex);
+        (0, utils_js_1.assertWarning)(false, `Never run ${picocolors_1.default.cyan('$ vike preview')} in production, run ${picocolors_1.default.cyan(`$ node ${outServerIndexRelative}`)} instead (or Bun/Deno).`, { onlyOnce: true });
+        return {
+            viteConfig: viteConfigResolved
+        };
+    }
+    else {
+        const server = await (0, vite_1.preview)(viteConfigFromUserEnhanced);
+        return {
+            viteServer: server,
+            viteConfig: server.config
+        };
+    }
 }

package/dist/cjs/node/api/utils.js

@@ -23,3 +23,4 @@ __exportStar(require("../../utils/getGlobalObject.js"), exports);
 __exportStar(require("../../utils/path.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/assertVersion.js"), exports);
+__exportStar(require("../../utils/pick.js"), exports);

package/dist/cjs/node/cli/entry.js

@@ -95,8 +95,10 @@ async function cmdBuild() {
 async function cmdPreview() {
     try {
         const { viteServer } = await (0, index_js_1.preview)();
-        viteServer.printUrls();
-        viteServer.bindCLIShortcuts({ print: true });
+        if (viteServer) {
+            viteServer.printUrls();
+            viteServer.bindCLIShortcuts({ print: true });
+        }
     }
     catch (err) {
         console.error(picocolors_1.default.red(`Error while starting preview server:`));

package/dist/cjs/node/cli/parseCli.js

@@ -11,7 +11,7 @@ const commands = [
     { name: 'dev', desc: 'Start development server' },
     { name: 'build', desc: 'Build for production' },
     { name: 'preview', desc: 'Start preview server using production build (only works for SSG apps)' },
-    { name: 'prerender', desc: 'Pre-render pages (only needed when partial.disableAutoRun is true)' }
+    { name: 'prerender', desc: 'Pre-render pages (only needed when prerender.disableAutoRun is true)' }
 ];
 function parseCli() {
     const command = getCommand();
@@ -62,10 +62,16 @@ function showHelp() {
         `vike@${utils_js_1.PROJECT_VERSION}`,
         '',
         'Usage:',
-        ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${picocolors_1.default.dim('$')} ${picocolors_1.default.bold(`vike ${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${picocolors_1.default.dim(`# ${c.desc}`)}`),
+        ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${picocolors_1.default.dim('$')} vike ${c.name.startsWith('-') ? picocolors_1.default.cyan(`${c.name}`) : picocolors_1.default.bold(`${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${picocolors_1.default.dim(`# ${c.desc}`)}`),
         '',
-        `Vike settings can be passed over the ${picocolors_1.default.cyan('VIKE_CONFIG')} environment variable or as ${picocolors_1.default.cyan('CLI options')} such as --host.`,
-        `Vite settings can be passed over the ${picocolors_1.default.cyan('VITE_CONFIG')} environment variable.`,
+        'Common CLI options:',
+        [`vike dev ${picocolors_1.default.cyan('--host')}`, `vike dev ${picocolors_1.default.cyan('--port')} 80`, `vike build ${picocolors_1.default.cyan('--mode')} staging`]
+            .map((o) => `  ${picocolors_1.default.dim('$')} ${o}`)
+            .join('\n'),
+        '',
+        `More Vike settings can be passed over the ${picocolors_1.default.cyan('VIKE_CONFIG')} environment variable or as ${picocolors_1.default.cyan('CLI options')}.`,
+        `More Vite settings can be passed over the ${picocolors_1.default.cyan('VITE_CONFIG')} environment variable.`,
+        ``,
         `See ${picocolors_1.default.underline('https://vike.dev/cli')} for more information.`
     ].join('\n'));
     process.exit(1);

package/dist/cjs/node/plugin/plugins/build/pluginAutoFullBuild.js

@@ -95,7 +95,7 @@ async function triggerFullBuild(config, vikeConfig, viteEnv, bundle) {
         // The server bulid is already called by builder.buildApp()
     }
     if ((0, context_js_1.isPrerenderAutoRunEnabled)(vikeConfig)) {
-        const res = await (0, runPrerender_js_1.runPrerenderFromAutoRun)(configInline, config);
+        const res = await (0, runPrerender_js_1.runPrerenderFromAutoRun)(configInline);
         forceExit = res.forceExit;
     }
 }
@@ -129,8 +129,8 @@ function isPrerenderForceExit() {
 }
 function getFullBuildInlineConfig(config) {
     const configFromCli = !(0, isViteCliCall_js_1.isViteCliCall)() ? null : (0, isViteCliCall_js_1.getViteConfigFromCli)();
-    if (config._viteConfigEnhanced) {
-        return config._viteConfigEnhanced;
+    if (config._viteConfigFromUserEnhanced) {
+        return config._viteConfigFromUserEnhanced;
     }
     else {
         return {

package/dist/cjs/node/plugin/plugins/build/pluginModuleBanner.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginModuleBanner = pluginModuleBanner;
+const utils_js_1 = require("../../utils.js");
+const virtual_files_js_1 = require("../../../shared/virtual-files.js");
+const isViteServerBuild_js_1 = require("../../shared/isViteServerBuild.js");
+// Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
+// But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
+const vikeModuleBannerPlaceholder = 'vikeModuleBannerPlaceholder';
+function pluginModuleBanner() {
+    let config;
+    return {
+        name: 'vike:pluginModuleBanner',
+        enforce: 'post',
+        apply: 'build',
+        configResolved(config_) {
+            config = config_;
+        },
+        generateBundle: {
+            order: 'post',
+            handler(_options, bundle) {
+                for (const module of Object.values(bundle)) {
+                    if (module.type === 'chunk') {
+                        if ((0, isViteServerBuild_js_1.isViteServerBuild)(config)) {
+                            const codeOld = module.code;
+                            const codeNew = codeOld.replace(/vikeModuleBannerPlaceholder\("([^"]*)"\);/g, '/* $1 [vike:pluginModuleBanner] */');
+                            (0, utils_js_1.assert)(!codeNew.includes(vikeModuleBannerPlaceholder));
+                            module.code = codeNew;
+                        }
+                        else {
+                            (0, utils_js_1.assert)(!module.code.includes(vikeModuleBannerPlaceholder));
+                        }
+                    }
+                }
+            }
+        },
+        transform: {
+            order: 'post',
+            handler(code, id, options) {
+                if (!(0, isViteServerBuild_js_1.isViteServerBuild_safe)(config, options))
+                    return;
+                if (id.startsWith('\0'))
+                    id = id;
+                id = (0, virtual_files_js_1.removeVirtualIdTag)(id);
+                if (id.startsWith(config.root))
+                    id = id.slice(config.root.length + 1);
+                return `${vikeModuleBannerPlaceholder}(${JSON.stringify(id)}); ${code}`;
+            }
+        }
+    };
+}

package/dist/cjs/node/plugin/plugins/build.js

@@ -8,6 +8,7 @@ const pluginDistFileNames_js_1 = require("./build/pluginDistFileNames.js");
 const pluginAutoFullBuild_js_1 = require("./build/pluginAutoFullBuild.js");
 const pluginBuildEntry_js_1 = require("./build/pluginBuildEntry.js");
 const pluginBuildConfig_js_1 = require("./build/pluginBuildConfig.js");
+const pluginModuleBanner_js_1 = require("./build/pluginModuleBanner.js");
 function build() {
     return [
         ...(0, pluginBuildConfig_js_1.pluginBuildConfig)(),
@@ -16,6 +17,7 @@ function build() {
         ...(0, pluginBuildEntry_js_1.pluginBuildEntry)(),
         (0, pluginDistPackageJsonFile_js_1.pluginDistPackageJsonFile)(),
         (0, pluginSuppressRollupWarning_js_1.pluginSuppressRollupWarning)(),
-        (0, pluginDistFileNames_js_1.pluginDistFileNames)()
+        (0, pluginDistFileNames_js_1.pluginDistFileNames)(),
+        (0, pluginModuleBanner_js_1.pluginModuleBanner)()
     ];
 }

package/dist/cjs/node/plugin/plugins/commonConfig.js

@@ -5,14 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonConfig = commonConfig;
 exports.getVikeConfigPublic = getVikeConfigPublic;
-const vite_1 = require("vite");
 const utils_js_1 = require("../utils.js");
 const pluginBuildConfig_js_1 = require("./build/pluginBuildConfig.js");
 const require_shim_1 = require("@brillout/require-shim");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const path_1 = __importDefault(require("path"));
 const assertResolveAlias_js_1 = require("./commonConfig/assertResolveAlias.js");
-const getEnvVarObject_js_1 = require("../shared/getEnvVarObject.js");
 const isViteCliCall_js_1 = require("../shared/isViteCliCall.js");
 const context_js_1 = require("../../api/context.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
@@ -21,6 +19,8 @@ const context_js_2 = require("../../prerender/context.js");
 const resolvePrerenderConfig_js_1 = require("../../prerender/resolvePrerenderConfig.js");
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
+    // We cache it => makes sure we only generate one object => we can mutate it at runPrerender()
+    let prerenderContext;
     return [
         {
             name: `${pluginName}:pre`,
@@ -33,6 +33,9 @@ function commonConfig(vikeVitePluginOptions) {
                     const root = configFromUser.root ? (0, prepareViteApiCall_js_1.normalizeViteRoot)(configFromUser.root) : await (0, prepareViteApiCall_js_1.getViteRoot)(operation);
                     (0, utils_js_1.assert)(root);
                     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig2)(root, isDev, vikeVitePluginOptions);
+                    const { isPrerenderingEnabled } = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
+                    prerenderContext ?? (prerenderContext = { isPrerenderingEnabled, output: null, pageContexts: null });
+                    (0, utils_js_1.assert)(prerenderContext.isPrerenderingEnabled === isPrerenderingEnabled);
                     return {
                         _isDev: isDev,
                         _root: root,
@@ -40,11 +43,12 @@ function commonConfig(vikeVitePluginOptions) {
                         _vikeConfigObject: vikeConfig,
                         _vike: {
                             pages: vikeConfig.pages,
-                            config: vikeConfig.global.config
+                            config: vikeConfig.global.config,
+                            prerenderContext
                         },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
-                            prerender: (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig).isPrerenderingEnabled
+                            prerender: isPrerenderingEnabled
                         })
                     };
                 }
@@ -73,6 +77,7 @@ function commonConfig(vikeVitePluginOptions) {
                     assertEsm(config.root);
                     assertVikeCliOrApi(config);
                     temp_supportOldInterface(config);
+                    emitServerEntryOnlyIfNeeded(config);
                 }
             },
             config: {
@@ -96,10 +101,6 @@ function commonConfig(vikeVitePluginOptions) {
                         // Set `--host` for Docker/Podman
                         setDefault('host', true, configFromUser, configFromVike);
                     }
-                    // VITE_CONFIG
-                    const configFromEnvVar = (0, getEnvVarObject_js_1.getEnvVarObject)('VITE_CONFIG');
-                    if (configFromEnvVar)
-                        configFromVike = (0, vite_1.mergeConfig)(configFromVike, configFromEnvVar);
                     return configFromVike;
                 }
             }
@@ -202,3 +203,10 @@ function getVikeConfigPublic(config) {
     (0, utils_js_1.assert)(vikeConfig);
     return vikeConfig;
 }
+// Only emit dist/server/entry.mjs if necessary
+function emitServerEntryOnlyIfNeeded(config) {
+    if (config.vitePluginServerEntry?.inject &&
+        !(0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(config._vikeConfigObject).isPrerenderingEnabled) {
+        config.vitePluginServerEntry.disableServerEntryEmit = true;
+    }
+}

package/dist/cjs/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -52,18 +52,18 @@ async function getPageDeps(config, pageConfigs) {
                     .forEach((configValueSource) => {
                     if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
                         return;
-                    const { definedAtFilePath, configEnv } = configValueSource;
+                    const { definedAt, configEnv } = configValueSource;
                     if (!configEnv.client)
                         return;
-                    if (definedAtFilePath.definedBy)
+                    if (definedAt.definedBy)
                         return;
-                    if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
+                    if (definedAt.filePathAbsoluteUserRootDir !== null) {
                         // Vite expects entries to be filesystem absolute paths (surprisingly so).
-                        addEntry(definedAtFilePath.filePathAbsoluteFilesystem);
+                        addEntry(definedAt.filePathAbsoluteFilesystem);
                     }
                     else {
                         // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                        addInclude(definedAtFilePath.importPathAbsolute);
+                        addInclude(definedAt.importPathAbsolute);
                     }
                 });
             });

package/dist/cjs/node/plugin/plugins/fileEnv.js

@@ -12,6 +12,7 @@ const getFilePath_js_1 = require("../shared/getFilePath.js");
 const rollupSourceMap_js_1 = require("../shared/rollupSourceMap.js");
 const parseEsModule_js_1 = require("../shared/parseEsModule.js");
 const normalizeId_js_1 = require("../shared/normalizeId.js");
+const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
 function fileEnv() {
     let config;
     let viteDevServer;
@@ -21,6 +22,8 @@ function fileEnv() {
             // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
             if (!viteDevServer)
                 return;
+            if (!(0, getVikeConfig_js_1.isV1Design)(config))
+                return;
             if (skip(id))
                 return;
             // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475