vike 0.4.267-commit-b005535 → 0.4.267-commit-5676e14

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

@@ -5,14 +5,12 @@ import { assert, assertWarning } from '../../../../utils/assert.js';
 import { onSetupBuild } from '../../../../utils/assertSetup.js';
 import { getGlobalObject } from '../../../../utils/getGlobalObject.js';
 import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
-import { isViteCli, getViteBuildCliArgs } from '../../shared/isViteCli.js';
+import { isViteCli, getViteCliArgs } from '../../shared/isViteCli.js';
 import pc from '@brillout/picocolors';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { isVikeCliOrApi } from '../../../../shared-server-node/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';
 import { logErrorServer } from '../../../../server/runtime/logErrorServer.js';
 import '../../assertEnvVite.js';
 const globalObject = getGlobalObject('build/pluginBuildApp.ts', {
@@ -20,7 +18,6 @@ const globalObject = getGlobalObject('build/pluginBuildApp.ts', {
 });
 function pluginBuildApp() {
     let config;
-    let alreadyBuilt = false;
     return [
         {
             name: 'vike:build:pluginBuildApp:pre',
@@ -33,18 +30,15 @@ function pluginBuildApp() {
                         builder: {
                             // Can be overridden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
                             async buildApp(builder) {
-                                if (alreadyBuilt)
-                                    return;
-                                alreadyBuilt = true;
                                 assert(builder.environments.client);
                                 assert(builder.environments.ssr);
+                                // The additional environments (e.g. `rsc`)
+                                const { _additionalEnvironmentNames: additionalEnvironmentNames } = await getVikeConfigInternal();
+                                for (const name of additionalEnvironmentNames) {
+                                    await builder.build(builder.environments[name]);
+                                }
                                 await builder.build(builder.environments.client);
                                 await builder.build(builder.environments.ssr);
-                                if (isPrerenderForceExit()) {
-                                    await builder.buildApp();
-                                    runPrerender_forceExit();
-                                    assert(false);
-                                }
                             },
                         },
                     };
@@ -88,8 +82,14 @@ function pluginBuildApp() {
                     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() ?
+            // Pre-render after all builds, e.g. after @vitejs/plugin-rsc moved its `rsc` build back into dist/server/
+            // - Before the `order: 'post'` buildApp() hooks of non-`enforce: 'pre'` plugins, e.g. vite-plugin-vercel copies dist/client/
+            buildApp: {
+                order: 'post',
+                async handler(builder) {
+                    await triggerPrerendering(builder.config);
+                },
+            },
             writeBundle: {
                 /* We can't use this because it breaks Vite's logging. TO-DO/eventually: try again with latest Vite version.
                 sequential: true,
@@ -99,7 +99,6 @@ function pluginBuildApp() {
                     try {
                         handleAssetsManifest_assertUsageCssTarget(config, this.environment);
                         await handleAssetsManifest(config, this.environment, options, bundle);
-                        await triggerPrerendering(config, this.environment, bundle);
                     }
                     catch (err) {
                         // We use try-catch also because:
@@ -115,6 +114,14 @@ function pluginBuildApp() {
             name: 'vike:build:pluginBuildApp:autoFullBuild:post',
             apply: 'build',
             enforce: 'post',
+            // After the buildApp() hooks of other plugins, e.g. vite-plugin-vercel
+            buildApp: {
+                order: 'post',
+                async handler() {
+                    if (isPrerenderForceExit())
+                        runPrerender_forceExit();
+                },
+            },
             closeBundle: {
                 sequential: true,
                 order: 'post',
@@ -125,18 +132,10 @@ function pluginBuildApp() {
         },
     ];
 }
-async function triggerPrerendering(config, viteEnv, bundle) {
+async function triggerPrerendering(config) {
     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;
     if (!(await isPrerenderAutoRunEnabled(vikeConfig)))
         return;
     const configInline = getFullBuildInlineConfig(config);
@@ -146,7 +145,7 @@ async function triggerPrerendering(config, viteEnv, bundle) {
 }
 async function abortViteBuildSsr() {
     const vikeConfig = await getVikeConfigInternal();
-    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCli() && getViteBuildCliArgs()?.build.ssr) {
+    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCli() && getViteCliArgs()?.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);
     }
@@ -165,7 +164,7 @@ function isPrerenderForceExit() {
     return globalObject.forceExit;
 }
 function getFullBuildInlineConfig(config) {
-    const configFromCli = !isViteCli() ? null : getViteBuildCliArgs();
+    const configFromCli = !isViteCli() ? null : getViteCliArgs();
     if (config._viteConfigUser) {
         return config._viteConfigUser;
     }

package/dist/node/vite/plugins/build/pluginBuildConfig.d.ts

@@ -1,7 +1,7 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import type { ResolvedConfig, Plugin } from 'vite';
+import type { ResolvedConfig, Plugin, Rollup } from 'vite';
 import type { PageConfigBuildTime } from '../../../../types/PageConfig.js';
 import type { FilePath } from '../../../../types/FilePath.js';
 import '../../assertEnvVite.js';
@@ -15,4 +15,4 @@ declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config
     hasServerRouting: boolean;
     clientEntries: Record<string, ClientEntry>;
 };
-declare function assertRollupInput(config: ResolvedConfig): void;
+declare function assertRollupInput(input: Rollup.InputOption | undefined): void;

package/dist/node/vite/plugins/build/pluginBuildConfig.js

@@ -16,7 +16,7 @@ import { extractAssetsAddQuery } from '../../../../shared-server-node/extractAss
 import { prependEntriesDir } from '../../../../shared-server-node/prependEntriesDir.js';
 import { getFilePathResolved, getFilePathUnresolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared-server-client/page-configs/getConfigValueBuildTime.js';
-import { isViteServerSide_viteEnvOptional } from '../../shared/isViteServerSide.js';
+import { isViteServerSide_configEnvironment } from '../../shared/isViteServerSide.js';
 import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest_alignCssTarget, } from './handleAssetsManifest.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../../server/runtime/renderPageServer/getPageAssets/retrievePageAssetsProd.js';
 import '../../assertEnvVite.js';
@@ -31,10 +31,18 @@ function pluginBuildConfig() {
                 async handler(config) {
                     handleAssetsManifest_alignCssTarget(config);
                     onSetupBuild();
-                    assertRollupInput(config);
-                    const entries = await getEntries(config);
-                    assert(Object.keys(entries).length > 0);
-                    config.build.rollupOptions.input = injectRollupInputs(entries, config);
+                    const { _additionalEnvironmentNames: additionalEnvironmentNames } = await getVikeConfigInternal();
+                    const entriesClient = await getEntries(config, false);
+                    const entriesServer = await getEntries(config, true);
+                    for (const [envName, envConfig] of Object.entries(config.environments)) {
+                        // Additional environments (e.g. `rsc`) only get Vike's `entry-environment.mjs`, see pluginEnvironmentEntries.ts
+                        if (additionalEnvironmentNames.includes(envName))
+                            continue;
+                        const entries = isViteServerSide_configEnvironment(envName, envConfig) ? entriesServer : entriesClient;
+                        assert(Object.keys(entries).length > 0);
+                        assertRollupInput(envConfig.build.rollupOptions.input);
+                        envConfig.build.rollupOptions.input = injectRollupInputs(entries, envConfig.build.rollupOptions.input);
+                    }
                     addLogHook();
                     handleAssetsManifest_assertUsageCssCodeSplit(config);
                 },
@@ -55,13 +63,13 @@ function pluginBuildConfig() {
         },
     ];
 }
-async function getEntries(config) {
+async function getEntries(config, isServerSide) {
     const vikeConfig = await getVikeConfigInternal();
     const { _pageConfigs: pageConfigs } = vikeConfig;
     // TO-DO/next-major-release: remove
-    const pageFileEntries = await getPageFileEntries(config, resolveIncludeAssetsImportedByServer(vikeConfig.config));
+    const pageFileEntries = await getPageFileEntries(config, resolveIncludeAssetsImportedByServer(vikeConfig.config), isServerSide);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
-    if (isViteServerSide_viteEnvOptional(config)) {
+    if (isServerSide) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
             ...pageFileEntries,
@@ -94,7 +102,7 @@ async function getEntries(config) {
 function getPageEntries(pageConfigs) {
     const pageEntries = {};
     pageConfigs.forEach((pageConfig) => {
-        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
+        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, 'server');
         pageEntries[entryName] = entryTarget;
     });
     return pageEntries;
@@ -114,7 +122,7 @@ function analyzeClientEntries(pageConfigs, config) {
         }
         {
             // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
-            const { entryName, entryTarget, entryFilePath } = getEntryFromPageConfig(pageConfig, true);
+            const { entryName, entryTarget, entryFilePath } = getEntryFromPageConfig(pageConfig, 'client');
             clientEntries[entryName] = { entryTarget, entryFilePath };
         }
         {
@@ -133,8 +141,8 @@ 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_viteEnvOptional(config);
+async function getPageFileEntries(config, includeAssetsImportedByServer, isServerSide) {
+    const isForClientSide = !isServerSide;
     const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
     if (isForClientSide && includeAssetsImportedByServer) {
         fileTypes.push('.page.server');
@@ -177,9 +185,9 @@ function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
     entryName = prependEntriesDir(entryName);
     return { entryName, entryTarget, entryFilePath: filePath };
 }
-function getEntryFromPageConfig(pageConfig, isForClientSide) {
+function getEntryFromPageConfig(pageConfig, environmentName) {
     let { pageId } = pageConfig;
-    const entryTarget = generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide });
+    const entryTarget = generateVirtualFileId({ type: 'page-entry', pageId, environmentName });
     let entryName = pageId;
     // Avoid:
     // ```
@@ -220,8 +228,8 @@ function addLogHook() {
         }
     });
 }
-function assertRollupInput(config) {
-    const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
+function assertRollupInput(input) {
+    const userInputs = normalizeRollupInput(input);
     const htmlInputs = Object.values(userInputs).filter((entry) => entry.endsWith('.html') || entry.endsWith('.htm'));
     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`);

package/dist/node/vite/plugins/build/pluginDistFileNames.js

@@ -12,6 +12,8 @@ import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import { assertModuleId, getFilePathToShowToUserModule } from '../../shared/getFilePath.js';
 import '../../assertEnvVite.js';
 import { isVite8OrAbove } from '../../shared/isVite8OrAbove.js';
+import { isViteServerSide_configEnvironment } from '../../shared/isViteServerSide.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 function pluginDistFileNames() {
     return [
         {
@@ -19,42 +21,65 @@ function pluginDistFileNames() {
             apply: 'build',
             enforce: 'post',
             configResolved: {
-                handler(config) {
-                    const rollupOutputs = getRollupOutputs(config);
-                    // We need to support multiple outputs: @vite/plugin-legacy adds an output, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
-                    rollupOutputs.forEach((rollupOutput) => {
-                        if (!('entryFileNames' in rollupOutput)) {
-                            rollupOutput.entryFileNames = (chunkInfo) => getEntryFileName(chunkInfo, config, true);
-                        }
-                        if (!('chunkFileNames' in rollupOutput)) {
-                            rollupOutput.chunkFileNames = (chunkInfo) => getChunkFileName(chunkInfo, config);
-                        }
-                        if (!('assetFileNames' in rollupOutput)) {
-                            rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config);
-                            rollupOutput.assetFileNames.isTheOneSetByVike = true;
-                            assert(rollupOutput.assetFileNames.isTheOneSetByVike);
-                        }
-                        else {
-                            // If a user needs this:
-                            //  - assertUsage() that the naming provided by the user ends with `.[hash][extname]`
-                            //    - It's needed for getHash() of handleAssetsManifest()
-                            //    - Asset URLs should always contain a hash: it's paramount for caching assets.
-                            //    - If rollupOutput.assetFileNames is a function then use a wrapper function to apply the assertUsage()
-                            assertUsage(rollupOutput.assetFileNames.isTheOneSetByVike, "Setting Vite's configuration build.rollupOptions.output.assetFileNames is currently forbidden. Reach out if you need to use it.");
-                        }
+                async handler(config) {
+                    const { _additionalEnvironmentNames: additionalEnvironmentNames } = await getVikeConfigInternal();
+                    Object.entries(config.environments).forEach(([envName, envConfig]) => {
+                        // Vike doesn't own the builds of additional environments (e.g. `rsc`): it only emits `entry-environment.mjs` there
+                        if (additionalEnvironmentNames.includes(envName))
+                            return;
+                        const { build } = envConfig;
+                        copyRollupOutputs(build);
+                        const isServerSide = isViteServerSide_configEnvironment(envName, envConfig);
+                        setFileNames(config, build, isServerSide, envName);
+                        disableCSSBundling(config, build);
                     });
-                    disableCSSBundling(config);
                 },
             },
         },
     ];
 }
+function setFileNames(config, build, isServerSide, envName) {
+    const rollupOutputs = getRollupOutputs(build);
+    // We need to support multiple outputs: @vite/plugin-legacy adds an output, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
+    rollupOutputs.forEach((rollupOutput) => {
+        // Server environments other than `ssr` keep their own entry file names, e.g. @vitejs/plugin-rsc imports its `rsc` entry as `index.js`
+        if (!('entryFileNames' in rollupOutput) && (!isServerSide || envName === 'ssr')) {
+            rollupOutput.entryFileNames = (chunkInfo) => getEntryFileName(chunkInfo, config, build, isServerSide);
+        }
+        if (!('chunkFileNames' in rollupOutput)) {
+            rollupOutput.chunkFileNames = (chunkInfo) => getChunkFileName(chunkInfo, build, isServerSide);
+        }
+        if (!('assetFileNames' in rollupOutput)) {
+            rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config, build);
+            rollupOutput.assetFileNames.isTheOneSetByVike = true;
+            assert(rollupOutput.assetFileNames.isTheOneSetByVike);
+        }
+        else {
+            // If a user needs this:
+            //  - assertUsage() that the naming provided by the user ends with `.[hash][extname]`
+            //    - It's needed for getHash() of handleAssetsManifest()
+            //    - Asset URLs should always contain a hash: it's paramount for caching assets.
+            //    - If rollupOutput.assetFileNames is a function then use a wrapper function to apply the assertUsage()
+            assertUsage(rollupOutput.assetFileNames.isTheOneSetByVike, "Setting Vite's configuration build.rollupOptions.output.assetFileNames is currently forbidden. Reach out if you need to use it.");
+        }
+    });
+}
+// Vike sets entryFileNames/chunkFileNames/assetFileNames on an output object only if the user didn't set them. But the user's output object can be:
+// - The same object for several environments.
+// - Reused across Vite's config resolutions, e.g. an inline config such as VITE_CONFIG.
+// Without a copy, the file names Vike sets for one environment look user-set to the next environment, which then keeps the wrong environment's file names.
+function copyRollupOutputs(build) {
+    const { output } = build.rollupOptions;
+    if (!output)
+        return;
+    build.rollupOptions.output = isArray(output) ? output.map((o) => ({ ...o })) : { ...output };
+}
 function getIdHash(id) {
     return crypto.createHash('md5').update(id).digest('hex').slice(0, 8);
 }
-function getAssetFileName(assetInfo, config) {
+function getAssetFileName(assetInfo, config, build) {
     const userRootDir = config.root;
-    const assetsDir = getAssetsDir(config);
+    const assetsDir = getAssetsDir(build);
     const dir = assetsDir + '/static';
     let { name } = assetInfo;
     if (!name) {
@@ -78,19 +103,19 @@ function getAssetFileName(assetInfo, config) {
     name = clean(name, userRootDir);
     return `${dir}/${name}.[hash][extname]`;
 }
-function getChunkFileName(_chunkInfo, config) {
-    const isForClientSide = !config.build.ssr;
+function getChunkFileName(_chunkInfo, build, isServerSide) {
+    const isForClientSide = !isServerSide;
     let name = 'chunks/chunk-[hash].js';
     if (isForClientSide) {
-        const assetsDir = getAssetsDir(config);
+        const assetsDir = getAssetsDir(build);
         name = `${assetsDir}/${name}`;
     }
     return name;
 }
-function getEntryFileName(chunkInfo, config, isEntry) {
+function getEntryFileName(chunkInfo, config, build, isServerSide) {
     const userRootDir = config.root;
-    const assetsDir = getAssetsDir(config);
-    const isForClientSide = !config.build.ssr;
+    const assetsDir = getAssetsDir(build);
+    const isForClientSide = !isServerSide;
     let { name } = chunkInfo;
     assertPosixPath(name);
     name = clean(name, userRootDir, true, 
@@ -100,7 +125,7 @@ function getEntryFileName(chunkInfo, config, isEntry) {
         return `${assetsDir}/${name}.[hash].js`;
     }
     else {
-        return `${name}.${isEntry ? 'mjs' : 'js'}`;
+        return `${name}.mjs`;
     }
 }
 function removePathSeparators(name) {
@@ -188,9 +213,9 @@ function workaroundGlob(name) {
     return name;
 }
 // Workaround for Vite CSS duplication bug: https://github.com/vikejs/vike/issues/1815
-function disableCSSBundling(config) {
+function disableCSSBundling(config, build) {
     if (isVite8OrAbove(config)) {
-        for (const output of getRolldownOutputs(config)) {
+        for (const output of getRolldownOutputs(build)) {
             assert(output);
             const { codeSplitting } = output;
             // `codeSplitting: false` => single-bundle mode; respect the user's choice.
@@ -219,7 +244,7 @@ function disableCSSBundling(config) {
         }
     }
     else {
-        for (const output of getRollupOutputs(config)) {
+        for (const output of getRollupOutputs(build)) {
             assert(output);
             wrapManualChunks(output, config, 'rollupOptions');
         }
@@ -291,28 +316,23 @@ function getCssChunkName(id, config) {
         return `${name}-${hash}`;
     }
 }
-function getRollupOutputs(config) {
-    var _a, _b;
-    // @ts-expect-error is read-only
-    config.build ?? (config.build = {});
-    (_a = config.build).rollupOptions ?? (_a.rollupOptions = {});
-    (_b = config.build.rollupOptions).output ?? (_b.output = {});
-    const { output } = config.build.rollupOptions;
+function getRollupOutputs(build) {
+    var _a;
+    (_a = build.rollupOptions).output ?? (_a.output = {});
+    const { output } = build.rollupOptions;
     if (!isArray(output)) {
         return [output];
     }
     return output;
 }
-function getRolldownOutputs(config) {
-    var _a, _b;
-    // @ts-expect-error is read-only
-    config.build ?? (config.build = {});
+function getRolldownOutputs(build) {
+    var _a;
     // @ts-ignore
-    (_a = config.build).rolldownOptions ?? (_a.rolldownOptions = {});
+    build.rolldownOptions ?? (build.rolldownOptions = {});
     // @ts-ignore
-    (_b = config.build.rolldownOptions).output ?? (_b.output = {});
+    (_a = build.rolldownOptions).output ?? (_a.output = {});
     // @ts-ignore
-    const { output } = config.build.rolldownOptions;
+    const { output } = build.rolldownOptions;
     if (!isArray(output)) {
         return [output];
     }

package/dist/node/vite/plugins/build/pluginEnvironmentEntries.d.ts

@@ -0,0 +1,6 @@
+export { pluginEnvironmentEntries };
+export { getEnvironmentEntryPlaceholder };
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+declare function pluginEnvironmentEntries(): Plugin[];
+declare function getEnvironmentEntryPlaceholder(environmentName: string): string;

package/dist/node/vite/plugins/build/pluginEnvironmentEntries.js

@@ -0,0 +1,71 @@
+export { pluginEnvironmentEntries };
+export { getEnvironmentEntryPlaceholder };
+// Vike's server environment imports the global entry of every additional environment (e.g. `rsc`), see loadPageContextEnvironments.ts
+// - An additional environment is a separate build, so the server imports its entry by a path relative to the importing chunk, which is known only after chunking (the same marker + renderChunk() as @vitejs/plugin-rsc's import.meta.viteRsc.loadModule())
+import { assertUsage } from '../../../../utils/assert.js';
+import { generateVirtualFileIdAdditionalEnvironment } from '../../../../shared-server-node/virtualFileId.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { getMagicString } from '../../shared/getMagicString.js';
+import path from 'node:path';
+import '../../assertEnvVite.js';
+const environmentEntryFileName = 'entry-environment.mjs';
+const environmentEntryPlaceholder = '__VIKE_ENVIRONMENT_ENTRY__';
+const environmentEntryPlaceholderRegex = new RegExp(`(["'\`])${environmentEntryPlaceholder}:(.+?)\\1`, 'g');
+function pluginEnvironmentEntries() {
+    return [
+        {
+            name: 'vike:build:emitEnvironmentEntry',
+            apply: 'build',
+            buildStart: {
+                async handler() {
+                    const { name, config } = this.environment;
+                    const { _additionalEnvironmentNames: additionalEnvironmentNames } = await getVikeConfigInternal();
+                    if (!additionalEnvironmentNames.includes(name))
+                        return;
+                    assertUsage(config.consumer === 'server', `The Vike environment ${name} should be a server-side Vite environment`);
+                    this.emitFile({
+                        type: 'chunk',
+                        id: generateVirtualFileIdAdditionalEnvironment(name),
+                        fileName: environmentEntryFileName,
+                    });
+                },
+            },
+        },
+        {
+            name: 'vike:build:linkEnvironmentEntries',
+            apply: 'build',
+            resolveId: {
+                filter: { id: new RegExp(`^${environmentEntryPlaceholder}:`) },
+                handler(id) {
+                    return { id, external: true };
+                },
+            },
+            renderChunk: {
+                handler(code, chunk) {
+                    return replaceEnvironmentEntryPlaceholders(code, chunk.fileName, this.environment);
+                },
+            },
+        },
+    ];
+}
+// The import specifier of the environment's entry, replaced by its relative path once the importer's location is known
+function getEnvironmentEntryPlaceholder(environmentName) {
+    return `${environmentEntryPlaceholder}:${environmentName}`;
+}
+// Replace each placeholder with the path of the environment's entry, relative to the chunk
+function replaceEnvironmentEntryPlaceholders(code, chunkFileName, environment) {
+    if (!code.includes(environmentEntryPlaceholder))
+        return;
+    const { config } = environment;
+    const chunkDir = path.dirname(path.resolve(config.root, config.build.outDir, chunkFileName));
+    const { magicString, getMagicStringResult } = getMagicString(code, chunkFileName);
+    for (const match of code.matchAll(environmentEntryPlaceholderRegex)) {
+        const outDir = config.environments[match[2]].build.outDir;
+        const environmentEntry = path.resolve(config.root, outDir, environmentEntryFileName);
+        let importPath = path.relative(chunkDir, environmentEntry).split(path.sep).join('/');
+        if (!importPath.startsWith('.'))
+            importPath = `./${importPath}`;
+        magicString.overwrite(match.index, match.index + match[0].length, JSON.stringify(importPath));
+    }
+    return getMagicStringResult();
+}

package/dist/node/vite/plugins/build/pluginSuppressRollupWarning.js

@@ -9,23 +9,25 @@ function pluginSuppressRollupWarning() {
             enforce: 'post',
             configResolved: {
                 async handler(config) {
-                    const onWarnOriginal = config.build.rollupOptions.onwarn;
-                    config.build.rollupOptions.onwarn = function (warning, warn) {
-                        // Suppress
-                        if (suppressUnusedImport(warning))
-                            return;
-                        if (suppressEmptyBundle(warning))
-                            return;
-                        if (suppressUseClientDirective(warning))
-                            return;
-                        // Pass through
-                        if (onWarnOriginal) {
-                            onWarnOriginal.apply(this, arguments);
-                        }
-                        else {
-                            warn(warning);
-                        }
-                    };
+                    Object.values(config.environments).forEach(({ build }) => {
+                        const onWarnOriginal = build.rollupOptions.onwarn;
+                        build.rollupOptions.onwarn = function (warning, warn) {
+                            // Suppress
+                            if (suppressUnusedImport(warning))
+                                return;
+                            if (suppressEmptyBundle(warning))
+                                return;
+                            if (suppressUseClientDirective(warning))
+                                return;
+                            // Pass through
+                            if (onWarnOriginal) {
+                                onWarnOriginal.apply(this, arguments);
+                            }
+                            else {
+                                warn(warning);
+                            }
+                        };
+                    });
                 },
             },
         },

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

@@ -8,11 +8,11 @@ import { isObject } from '../../../utils/isObject.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import pc from '@brillout/picocolors';
 import { assertResolveAlias } from './pluginCommon/assertResolveAlias.js';
-import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVikeConfigInternal.js';
+import { getVikeConfigInternal, setVikeConfigContext, setViteEnvironmentNames, } from '../shared/resolveVikeConfigInternal.js';
 import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigUser.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 import { resolvePrerenderConfigGlobal, isDistServerRemoved } from '../../prerender/resolvePrerenderConfig.js';
-import { version as viteVersionVike } from 'vite';
+import { assertViteVersion } from '../../../utils/assertViteVersion.js';
 import '../assertEnvVite.js';
 const pluginName = 'vike:pluginCommon';
 globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
@@ -24,7 +24,9 @@ function pluginCommon(vikeVitePluginOptions) {
             config: {
                 order: 'pre',
                 async handler(configFromUser, env) {
-                    const viteVersionUser = this?.meta?.viteVersion; // is `undefined` on old Vite versions
+                    // `this` is `undefined` on Vite 6 or older
+                    const viteVersion = this?.meta.viteVersion;
+                    assertViteVersion(viteVersion);
                     const isDev = isDevCheck(env);
                     const isBuild = env.command === 'build';
                     const isPreview = env.isPreview;
@@ -38,7 +40,7 @@ function pluginCommon(vikeVitePluginOptions) {
                     const vikeConfig = await getVikeConfigInternal();
                     return {
                         _isDev: isDev,
-                        _viteVersionResolved: viteVersionUser || viteVersionVike,
+                        _viteVersionResolved: viteVersion,
                         _rootResolvedEarly: rootResolvedEarly,
                         // TO-DO/next-major-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
@@ -52,9 +54,10 @@ function pluginCommon(vikeVitePluginOptions) {
         {
             name: pluginName,
             configResolved: {
-                handler(config) {
+                async handler(config) {
                     assertViteRoot(config._rootResolvedEarly, config);
                     assertSingleInstance(config);
+                    await setViteEnvironmentNames(Object.keys(config.environments));
                 },
             },
         },
@@ -72,7 +75,7 @@ function pluginCommon(vikeVitePluginOptions) {
                     overrideViteDefaultSsrExternal(config)
                     //*/
                     workaroundCI(config);
-                    assertRollupInput(config);
+                    assertRollupInput(config.build.rollupOptions.input);
                     assertResolveAlias(config);
                     temp_supportOldInterface(config);
                     await emitServerEntryOnlyIfNeeded(config);

package/dist/node/vite/plugins/pluginDev/optimizeDeps.js

@@ -191,7 +191,7 @@ async function getPageDeps(config, pageConfigs, pageConfigGlobal) {
             [...pageConfigs, pageConfigGlobal].forEach((pageConfig) => {
                 Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
                     const runtimeEnv = {
-                        isForClientSide,
+                        environmentName: isForClientSide ? 'client' : 'server',
                         isDev: true,
                         // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
                         isClientRouting: true,

package/dist/node/vite/plugins/pluginReplaceConstantsGlobalThis.js

@@ -16,7 +16,10 @@ const filterRolldown = {
         include: new RegExp(escapeRegex(VIRTUAL_FILE_ID_constantsGlobalThis)),
     },
 };
-const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
+const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis ||
+    // Vite re-resolves the resolved ID and its URL when a plugin adds the module as a watch file (@vitejs/plugin-rsc)
+    id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis) ||
+    id === `/@id/__x00__${VIRTUAL_FILE_ID_constantsGlobalThis}`;
 // ===
 function pluginReplaceConstantsGlobalThis() {
     let config;
@@ -63,9 +66,8 @@ function pluginReplaceConstantsGlobalThis() {
             resolveId: {
                 filter: filterRolldown,
                 handler(id) {
-                    assert(filterFunction(id));
-                    assert(id === VIRTUAL_FILE_ID_constantsGlobalThis);
-                    return addVirtualFileIdPrefix(id);
+                    assert(filterFunction(id), { id });
+                    return addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
                 },
             },
             load: {