vike 0.4.220-commit-af5c91f → 0.4.221-commit-8577456

package/dist/esm/__internal/index.js

@@ -1,19 +1,19 @@
-// Internals needed by Vike
+// Needed by Vike
 export { setGlobalContext_buildEntry } from '../node/runtime/globalContext.js';
-// Internals needed by vite-plugin-vercel
+// Needed by vite-plugin-vercel
 export { route, getPagesAndRoutes };
-// Internals needed by experimental implementation of vike-telefunc
-export { getMiddlewares };
 import { route as routeInternal } from '../shared/route/index.js';
-import { getPageFilesAll } from '../shared/getPageFiles/getPageFiles.js';
-import { getGlobalContext, initGlobalContext_getGlobalContextAsync } from '../node/runtime/globalContext.js';
+import { getGlobalContextInternal, initGlobalContext_getPagesAndRoutes } from '../node/runtime/globalContext.js';
 import { setNodeEnvProduction } from '../utils/assertSetup.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
+ *
+ * TODO/eventually: remove
  */
 async function getPagesAndRoutes() {
     setNodeEnvProduction();
-    const globalContext = getGlobalContext();
+    await initGlobalContext_getPagesAndRoutes();
+    const globalContext = await getGlobalContextInternal();
     const { 
     //
     pageRoutes, pageFilesAll, pageConfigs, allPageIds } = globalContext;
@@ -24,25 +24,6 @@ async function getPagesAndRoutes() {
         allPageIds
     };
 }
-// TODO/eventually:
-//  - Remove the need for `isProduction` after Vike's CLI is implemented
-//  - Remove it in favor of https://vike.dev/getGlobalContext
-async function getMiddlewares() {
-    const isProduction = process.env.NODE_ENV === 'production';
-    const { pageConfigs } = await getPageFilesAllSafe(isProduction);
-    const middlewares = pageConfigs[0].configValues.middleware.value.flat(Infinity);
-    return middlewares;
-}
-// TODO/eventually:
-//  - Make it cleaner once the internal refactoring about global configs is done.
-//  - Remove it in favor of https://vike.dev/getGlobalContext
-// Demo usage: https://github.com/vikejs/vike/pull/1823
-async function getPageFilesAllSafe(isProduction) {
-    await initGlobalContext_getGlobalContextAsync(isProduction);
-    const globalContext = getGlobalContext();
-    const pageFilesAll = await getPageFilesAll(false, globalContext.isProduction);
-    return pageFilesAll;
-}
 async function route(pageContext) {
     const pageContextFromRoute = await routeInternal(pageContext);
     // Old interface

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

@@ -1,18 +1,14 @@
 export { createPageContext };
+import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
-import { getPageFilesAll, setPageFiles } from '../../shared/getPageFiles/getPageFiles.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
-import { assert, isBaseServer, getGlobalObject, objectAssign } from './utils.js';
+import { assert, isBaseServer, objectAssign } from './utils.js';
+// TODO/now: can we avoid optimizeDeps.exclude of client runtime?
 // @ts-ignore
-import * as pageFilesExports from 'virtual:vike:importUserCode:client:client-routing';
-const globalObject = getGlobalObject('createPageContext.ts', {});
-setPageFiles(pageFilesExports);
+import * as virtualFileExports from 'virtual:vike:importUserCode:client:client-routing';
+const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
 async function createPageContext(urlOriginal) {
-    if (!globalObject.pageFilesData) {
-        globalObject.pageFilesData = await getPageFilesAll(true);
-    }
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = globalObject.pageFilesData;
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
     const baseServer = getBaseServer();
     assert(isBaseServer(baseServer));

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

@@ -1,13 +1,13 @@
 export { getPageContext };
 import { assertUsage, assertWarning, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
-import { getPageFilesAll, setPageFiles } from '../../shared/getPageFiles/getPageFiles.js';
 import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
+import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
 // @ts-ignore
-import * as pageFilesExports from 'virtual:vike:importUserCode:client:server-routing';
+import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-routing';
+const { pageFilesAll, pageConfigs } = getPageConfigsRuntime(virtualFileExports);
 const urlFirst = getCurrentUrl({ withoutHash: true });
-setPageFiles(pageFilesExports);
 async function getPageContext() {
     const pageContext = getPageContextSerializedInHtml();
     objectAssign(pageContext, {
@@ -26,7 +26,6 @@ function assertPristineUrl() {
 }
 async function loadPageUserFiles(pageId) {
     const pageContextAddendum = {};
-    const { pageFilesAll, pageConfigs } = await getPageFilesAll(true);
     objectAssign(pageContextAddendum, {
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs

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

@@ -1,6 +1,7 @@
 export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
-import { getPageFilesClientSide, getPageConfigUserFriendly } from '../../shared/getPageFiles.js';
+import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
+import { getPageConfigUserFriendlyOld } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { objectAssign } from '../server-routing-runtime/utils.js';
@@ -29,7 +30,7 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         }
         throw err;
     }
-    const pageContextExports = getPageConfigUserFriendly(pageFilesClientSide, pageConfigLoaded);
+    const pageContextExports = getPageConfigUserFriendlyOld(pageFilesClientSide, pageConfigLoaded);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

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

@@ -1,29 +1,40 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
-import { build as buildVite } from 'vite';
+import { build as buildVite, version } from 'vite';
 import assert from 'assert';
 import { isVikeCli } from '../cli/context.js';
 import { isPrerendering } from '../prerender/context.js';
+import { assertVersion } from './utils.js';
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'build');
+    const { viteConfigEnhanced, vikeConfig } = await prepareViteApiCall(options.viteConfig, 'build');
     // Pass it to autoFullBuild()
     if (viteConfigEnhanced)
         viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
-    // 1. Build client-side
-    // 2. Build server-side
-    //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L90
-    // 3. Pre-render (if enabled)
-    //    > 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);
-    // When using the Vike CLI with pre-rendering the process is forcefully exited at the end of the buildVite() call above
-    assert(!(isVikeCli() && isPrerendering()));
+    if (vikeConfig.global.config.viteEnvironmentAPI) {
+        assertVersion('Vite', version, '6.0.0');
+        const { createBuilder } = await import('vite');
+        const builder = await createBuilder(viteConfigEnhanced);
+        await builder.buildApp();
+    }
+    else {
+        // This buildVite() call does everything:
+        // 1. Build client-side
+        // 2. Build server-side
+        //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L90
+        // 3. Pre-render (if enabled)
+        //    > 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);
+        // 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,

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

@@ -4,9 +4,11 @@ export { assertViteRoot };
 export { normalizeViteRoot };
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { Operation } from './types.js';
-declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
+import { type VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+declare function prepareViteApiCall(viteConfigFromOptions: InlineConfig | undefined, operation: Operation): Promise<{
+    vikeConfig: VikeConfigObject;
     viteConfigEnhanced: InlineConfig | undefined;
 }>;
-declare function getViteRoot(operation: 'build' | 'dev' | 'preview' | 'prerender'): Promise<string>;
+declare function getViteRoot(operation: Operation): Promise<string>;
 declare function normalizeViteRoot(root: string): string;
 declare function assertViteRoot(root: string, config: ResolvedConfig): void;

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

@@ -11,32 +11,34 @@ import { assert, assertUsage, getGlobalObject, isObject, toPosixPath } from './u
 import pc from '@brillout/picocolors';
 import { clearGlobalContext } from '../runtime/globalContext.js';
 const globalObject = getGlobalObject('prepareViteApiCall.ts', {});
-async function prepareViteApiCall(viteConfig, operation) {
+async function prepareViteApiCall(viteConfigFromOptions, operation) {
     clear();
     setContextApiOperation(operation);
-    return enhanceViteConfig(viteConfig, operation);
+    return enhanceViteConfig(viteConfigFromOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
     clearContextApiOperation();
     clearGlobalContext();
 }
-async function enhanceViteConfig(viteConfig, operation) {
-    const viteInfo = await getInfoFromVite(viteConfig, operation);
+async function enhanceViteConfig(viteConfigFromOptions, operation) {
+    const viteInfo = await getInfoFromVite(viteConfigFromOptions, operation);
     await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
     const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
     const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
     return {
+        vikeConfig,
         viteConfigEnhanced
     };
 }
 function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
-    const viteConfigs = vikeConfig.global.from.configsCumulative.vite;
+    const viteConfigs = vikeConfig.global._from.configsCumulative.vite;
     if (!viteConfigs)
         return viteConfigEnhanced;
     viteConfigs.values.forEach((v) => {
         assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
         viteConfigEnhanced = mergeConfig(viteConfigEnhanced ?? {}, v.value);
+        assertUsage(findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
     });
     return viteConfigEnhanced;
 }
@@ -46,13 +48,14 @@ async function getViteRoot(operation) {
     assert(globalObject.root);
     return globalObject.root;
 }
-async function getInfoFromVite(viteConfig, operation) {
-    const viteConfigFromFile = await loadViteConfigFile(viteConfig, operation);
-    const root = normalizeViteRoot(viteConfigFromFile?.root ?? viteConfig?.root ?? process.cwd());
+async function getInfoFromVite(viteConfigFromOptions, operation) {
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
+    const root = normalizeViteRoot(viteConfigFromUserViteFile?.root ?? viteConfigFromOptions?.root ?? process.cwd());
     globalObject.root = root;
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfig;
-    const found = findVikeVitePlugin([...(viteConfig?.plugins ?? []), ...(viteConfigFromFile?.plugins ?? [])]);
+    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);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -61,20 +64,20 @@ async function getInfoFromVite(viteConfig, operation) {
         // 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('../plugin/index.js');
         viteConfigEnhanced = {
-            ...viteConfig,
-            plugins: [...(viteConfig?.plugins ?? []), vikePlugin()]
+            ...viteConfigFromOptions,
+            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
         };
-        const res = findVikeVitePlugin(viteConfigEnhanced.plugins);
+        const res = findVikeVitePlugin(viteConfigEnhanced);
         assert(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     assert(vikeVitePluginOptions);
     return { root, vikeVitePluginOptions, viteConfigEnhanced };
 }
-function findVikeVitePlugin(plugins) {
+function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
     let vikeVitePuginFound = false;
-    plugins.forEach((p) => {
+    viteConfig?.plugins?.forEach((p) => {
         if (p && '__vikeVitePluginOptions' in p) {
             vikeVitePuginFound = true;
             const options = p.__vikeVitePluginOptions;
@@ -87,8 +90,8 @@ function findVikeVitePlugin(plugins) {
     return { vikeVitePluginOptions };
 }
 // Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfig, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfig, operation);
+async function loadViteConfigFile(viteConfigFromOptions, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromOptions, operation);
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
     const configEnv = {

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

@@ -1,6 +1,7 @@
 export { prerender };
 import { runPrerenderFromAPI } from '../prerender/runPrerender.js';
 import { prepareViteApiCall } from './prepareViteApiCall.js';
+// TODO/soon use importServerProductionIndex()
 /**
  * Programmatically trigger `$ vike prerender`
  *

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

@@ -2,3 +2,4 @@ export * from '../../utils/assert.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/path.js';
 export * from '../../utils/isObject.js';
+export * from '../../utils/assertVersion.js';

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

@@ -6,3 +6,4 @@ export * from '../../utils/assert.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/path.js';
 export * from '../../utils/isObject.js';
+export * from '../../utils/assertVersion.js';

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

@@ -26,6 +26,7 @@ import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.
 import { resolveClientEntriesDev } from './shared/resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
 import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegression.js';
+import { buildApp } from './plugins/buildApp.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
@@ -35,6 +36,7 @@ function plugin(vikeVitePluginOptions = {}) {
         importUserCode(),
         ...devConfig(),
         ...buildConfig(),
+        ...buildApp(),
         previewConfig(),
         ...autoFullBuild(),
         packageJsonFile(),

package/dist/esm/node/plugin/plugins/autoFullBuild.js

@@ -1,7 +1,8 @@
 // TODO/v1-release: remove this file
+import { getFullBuildInlineConfig } from '../shared/getFullBuildInlineConfig.js';
 export { autoFullBuild };
 import { build } from 'vite';
-import { assertWarning } from '../utils.js';
+import { assert, assertWarning } from '../utils.js';
 import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../prerender/runPrerender.js';
 import { isPrerenderAutoRunEnabled } from '../../prerender/context.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
@@ -10,7 +11,6 @@ import { logErrorHint } from '../../runtime/renderPage/logErrorHint.js';
 import { manifestTempFile } from './buildConfig.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { isVikeCliOrApi } from '../../api/context.js';
-import { isVikeCli } from '../../cli/context.js';
 let forceExit = false;
 function autoFullBuild() {
     let config;
@@ -52,6 +52,7 @@ function autoFullBuild() {
                 handler() {
                     if (forceExit) {
                         runPrerender_forceExit();
+                        assert(false);
                     }
                 }
             }
@@ -69,21 +70,7 @@ async function triggerFullBuild(config, vikeConfig, bundle) {
     //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
     if (!bundle[manifestTempFile])
         return;
-    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
-    let configInline;
-    if (config._viteConfigEnhanced) {
-        configInline = config._viteConfigEnhanced;
-    }
-    else {
-        configInline = {
-            ...configFromCli,
-            configFile: configFromCli?.configFile || config.configFile,
-            root: config.root,
-            build: {
-                ...configFromCli?.build
-            }
-        };
-    }
+    const configInline = getFullBuildInlineConfig(config);
     try {
         await build(setSSR(configInline));
     }
@@ -93,9 +80,8 @@ async function triggerFullBuild(config, vikeConfig, bundle) {
         process.exit(1);
     }
     if (isPrerenderAutoRunEnabled(vikeConfig)) {
-        const { prerenderContextPublic } = await runPrerenderFromAutoRun(configInline);
-        config.vike.prerenderContext = prerenderContextPublic;
-        forceExit = isVikeCli() || isViteCliCall();
+        const res = await runPrerenderFromAutoRun(configInline, config);
+        forceExit = res.forceExit;
     }
 }
 function setSSR(configInline) {
@@ -114,7 +100,10 @@ function abortViteBuildSsr(vikeConfig) {
     }
 }
 function isDisabled(vikeConfig) {
-    const { disableAutoFullBuild } = vikeConfig.global.config;
+    const { disableAutoFullBuild, viteEnvironmentAPI } = vikeConfig.global.config;
+    if (viteEnvironmentAPI) {
+        return true;
+    }
     if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
         const isViteApi = !isViteCliCall() && !isVikeCliOrApi();
         return isViteApi;

package/dist/esm/node/plugin/plugins/baseUrls.js

@@ -11,7 +11,7 @@ function baseUrls() {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            basesResolved = resolveBase(baseViteOriginal, config.vike.global.config.baseServer ?? null, config.vike.global.config.baseAssets ?? null);
+            basesResolved = resolveBase(baseViteOriginal, config.vike.config.baseServer ?? null, config.vike.config.baseAssets ?? null);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;
             process.env.BASE_ASSETS = basesResolved.baseAssets;

package/dist/esm/node/plugin/plugins/buildApp.d.ts

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

package/dist/esm/node/plugin/plugins/buildApp.js

@@ -0,0 +1,70 @@
+import { runPrerender_forceExit, runPrerenderFromAutoRun } from '../../prerender/runPrerender.js';
+export { buildApp };
+import { isPrerenderAutoRunEnabled } from '../../prerender/context.js';
+import { resolveOutDir } from '../shared/getOutDirs.js';
+import { assert } from '../utils.js';
+import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { getFullBuildInlineConfig } from '../shared/getFullBuildInlineConfig.js';
+function buildApp() {
+    let config;
+    return [
+        {
+            name: 'vike:buildApp',
+            apply: 'build',
+            config(config) {
+                if (!config.vike.config.viteEnvironmentAPI)
+                    return;
+                return {
+                    builder: {
+                        buildApp: async (builder) => {
+                            assert(builder.environments.client);
+                            assert(builder.environments.ssr);
+                            await builder.build(builder.environments.client);
+                            await builder.build(builder.environments.ssr);
+                        }
+                    },
+                    environments: {
+                        ssr: {
+                            consumer: 'server',
+                            build: {
+                                outDir: resolveOutDir(config, true),
+                                ssr: true
+                            }
+                        },
+                        client: {
+                            consumer: 'client',
+                            build: {
+                                copyPublicDir: true,
+                                ssr: false
+                            }
+                        }
+                    }
+                };
+            }
+        },
+        {
+            name: 'vike:buildApp:prerender',
+            apply: 'build',
+            enforce: 'pre',
+            applyToEnvironment(env) {
+                return env.name === 'ssr';
+            },
+            configResolved(_config) {
+                config = _config;
+            },
+            async writeBundle() {
+                if (!config.vike.config.viteEnvironmentAPI)
+                    return;
+                const vikeConfig = await getVikeConfig(config);
+                if (!isPrerenderAutoRunEnabled(vikeConfig))
+                    return;
+                const configInline = getFullBuildInlineConfig(config);
+                const { forceExit } = await runPrerenderFromAutoRun(configInline, config);
+                if (forceExit) {
+                    runPrerender_forceExit();
+                    assert(false);
+                }
+            }
+        }
+    ];
+}

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.d.ts

@@ -2,7 +2,6 @@ export { fixServerAssets };
 export { fixServerAssets_isEnabled };
 export { fixServerAssets_assertCssCodeSplit };
 export { fixServerAssets_assertCssTarget };
-export { fixServerAssets_assertCssTarget_populate };
 import { ViteManifest } from '../../../shared/ViteManifest.js';
 import { ResolvedConfig } from 'vite';
 /**
@@ -18,5 +17,4 @@ declare function fixServerAssets(config: ResolvedConfig): Promise<{
     serverManifestMod: ViteManifest;
 }>;
 declare function fixServerAssets_assertCssCodeSplit(config: ResolvedConfig): void;
-declare function fixServerAssets_assertCssTarget_populate(config: ResolvedConfig): void;
 declare function fixServerAssets_assertCssTarget(config: ResolvedConfig): Promise<void>;

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.js

@@ -2,7 +2,6 @@ export { fixServerAssets };
 export { fixServerAssets_isEnabled };
 export { fixServerAssets_assertCssCodeSplit };
 export { fixServerAssets_assertCssTarget };
-export { fixServerAssets_assertCssTarget_populate };
 import fs from 'fs/promises';
 import fs_sync from 'fs';
 import path from 'path';
@@ -195,17 +194,15 @@ function fixServerAssets_assertCssCodeSplit(config) {
     assertWarning(config.build.cssCodeSplit, `${pc.cyan('build.cssCodeSplit')} shouldn't be set to ${pc.cyan('false')} (https://github.com/vikejs/vike/issues/1993)`, { onlyOnce: true });
 }
 const targets = [];
-function fixServerAssets_assertCssTarget_populate(config) {
-    const isServerSide = viteIsSSR(config);
-    assert(typeof isServerSide === 'boolean');
-    assert(config.build.target !== undefined);
-    targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
-}
 async function fixServerAssets_assertCssTarget(config) {
     if (!fixServerAssets_isEnabled())
         return;
     if (!(await isV1Design(config)))
         return;
+    const isServerSide = viteIsSSR(config);
+    assert(typeof isServerSide === 'boolean');
+    assert(config.build.target !== undefined);
+    targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
     const targetsServer = targets.filter((t) => t.isServerSide);
     const targetsClient = targets.filter((t) => !t.isServerSide);
     targetsClient.forEach((targetClient) => {
@@ -213,9 +210,10 @@ async function fixServerAssets_assertCssTarget(config) {
         targetsServer.forEach((targetServer) => {
             const targetCssResolvedServer = resolveCssTarget(targetServer);
             assertWarning(isEqualStringList(targetCssResolvedClient, targetCssResolvedServer), [
-                'The CSS browser target should be the same for both client-side and server-side (https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979) but we got:',
-                `Client-side: ${pc.cyan(JSON.stringify(targetCssResolvedClient))}`,
-                `Server-side: ${pc.cyan(JSON.stringify(targetCssResolvedServer))}`
+                'The CSS browser target should be the same for both client and server, but we got:',
+                `Client: ${pc.cyan(JSON.stringify(targetCssResolvedClient))}`,
+                `Server: ${pc.cyan(JSON.stringify(targetCssResolvedServer))}`,
+                `Different targets leads to CSS duplication, see ${pc.underline('https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979')} for more information.`
             ].join('\n'), {
                 showStackTrace: true,
                 onlyOnce: 'different-css-target'

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -10,7 +10,7 @@ import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { createRequire } from 'module';
 import fs from 'fs/promises';
 import path from 'path';
-import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_assertCssTarget_populate, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
+import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
 import { set_ASSETS_MANIFEST } from './buildEntry/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
@@ -23,7 +23,6 @@ const require_ = createRequire(importMetaUrl);
 const manifestTempFile = '_temp_manifest.json';
 function buildConfig() {
     let isServerAssetsFixEnabled;
-    let isSsrBuild;
     let outDirs;
     let config;
     return [
@@ -49,7 +48,6 @@ function buildConfig() {
                             config.build.ssrEmitAssets = true;
                             // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
                             config.build.cssMinify = 'esbuild';
-                            fixServerAssets_assertCssTarget_populate(config);
                             fixServerAssets_assertCssCodeSplit(config);
                         }
                     }
@@ -59,12 +57,14 @@ function buildConfig() {
                 order: 'post',
                 handler(config) {
                     onSetupBuild();
-                    isSsrBuild = viteIsSSR(config);
                     return {
                         build: {
                             outDir: resolveOutDir(config),
                             manifest: manifestTempFile,
-                            copyPublicDir: !isSsrBuild
+                            copyPublicDir: config.vike.config.viteEnvironmentAPI
+                                ? // Already set by buildApp() plugin
+                                    undefined
+                                : !viteIsSSR(config)
                         }
                     };
                 }
@@ -88,7 +88,7 @@ function buildConfig() {
                 order: 'pre',
                 sequential: true,
                 async handler(options, bundle) {
-                    if (isSsrBuild) {
+                    if (viteIsSSR(config)) {
                         // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
                         //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
                         //  - We'll able to do so once we replace `$ vite build` with `$ vike build`

package/dist/esm/node/plugin/plugins/buildEntry/index.js

@@ -42,14 +42,14 @@ function getServerProductionEntryCode(config) {
     // After the old design is removed, let's maybe simplify and move everything into a single virtual module
     const importerCode = [
         `  import { setGlobalContext_buildEntry } from '${importPath}';`,
-        `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
+        `  import * as virtualFileExports from '${virtualFileIdImportUserCodeServer}';`,
         `  {`,
         // Because of a Rollup bug, we have to assign ASSETS_MANIFEST to a variable before passing it to setGlobalContext_buildEntry()
         // - This workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
         `    const assetsManifest = ${ASSETS_MANIFEST};`,
         `    const buildInfo = ${JSON.stringify(buildInfo, null, 2)};`,
         '    setGlobalContext_buildEntry({',
-        `      pageFiles,`,
+        `      virtualFileExports,`,
         `      assetsManifest,`,
         `      buildInfo,`,
         '    });',

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -10,7 +10,7 @@ declare module 'vite' {
         _baseViteOriginal?: string;
         _viteConfigEnhanced?: InlineConfig;
         vike?: {
-            global: VikeConfigObject['global'];
+            config: VikeConfigObject['global']['config'];
             prerenderContext?: PrerenderContextPublic;
         };
     }

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

@@ -30,7 +30,7 @@ function commonConfig(vikeVitePluginOptions) {
                         _isDev: isDev,
                         _root: root,
                         _vikeVitePluginOptions: vikeVitePluginOptions,
-                        vike: { global: vikeConfig.global },
+                        vike: { config: vikeConfig.global.config },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
                             prerender: isPrerenderEnabled(vikeConfig)