vike 0.4.237-commit-2d6f480 → 0.4.237-commit-2c1db32

package/dist/cjs/node/vite/shared/isViteServerSide.js

@@ -2,57 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isViteServerSide = isViteServerSide;
 exports.isViteClientSide = isViteClientSide;
-exports.isViteServerSide_withoutEnv = isViteServerSide_withoutEnv;
+exports.isViteServerSide_viteEnvOptional = isViteServerSide_viteEnvOptional;
 exports.isViteServerSide_onlySsrEnv = isViteServerSide_onlySsrEnv;
 exports.isViteServerSide_extraSafe = isViteServerSide_extraSafe;
 const assert_js_1 = require("../../../utils/assert.js");
 function isViteServerSide_impl(configGlobal, viteEnv) {
     (0, assert_js_1.assert)(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
-    const isServerSide1 = !viteEnv?.config.consumer ? null : viteEnv.config.consumer !== 'client';
-    const isServerSide2 = !viteEnv?.config.build ? null : getBuildSsrValue(viteEnv.config.build.ssr);
-    const isServerSide3 = !configGlobal.build ? null : getBuildSsrValue(configGlobal.build.ssr);
-    const isServerSide4 = viteEnv?.name === 'ssr' ? true : viteEnv?.name === 'client' ? false : null;
     const debug = {
         viteEnvIsUndefined: !viteEnv,
         viteEnvName: viteEnv?.name ?? null,
         viteEnvConsumer: viteEnv?.config.consumer ?? null,
         configEnvBuildSsr: viteEnv?.config.build?.ssr ?? null,
         configGlobalBuildSsr: configGlobal.build?.ssr ?? null,
-        isServerSide1,
-        isServerSide2,
-        isServerSide3,
-        isServerSide4,
     };
-    if (isServerSide1 !== null) {
-        // assert(isServerSide1 === isServerSide4 || isServerSide4 === null, debug)
-        /* This assertion can fail, seems to be a Vite bug?
-        assert(isServerSide1 === isServerSide2, debug)
-        */
-        return isServerSide1;
-    }
-    if (isServerSide2 !== null) {
-        // assert(isServerSide2 === isServerSide4 || isServerSide4 === null, debug)
-        return isServerSide2;
-    }
-    if (isServerSide3 !== null) {
-        // assert(isServerSide3 === isServerSide4 || isServerSide4 === null, debug)
-        return isServerSide3;
+    if (!viteEnv) {
+        const isServerSide = getBuildSsrValue(configGlobal.build?.ssr);
+        (0, assert_js_1.assert)(typeof isServerSide === 'boolean', debug);
+        return isServerSide;
     }
-    if (isServerSide4 !== null) {
-        return isServerSide4;
+    else {
+        const isServerSide1 = !viteEnv.config.consumer ? null : viteEnv.config.consumer !== 'client';
+        const isServerSide2 = getBuildSsrValue(viteEnv.config.build?.ssr);
+        const isServerSide3 = viteEnv.name === 'ssr' ? true : viteEnv.name === 'client' ? false : null;
+        const isServerSide = isServerSide1 ?? isServerSide2;
+        (0, assert_js_1.assert)(isServerSide === isServerSide1 || isServerSide1 === null, debug);
+        (0, assert_js_1.assert)(isServerSide === isServerSide2 || isServerSide2 === null, debug);
+        (0, assert_js_1.assert)(isServerSide === isServerSide3 || isServerSide3 === null, debug);
+        (0, assert_js_1.assert)(isServerSide !== null);
+        return isServerSide;
     }
-    (0, assert_js_1.assert)(!viteEnv);
-    return !!configGlobal.build?.ssr;
 }
 function getBuildSsrValue(buildSsr) {
     if (buildSsr === undefined)
         return null;
+    (0, assert_js_1.assert)(typeof buildSsr === 'boolean' || typeof buildSsr === 'string');
     return !!buildSsr;
 }
 function isViteServerSide(configGlobal, viteEnv) {
     return isViteServerSide_impl(configGlobal, viteEnv);
 }
-function isViteServerSide_withoutEnv(configGlobal, viteEnv) {
+function isViteServerSide_viteEnvOptional(configGlobal, viteEnv) {
     return isViteServerSide_impl(configGlobal, viteEnv);
 }
 function isViteClientSide(configGlobal, viteEnv) {
@@ -63,37 +52,17 @@ function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
     return viteEnv.name ? viteEnv.name === 'ssr' : isViteServerSide(configGlobal, viteEnv);
 }
 // Vite is quite messy about setting config.build.ssr — for security purposes, we use an extra safe implementation with lots of assertions, which is needed for the .client.js and .server.js guarantee.
-function isViteServerSide_extraSafe(config, options, viteEnv) {
+function isViteServerSide_extraSafe(config, viteEnv, options) {
     const isServerSide = isViteServerSide(config, viteEnv);
     const debug = {
+        isServerSide,
         configCommand: config.command,
-        configBuildSsr: config.build.ssr,
+        configBuildSsr: getBuildSsrValue(config.build.ssr),
         optionsIsUndefined: options === undefined,
-        optionsSsr: options?.ssr,
-        isServerSide,
+        optionsSsr: options?.ssr ?? null,
     };
-    if (true) {
-        const res = options?.ssr;
-        if (typeof res === 'boolean') {
-            (0, assert_js_1.assert)(res === isServerSide, debug);
-            return res;
-        }
-        return isServerSide;
-    }
-    if (config.command === 'build') {
-        const res = config.build.ssr;
-        (0, assert_js_1.assert)(typeof res === 'boolean', debug);
-        (0, assert_js_1.assert)(res === options?.ssr || options?.ssr === undefined, debug);
-        (0, assert_js_1.assert)(res === isServerSide, debug);
-        return res;
-    }
-    else {
-        const res = options?.ssr;
-        (0, assert_js_1.assert)(typeof res === 'boolean', debug);
-        /* This assertion can fail, seems to be a Vite bug? It's very unexpected.
-        if (typeof config.build.ssr === 'boolean') assert(res === config.build.ssr)
-        */
-        (0, assert_js_1.assert)(res === isServerSide, debug);
-        return res;
-    }
+    (0, assert_js_1.assert)(options, debug);
+    (0, assert_js_1.assert)(typeof options.ssr === 'boolean', debug);
+    (0, assert_js_1.assert)(options.ssr === isServerSide, debug);
+    return isServerSide;
 }

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.237-commit-2d6f480';
+exports.PROJECT_VERSION = '0.4.237-commit-2c1db32';

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

@@ -8,7 +8,7 @@ import { createBuilder } from 'vite';
  */
 async function build(options = {}) {
     const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'build');
-    // Pass it to pluginAutoFullBuild()
+    // Pass it to vike:build:pluginBuildApp
     if (viteConfigFromUserEnhanced)
         viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
     const builder = await createBuilder(viteConfigFromUserEnhanced);

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

@@ -33,7 +33,7 @@ async function runPrerenderFromAutoRun(viteConfig) {
         await runPrerender({ viteConfig }, 'auto-run');
     }
     catch (err) {
-        // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+        // Avoid Rollup prefixing the error with [vike:build:pluginBuildApp], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
         console.error(err);
         logErrorHint(err);
         process.exit(1);

package/dist/esm/node/vite/plugins/pluginBuild/handleAssetsManifest.d.ts

@@ -3,12 +3,12 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
-import type { Environment, ResolvedConfig, Rollup, UserConfig } from 'vite';
+import type { Environment, ResolvedConfig, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
-declare function handleAssetsManifest_isFixEnabled(config: ResolvedConfig | UserConfig): boolean;
+declare function handleAssetsManifest_isFixEnabled(): boolean;
 declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
 declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig, env: Environment): void;
-declare function handleAssetsManifest_getBuildConfig(config: UserConfig): Promise<{
+declare function handleAssetsManifest_getBuildConfig(): Promise<{
     readonly ssrEmitAssets: true | undefined;
     readonly cssMinify: "esbuild" | undefined;
     readonly manifest: true;

package/dist/esm/node/vite/plugins/pluginBuild/handleAssetsManifest.js

@@ -21,7 +21,7 @@ const globalObject = getGlobalObject('build/handleAssetsManifest.ts', {
 });
 // true  => use workaround config.build.ssrEmitAssets
 // false => use workaround extractAssets plugin
-function handleAssetsManifest_isFixEnabled(config) {
+function handleAssetsManifest_isFixEnabled() {
     // Allow user to toggle between the two workarounds? E.g. based on https://vike.dev/includeAssetsImportedByServer.
     return isV1Design();
 }
@@ -212,13 +212,13 @@ function getHash(src) {
 }
 // https://github.com/vikejs/vike/issues/1993
 function handleAssetsManifest_assertUsageCssCodeSplit(config) {
-    if (!handleAssetsManifest_isFixEnabled(config))
+    if (!handleAssetsManifest_isFixEnabled())
         return;
     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 handleAssetsManifest_assertUsageCssTarget(config, env) {
-    if (!handleAssetsManifest_isFixEnabled(config))
+    if (!handleAssetsManifest_isFixEnabled())
         return;
     const isServerSide = isViteServerSide(config, env);
     assert(typeof isServerSide === 'boolean');
@@ -279,8 +279,8 @@ async function writeManifestFile(manifest, manifestFilePath) {
     const manifestFileContent = JSON.stringify(manifest, null, 2);
     await fs.writeFile(manifestFilePath, manifestFileContent, 'utf-8');
 }
-async function handleAssetsManifest_getBuildConfig(config) {
-    const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+async function handleAssetsManifest_getBuildConfig() {
+    const isFixEnabled = handleAssetsManifest_isFixEnabled();
     return {
         // https://github.com/vikejs/vike/issues/1339
         ssrEmitAssets: isFixEnabled ? true : undefined,
@@ -288,7 +288,7 @@ async function handleAssetsManifest_getBuildConfig(config) {
         cssMinify: isFixEnabled ? 'esbuild' : undefined,
         manifest: true,
         /* Already set by vike:build:pluginBuildApp
-        copyPublicDir: !isViteServerSide_withoutEnv(config),
+        copyPublicDir: !isViteServerSide_viteEnvOptional(config),
         */
     };
 }
@@ -313,7 +313,7 @@ async function handleAssetsManifest(config, viteEnv, options, bundle) {
     }
 }
 async function writeAssetsManifestFile(assetsJsonFilePath, config) {
-    const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+    const isFixEnabled = handleAssetsManifest_isFixEnabled();
     const clientManifestFilePath = getManifestFilePath(config, true);
     const serverManifestFilePath = getManifestFilePath(config, false);
     if (!isFixEnabled) {

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildApp.d.ts

@@ -1,3 +1,5 @@
 export { pluginBuildApp };
+export { isPrerenderForceExit };
 import type { Plugin } from 'vite';
 declare function pluginBuildApp(): Plugin[];
+declare function isPrerenderForceExit(): boolean;

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

@@ -1,9 +1,23 @@
 export { pluginBuildApp };
+export { isPrerenderForceExit };
 import { runPrerender_forceExit } from '../../../prerender/runPrerenderEntry.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
-import { assert } from '../../utils.js';
-import { isPrerenderForceExit } from './pluginBuildConfig.js';
+import { assert, assertWarning, getGlobalObject, onSetupBuild } from '../../utils.js';
+import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
+import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
+import pc from '@brillout/picocolors';
+import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { isVikeCliOrApi } from '../../../api/context.js';
+import { handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget } from './handleAssetsManifest.js';
+import { isViteServerSide_onlySsrEnv } from '../../shared/isViteServerSide.js';
+import { runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
+import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
+const globalObject = getGlobalObject('build/pluginBuildApp.ts', {
+    forceExit: false,
+});
 function pluginBuildApp() {
+    let config;
     return [
         {
             name: 'vike:build:pluginBuildApp:pre',
@@ -55,5 +69,107 @@ function pluginBuildApp() {
                 };
             },
         },
+        {
+            name: 'vike:build:pluginBuildApp:autoFullBuild:pre',
+            apply: 'build',
+            enforce: 'pre',
+            async configResolved(config_) {
+                config = config_;
+                await abortViteBuildSsr();
+            },
+            // TO-DO/eventually: stop using this writeBundle() hack and, instead, use the buildApp() implementation above.
+            // - Could it cause issues if a tool uses the writeBundle() hack together with getVikeConfig() ?
+            writeBundle: {
+                /* We can't use this because it breaks Vite's logging. TO-DO/eventually: try again with latest Vite version.
+                sequential: true,
+                order: 'pre',
+                */
+                async handler(options, bundle) {
+                    try {
+                        await handleAssetsManifest(config, this.environment, options, bundle);
+                        await triggerPrerendering(config, this.environment, bundle);
+                    }
+                    catch (err) {
+                        // We use try-catch also because:
+                        // - Vite/Rollup swallows errors thrown inside the writeBundle() hook. (It doesn't swallow errors thrown inside the first writeBundle() hook while building the client-side, but it does swallow errors thrown inside the second writeBundle() while building the server-side triggered after Vike calls Vite's `build()` API.)
+                        // - Avoid Rollup prefixing the error with [vike:build:pluginBuildApp], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+                        console.error(err);
+                        logErrorHint(err);
+                        process.exit(1);
+                    }
+                },
+            },
+        },
+        {
+            name: 'vike:build:pluginBuildApp:autoFullBuild:post',
+            apply: 'build',
+            enforce: 'post',
+            closeBundle: {
+                sequential: true,
+                order: 'post',
+                handler() {
+                    onSetupBuild();
+                    handleAssetsManifest_assertUsageCssTarget(config, this.environment);
+                    /* Let vike:build:pluginBuildApp force exit
+                    runPrerender_forceExit()
+                    */
+                },
+            },
+        },
     ];
 }
+async function triggerPrerendering(config, viteEnv, bundle) {
+    const vikeConfig = await getVikeConfigInternal();
+    if (!isViteServerSide_onlySsrEnv(config, viteEnv))
+        return;
+    if (isDisabled(vikeConfig))
+        return;
+    // Workaround for @vitejs/plugin-legacy
+    //  - The legacy plugin triggers its own Rollup build for the client-side.
+    //  - The legacy plugin doesn't generate a manifest => we can use that to detect the legacy plugin build.
+    //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
+    if (!bundle[getManifestFilePathRelative(config.build.manifest)])
+        return;
+    const configInline = getFullBuildInlineConfig(config);
+    if (isPrerenderAutoRunEnabled(vikeConfig)) {
+        const res = await runPrerenderFromAutoRun(configInline);
+        globalObject.forceExit = res.forceExit;
+        assert(wasPrerenderRun());
+    }
+}
+async function abortViteBuildSsr() {
+    const vikeConfig = await getVikeConfigInternal();
+    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.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);
+    }
+}
+function isDisabled(vikeConfig) {
+    const { disableAutoFullBuild } = vikeConfig.config;
+    if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
+        const isUserUsingViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        return isUserUsingViteApi;
+    }
+    else {
+        return disableAutoFullBuild;
+    }
+}
+function isPrerenderForceExit() {
+    return globalObject.forceExit;
+}
+function getFullBuildInlineConfig(config) {
+    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
+    if (config._viteConfigFromUserEnhanced) {
+        return config._viteConfigFromUserEnhanced;
+    }
+    else {
+        return {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
+            build: {
+                ...configFromCli?.build,
+            },
+        };
+    }
+}

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.d.ts

@@ -1,8 +1,6 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-export { pluginAutoFullBuild };
-export { isPrerenderForceExit };
 import type { ResolvedConfig, Plugin } from 'vite';
 import type { PageConfigBuildTime } from '../../../../types/PageConfig.js';
 declare function pluginBuildConfig(): Plugin[];
@@ -12,5 +10,3 @@ declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config
     clientEntries: Record<string, string>;
 };
 declare function assertRollupInput(config: ResolvedConfig): void;
-declare function pluginAutoFullBuild(): Plugin[];
-declare function isPrerenderForceExit(): boolean;

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.js

@@ -1,9 +1,7 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-export { pluginAutoFullBuild };
-export { isPrerenderForceExit };
-import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveDistFile, assertWarning, getGlobalObject, } from '../../utils.js';
+import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveDistFile, } from '../../utils.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { generateVirtualFileId } from '../../../shared/virtualFileId.js';
@@ -11,19 +9,9 @@ import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { isViteServerSide_withoutEnv, isViteServerSide_onlySsrEnv } from '../../shared/isViteServerSide.js';
-import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget, } from './handleAssetsManifest.js';
+import { isViteServerSide_viteEnvOptional } from '../../shared/isViteServerSide.js';
+import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, } from './handleAssetsManifest.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
-import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
-import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
-import pc from '@brillout/picocolors';
-import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
-import { isVikeCliOrApi } from '../../../api/context.js';
-import { runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
-import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
-const globalObject = getGlobalObject('build/pluginAutoFullBuild.ts', {
-    forceExit: false,
-});
 function pluginBuildConfig() {
     let config;
     return [
@@ -46,9 +34,9 @@ function pluginBuildConfig() {
             },
             config: {
                 order: 'post',
-                async handler(config) {
+                async handler() {
                     onSetupBuild();
-                    const build = await handleAssetsManifest_getBuildConfig(config);
+                    const build = await handleAssetsManifest_getBuildConfig();
                     return { build };
                 },
             },
@@ -64,7 +52,7 @@ async function getEntries(config) {
     // TO-DO/next-major-release: remove
     const pageFileEntries = await getPageFileEntries(config, resolveIncludeAssetsImportedByServer(vikeConfig.config));
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
-    if (isViteServerSide_withoutEnv(config)) {
+    if (isViteServerSide_viteEnvOptional(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
             ...pageFileEntries,
@@ -137,7 +125,7 @@ function analyzeClientEntries(pageConfigs, config) {
 // Ensure Rollup creates entries for each page file, see https://github.com/vikejs/vike/issues/350
 // (Otherwise the page files may be missing in the client manifest.json)
 async function getPageFileEntries(config, includeAssetsImportedByServer) {
-    const isForClientSide = !isViteServerSide_withoutEnv(config);
+    const isForClientSide = !isViteServerSide_viteEnvOptional(config);
     const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
     if (isForClientSide && includeAssetsImportedByServer) {
         fileTypes.push('.page.server');
@@ -228,108 +216,3 @@ function assertRollupInput(config) {
     const htmlInput = htmlInputs[0];
     assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using Vike, instead follow https://vike.dev/add`);
 }
-function pluginAutoFullBuild() {
-    let config;
-    return [
-        {
-            name: 'vike:build:pluginAutoFullBuild',
-            apply: 'build',
-            enforce: 'pre',
-            async configResolved(config_) {
-                config = config_;
-                await abortViteBuildSsr();
-            },
-            writeBundle: {
-                /* We can't use this because it breaks Vite's logging. TO-DO/eventually: try again with latest Vite version.
-                sequential: true,
-                order: 'pre',
-                */
-                async handler(options, bundle) {
-                    try {
-                        await handleAssetsManifest(config, this.environment, options, bundle);
-                        await triggerPrerendering(config, this.environment, bundle);
-                    }
-                    catch (err) {
-                        // We use try-catch also because:
-                        // - Vite/Rollup swallows errors thrown inside the writeBundle() hook. (It doesn't swallow errors thrown inside the first writeBundle() hook while building the client-side, but it does swallow errors thrown inside the second writeBundle() while building the server-side triggered after Vike calls Vite's `build()` API.)
-                        // - Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
-                        console.error(err);
-                        logErrorHint(err);
-                        process.exit(1);
-                    }
-                },
-            },
-        },
-        {
-            name: 'vike:build:pluginAutoFullBuild:post',
-            apply: 'build',
-            enforce: 'post',
-            closeBundle: {
-                sequential: true,
-                order: 'post',
-                handler() {
-                    onSetupBuild();
-                    handleAssetsManifest_assertUsageCssTarget(config, this.environment);
-                    /* Let vike:build:pluginBuildApp force exit
-                    runPrerender_forceExit()
-                    */
-                },
-            },
-        },
-    ];
-}
-async function triggerPrerendering(config, viteEnv, bundle) {
-    const vikeConfig = await getVikeConfigInternal();
-    if (!isViteServerSide_onlySsrEnv(config, viteEnv))
-        return;
-    if (isDisabled(vikeConfig))
-        return;
-    // Workaround for @vitejs/plugin-legacy
-    //  - The legacy plugin triggers its own Rollup build for the client-side.
-    //  - The legacy plugin doesn't generate a manifest => we can use that to detect the legacy plugin build.
-    //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
-    if (!bundle[getManifestFilePathRelative(config.build.manifest)])
-        return;
-    const configInline = getFullBuildInlineConfig(config);
-    if (isPrerenderAutoRunEnabled(vikeConfig)) {
-        const res = await runPrerenderFromAutoRun(configInline);
-        globalObject.forceExit = res.forceExit;
-        assert(wasPrerenderRun());
-    }
-}
-async function abortViteBuildSsr() {
-    const vikeConfig = await getVikeConfigInternal();
-    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.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);
-    }
-}
-function isDisabled(vikeConfig) {
-    const { disableAutoFullBuild } = vikeConfig.config;
-    if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
-        const isUserUsingViteApi = !isViteCliCall() && !isVikeCliOrApi();
-        return isUserUsingViteApi;
-    }
-    else {
-        return disableAutoFullBuild;
-    }
-}
-function isPrerenderForceExit() {
-    return globalObject.forceExit;
-}
-function getFullBuildInlineConfig(config) {
-    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
-    if (config._viteConfigFromUserEnhanced) {
-        return config._viteConfigFromUserEnhanced;
-    }
-    else {
-        return {
-            ...configFromCli,
-            configFile: configFromCli?.configFile || config.configFile,
-            root: config.root,
-            build: {
-                ...configFromCli?.build,
-            },
-        };
-    }
-}

package/dist/esm/node/vite/plugins/pluginBuild/pluginModuleBanner.js

@@ -16,7 +16,7 @@ function pluginModuleBanner() {
         transform: {
             order: 'post',
             handler(code, id, options) {
-                if (!isViteServerSide_extraSafe(config, options, this.environment) &&
+                if (!isViteServerSide_extraSafe(config, this.environment, options) &&
                     // Inject module banners if user sets `build.minify` to `false` for inspecting dist/client/
                     config.build.minify) {
                     return;

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

@@ -4,13 +4,12 @@ import { pluginDistPackageJsonFile } from './pluginBuild/pluginDistPackageJsonFi
 import { pluginSuppressRollupWarning } from './pluginBuild/pluginSuppressRollupWarning.js';
 import { pluginDistFileNames } from './pluginBuild/pluginDistFileNames.js';
 import { pluginBuildEntry } from './pluginBuild/pluginBuildEntry.js';
-import { pluginBuildConfig, pluginAutoFullBuild } from './pluginBuild/pluginBuildConfig.js';
+import { pluginBuildConfig } from './pluginBuild/pluginBuildConfig.js';
 import { pluginModuleBanner } from './pluginBuild/pluginModuleBanner.js';
 function pluginBuild() {
     return [
         ...pluginBuildConfig(),
         ...pluginBuildApp(),
-        ...pluginAutoFullBuild(),
         ...pluginBuildEntry(),
         pluginDistPackageJsonFile(),
         pluginSuppressRollupWarning(),

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

@@ -36,7 +36,7 @@ function pluginEnvVars() {
             if (!code.includes('import.meta.env.'))
                 return;
             const isBuild = config.command === 'build';
-            const isClientSide = !isViteServerSide_extraSafe(config, options, this.environment);
+            const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
             const { magicString, getMagicStringResult } = getMagicString(code, id);
             // Find & check
             const replacements = Object.entries(envsAll)

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

@@ -45,7 +45,7 @@ function pluginExtractAssets() {
                 }
                 const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
                 assert(includeAssetsImportedByServer);
-                assert(!isViteServerSide_extraSafe(config, options, this.environment));
+                assert(!isViteServerSide_extraSafe(config, this.environment, options));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
@@ -62,7 +62,7 @@ function pluginExtractAssets() {
             //  - Vite's `vite:resolve` plugin; https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
             enforce: 'pre',
             async resolveId(source, importer, options) {
-                if (isViteServerSide_extraSafe(config, options, this.environment)) {
+                if (isViteServerSide_extraSafe(config, this.environment, options)) {
                     // When building for the server, there should never be a `?extractAssets` query
                     assert(!extractAssetsRE.test(source));
                     assert(importer === undefined || !extractAssetsRE.test(importer));
@@ -139,7 +139,7 @@ function pluginExtractAssets() {
             async configResolved(config_) {
                 config = config_;
                 vikeConfig = await getVikeConfigInternal();
-                isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+                isFixEnabled = handleAssetsManifest_isFixEnabled();
                 if (!isFixEnabled) {
                     // https://github.com/vikejs/vike/issues/1060
                     assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');

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

@@ -16,7 +16,7 @@ function pluginExtractExportNames() {
         enforce: 'post',
         async transform(src, id, options) {
             id = normalizeId(id);
-            const isClientSide = !isViteServerSide_extraSafe(config, options, this.environment);
+            const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
             if (extractExportNamesRE.test(id)) {
                 const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
                 debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);

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

@@ -29,7 +29,7 @@ function pluginFileEnv() {
             const importers = Array.from(moduleInfo.importers)
                 .map((m) => m.id)
                 .filter((id) => id !== null);
-            assertFileEnv(id, isViteServerSide_extraSafe(config, options, this.environment), importers, 
+            assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 
             // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
             true);
         },
@@ -41,7 +41,7 @@ function pluginFileEnv() {
                 return;
             if (skip(id))
                 return;
-            const isServerSide = isViteServerSide_extraSafe(config, options, this.environment);
+            const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
             if (!isWrongEnv(id, isServerSide))
                 return;
             const { importers } = this.getModuleInfo(id);

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

@@ -33,7 +33,7 @@ function pluginReplaceConstants() {
             const constantsMap = [];
             constantsMap.push({
                 constants: ['pageContext.isClientSide', 'globalContext.isClientSide', 'pageContext.globalContext.isClientSide'],
-                replacement: !isViteServerSide_extraSafe(config, options, this.environment),
+                replacement: !isViteServerSide_extraSafe(config, this.environment, options),
             });
             constantsMap.forEach(({ constants, replacement }) => {
                 if (!constants.some((c) => code.includes(c)))