vike 0.4.267 → 0.4.268-commit-ca58695

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);
@@ -181,7 +184,7 @@ async function disableAutoImportIfPrerendering(isBuild) {
         return;
     const vikeConfig = await getVikeConfigInternal();
     const prerenderConfigGlobal = await resolvePrerenderConfigGlobal(vikeConfig);
-    if (isDistServerRemoved(prerenderConfigGlobal)) {
+    if (isDistServerRemoved(prerenderConfigGlobal, vikeConfig)) {
         return { vitePluginServerEntry: { disableAutoImport: true } };
     }
 }

package/dist/node/vite/plugins/pluginDev/optimizeDeps.d.ts

@@ -4,12 +4,12 @@ import type { ResolvedConfig } from 'vite';
 import '../../assertEnvVite.js';
 declare const optimizeDeps: {
     readonly optimizeDeps: {
-        readonly exclude: ["vike/client", "vike/client/router"];
+        readonly exclude: ["vike/client", "vike/client/router", "vike/__internal/client"];
         readonly include: ["vike > @brillout/json-serializer/parse", "vike > @brillout/json-serializer/stringify", "vike > @brillout/picocolors"];
     };
     readonly ssr: {
         readonly optimizeDeps: {
-            readonly exclude: ["@brillout/import", "@brillout/json-serializer", "@brillout/vite-plugin-server-entry", "vike"];
+            readonly exclude: ["@brillout/import", "@brillout/json-serializer", "@brillout/vite-plugin-server-entry", "vike", "@universal-middleware/core"];
         };
     };
 };

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

@@ -43,6 +43,8 @@ const optimizeDeps = {
             // We must exclude Vike's client runtime so it can import virtual modules
             'vike/client',
             'vike/client/router',
+            // Also all entries of Vike's client runtime, otherwise pre-bundling an entry would load a second copy of Vike's client code (also problematic as it duplicates module-level variables that don't use `getGlobalObject()`)
+            'vike/__internal/client',
         ],
         include: [
             // Avoid:
@@ -65,6 +67,8 @@ const optimizeDeps = {
                 */
                 '@brillout/vite-plugin-server-entry',
                 'vike',
+                // Needed so that Vike doesn't get the user's @universal-middleware/core version (that might differ from Vike's @universal-middleware/core version). (Vite pre-bundles one copy per package name for every importer: https://github.com/vitejs/vite/issues/9948)
+                '@universal-middleware/core',
             ],
         },
     },
@@ -191,7 +195,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,
@@ -211,7 +215,7 @@ async function getPageDeps(config, pageConfigs, pageConfigGlobal) {
     }
     // V0.4 design
     {
-        const pageFiles = await findPageFiles(config, ['.page', '.page.client'], true);
+        const pageFiles = await findPageFiles(config, ['.page', '.page.client']);
         const userRootDir = config.root;
         pageFiles.forEach((filePathAbsoluteUserRootDir) => {
             const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });

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: {

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerConfig.d.ts

@@ -1,5 +1,6 @@
 export { getServerConfig };
 export { isUniversalDeployVitePreview };
+export { getServerEntryFilePath_ifDev };
 import type { ResolvedConfig } from 'vite';
 import type { VikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import '../../assertEnvVite.js';
@@ -7,5 +8,7 @@ declare function getServerConfig(vikeConfig: VikeConfigInternal): {
     serverEntryId: string;
     serverEntryVike: string;
     serverFilePath: string | null;
+    serverEntryFilePath: string | null;
 } | undefined;
+declare function getServerEntryFilePath_ifDev(vikeConfig: VikeConfigInternal): string | null;
 declare function isUniversalDeployVitePreview(vikeConfig: VikeConfigInternal, viteConfigResolved: ResolvedConfig): boolean | null;

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerConfig.js

@@ -1,5 +1,6 @@
 export { getServerConfig };
 export { isUniversalDeployVitePreview };
+export { getServerEntryFilePath_ifDev };
 import { catchAllEntry } from '@universal-deploy/store';
 import { assert } from '../../../../utils/assert.js';
 import '../../assertEnvVite.js';
@@ -7,12 +8,15 @@ function getServerConfig(vikeConfig) {
     let serverEntryId;
     let serverFilePath = null;
     let serverEntryVike;
+    const serverEntryFilePath = getServerEntryFilePath(vikeConfig);
     // universal-deploy support must be manually enabled
     const serverConfig = 
     // +config.js > `export default { server: true }`
     vikeConfig.config.server ||
         // +server.js exists
         !!vikeConfig._pageConfigGlobal.configValueSources.server ||
+        // +serverEntry.js exists
+        !!serverEntryFilePath ||
         false;
     if (serverConfig === false)
         return;
@@ -26,22 +30,44 @@ function getServerConfig(vikeConfig) {
     }
     else {
         serverEntryId = catchAllEntry;
-        serverEntryVike = 'vike/fetch';
+        serverEntryVike = 'vike/__internal/fetch';
     }
     return {
         // Used to filter which module ID to transform.
         // It points to a fully resolved server entry or the virtual universal-deploy catchAll entry.
         serverEntryId,
         // This entry will be pushed to universal-deploy via `addEntry`.
-        // It either points to the default fetchable endpoint (vike/fetch), or one defined by the user through +server.
+        // It either points to the default fetchable endpoint (vike/__internal/fetch), or one defined by the user through +server.
         serverEntryVike,
         serverFilePath,
+        // +serverEntry.js => it's the production server entry dist/server/index.mjs (instead of @universal-deploy/node's)
+        serverEntryFilePath,
     };
 }
+// https://vike.dev/serverEntry
+function getServerEntryFilePath(vikeConfig) {
+    const source = vikeConfig._pageConfigGlobal.configValueSources.serverEntry?.[0];
+    if (!source)
+        return null;
+    assert(source.valueIsLoaded && source.valueIsFilePath && typeof source.value === 'string');
+    assert('filePathAbsoluteFilesystem' in source.definedAt);
+    // `source.value` is the import path, e.g. `some-npm-package/serverEntry` if the file cannot be resolved
+    return source.definedAt.filePathAbsoluteFilesystem ?? source.value;
+}
+// The +serverEntry.js that `$ vike dev` runs: only if there isn't +server.js (otherwise +serverEntry.js is production-only)
+// https://vike.dev/serverEntry
+function getServerEntryFilePath_ifDev(vikeConfig) {
+    if (vikeConfig._pageConfigGlobal.configValueSources.server)
+        return null;
+    return getServerEntryFilePath(vikeConfig);
+}
 function isUniversalDeployVitePreview(vikeConfig, viteConfigResolved) {
     const isServerConfig = getServerConfig(vikeConfig);
     if (!isServerConfig)
         return null; // not UD
+    // +serverEntry.js => dist/server/index.mjs is the user's server entry => real preview
+    if (isServerConfig.serverEntryFilePath)
+        return false;
     // @universal-deploy/node -> real preview
     // else -> vite preview
     const udNodePlugin = viteConfigResolved.plugins.find((p) => p.name.match(/^ud:node:(?!.*:disabled$)/));

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryAlias.d.ts

@@ -1,5 +1,5 @@
 export { pluginServerEntryAlias };
 import type { Plugin } from 'vite';
 import '../../assertEnvVite.js';
-/** Alias for virtual:ud:catch if no userland server entry */
+/** `vike:server` => alias for virtual:ud:catch-all, also re-exporting the non-default exports of +server.js (if any) */
 declare function pluginServerEntryAlias(serverFilePath?: string | null): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryAlias.js

@@ -1,35 +1,46 @@
 export { pluginServerEntryAlias };
 import { catchAllEntry } from '@universal-deploy/store';
+import pc from '@brillout/picocolors';
 import { pluginCommon } from './common.js';
 import { escapeRegex } from '../../../../utils/escapeRegex.js';
-import { assert } from '../../../../utils/assert.js';
+import { assert, assertWarning } from '../../../../utils/assert.js';
 import '../../assertEnvVite.js';
-const serverEntryAlias = 'vike:server-entry';
-const virtualFileId = '\0' + serverEntryAlias;
+const serverAlias = 'vike:server';
+// TO-DO/next-major-release: remove
+const serverAliasDeprecated = 'vike:server-entry';
+const virtualFileId = '\0' + serverAlias;
 // === Rolldown filter
-const filterRolldown = {
+const filterRolldownResolveId = {
     id: {
-        include: [new RegExp(escapeRegex(serverEntryAlias)), new RegExp(escapeRegex(virtualFileId))],
+        include: [serverAlias, serverAliasDeprecated, virtualFileId].map((id) => new RegExp(`^${escapeRegex(id)}$`)),
+    },
+};
+const filterRolldownLoad = {
+    id: {
+        include: [new RegExp(`^${escapeRegex(virtualFileId)}$`)],
     },
 };
 // ===
-/** Alias for virtual:ud:catch if no userland server entry */
+/** `vike:server` => alias for virtual:ud:catch-all, also re-exporting the non-default exports of +server.js (if any) */
 function pluginServerEntryAlias(serverFilePath) {
     return {
         name: 'vike:pluginUniversalDeploy:alias',
         resolveId: {
-            filter: filterRolldown,
-            handler() {
+            filter: filterRolldownResolveId,
+            handler(id) {
+                assert(id === serverAlias || id === serverAliasDeprecated || id === virtualFileId);
+                assertWarning(id !== serverAliasDeprecated, `${pc.cyan(serverAliasDeprecated)} is deprecated in favor of ${pc.cyan(serverAlias)}, e.g. replace ${pc.cyan(`"main": "${serverAliasDeprecated}"`)} with ${pc.cyan(`"main": "${serverAlias}"`)} in your wrangler.jsonc`, { onlyOnce: true });
                 if (!serverFilePath)
                     return catchAllEntry;
                 return virtualFileId;
             },
         },
         load: {
-            filter: filterRolldown,
-            handler() {
+            filter: filterRolldownLoad,
+            handler(id) {
+                assert(id === virtualFileId);
                 assert(serverFilePath);
-                // Also re-export non-default exports, to support Durable Objects
+                // Also re-export non-default exports, e.g. to support Durable Objects
                 return `import mod from ${JSON.stringify(catchAllEntry)};
 
 export * from ${JSON.stringify(serverFilePath)};

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginWrapServerFile.d.ts

@@ -0,0 +1,4 @@
+export { pluginWrapServerFile };
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+declare function pluginWrapServerFile(serverFilePath: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginWrapServerFile.js

@@ -0,0 +1,29 @@
+export { pluginWrapServerFile };
+import { wrapper } from 'vite-plugin-wrapper';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import '../../assertEnvVite.js';
+function pluginWrapServerFile(serverFilePath) {
+    return wrapper({
+        resolveId: {
+            filter: {
+                id: new RegExp(`${escapeRegex(serverFilePath)}$`),
+            },
+        },
+        load(id) {
+            return [
+                // === Side exports
+                `export * from ${JSON.stringify(id)};`,
+                '',
+                // === Default export
+                // `vikeFetch` acts as fallback if the user's +server.js doesn't export `fetch`
+                // - Example: https://vike.dev/cloudflare#durable-objects
+                // - Bloat (when `vikeFetch` isn't used) is negligible
+                "import vikeFetch from 'vike/__internal/fetch';",
+                `import * as mod from ${JSON.stringify(id)};`,
+                // Destructured because mod.default makes Rolldown warn when +server.js has no default export
+                'const { default: server } = mod;',
+                'export default { ...server, ...server?.prod, fetch: server?.fetch ?? vikeFetch.fetch };',
+            ].join('\n');
+        },
+    });
+}