vike 0.4.266 → 0.4.267-commit-7884d91

package/dist/node/prerender/runPrerender.js

@@ -21,6 +21,7 @@ import { preservePropertyGetters } from '../../utils/preservePropertyGetters.js'
 import { assertPosixPath } from '../../utils/path.js';
 import { urlToFile } from '../../utils/urlToFile.js';
 import { prependBase } from '../../utils/parseUrl-extras.js';
+import { parseUrl } from '../../utils/parseUrl.js';
 import { prerenderPage } from '../../server/runtime/renderPageServer/renderPageServerAfterRoute.js';
 import { createPageContextServer } from '../../server/runtime/renderPageServer/createPageContextServer.js';
 import pc from '@brillout/picocolors';
@@ -43,6 +44,8 @@ import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal, isDistServer
 import { getOutDirsAllFromRootNormalized } from '../vite/shared/getOutDirs.js';
 import fs from 'node:fs';
 import { getPublicProxy } from '../../shared-server-client/getPublicProxy.js';
+import { getPageContextPublicServer } from '../../server/runtime/renderPageServer/getPageContextPublicServer.js';
+import { isObject } from '../../utils/isObject.js';
 import { getStaticRedirectsForPrerender } from '../../server/runtime/renderPageServer/resolveRedirects.js';
 import { updateType } from '../../utils/updateType.js';
 const docLink = 'https://vike.dev/i18n#pre-rendering';
@@ -124,6 +127,17 @@ async function runPrerender(options = {}, trigger) {
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
+    const { precompress } = vikeConfig.config;
+    if (precompress &&
+        // During `$ vike build` (`auto-run`), the build's own precompress pass covers these files.
+        trigger !== 'auto-run' &&
+        // `onPagePrerender` setting defined => no `.html`/`.json` files written => we also don't write `.br`/`.gz` files
+        !options.onPagePrerender) {
+        const { precompressFiles } = await import('@universal-deploy/vite');
+        const { written } = await precompressFiles(prerenderContext.output.map((o) => o.filePath), precompress);
+        if (written > 0)
+            console.log(`${pc.green(`✓`)} ${written} precompressed files.`);
+    }
     await warnMissingPages(prerenderContext._prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = getPrerenderContextPublic(prerenderContext);
     objectAssign(vikeConfig.prerenderContext, prerenderContextPublic, true);
@@ -471,6 +485,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
     });
     const prerenderContextPublic = getPrerenderContextPublic(prerenderContext);
     let result = await execHookSingleWithoutPageContext(onPrerenderStartHook, globalContext, () => hookFn(prerenderContextPublic));
+    prerenderContext.pageContexts = prerenderContext.pageContexts.map(getPageContextOriginal);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;
@@ -496,7 +511,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
     assertUsage(isObjectWithKeys(result, ['prerenderContext']) &&
         hasProp(result, 'prerenderContext', 'object') &&
         hasProp(result.prerenderContext, 'pageContexts', 'array'), rightUsage);
-    prerenderContext.pageContexts = result.prerenderContext.pageContexts;
+    prerenderContext.pageContexts = result.prerenderContext.pageContexts.map(getPageContextOriginal);
     prerenderContext.pageContexts.forEach((pageContext) => {
         // TO-DO/next-major-release: remove
         if (pageContext.url && !isPropertyGetter(pageContext, 'url')) {
@@ -535,11 +550,12 @@ async function prerenderPages(prerenderContext, concurrencyLimit, onComplete) {
             assertIsNotAbort(err, pc.cyan(pageContextBeforeRender.urlOriginal));
             throw err;
         }
-        const { documentHtml, pageContext } = res;
+        const { documentHtml, content, pageContext } = res;
         const pageContextSerialized = pageContext.is404 ? null : res.pageContextSerialized;
         await onComplete({
             pageContext,
             htmlString: documentHtml,
+            content,
             pageContextSerialized,
         });
     })));
@@ -568,7 +584,13 @@ async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPre
         assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while there isn't any ${hookName}() hook returning an URL matching the page's route. You must use a ${hookName}() hook (https://vike.dev/${hookName}) for providing the list of URLs to be pre-rendered for that page. If you want to skip pre-rendering that page, you can remove this warning by setting +prerender to false at ${pageAt} (https://vike.dev/pre-rendering#partial) or by setting +prerender.partial to true (https://vike.dev/prerender#partial).`, { onlyOnce: true });
     });
 }
-async function writeFiles({ pageContext, htmlString, pageContextSerialized }, prerenderContext, onPagePrerender, logLevel) {
+async function writeFiles({ pageContext, htmlString, content, pageContextSerialized }, prerenderContext, onPagePrerender, logLevel) {
+    if (content !== null) {
+        assert(htmlString === null && pageContextSerialized === null);
+        await write(pageContext, 'CONTENT', content, onPagePrerender, prerenderContext, logLevel);
+        return;
+    }
+    assert(htmlString !== null);
     const writeJobs = [write(pageContext, 'HTML', htmlString, onPagePrerender, prerenderContext, logLevel)];
     if (pageContextSerialized !== null) {
         writeJobs.push(write(pageContext, 'JSON', pageContextSerialized, onPagePrerender, prerenderContext, logLevel));
@@ -583,10 +605,13 @@ async function write(pageContext, fileType, fileContent, onPagePrerender, preren
         const doNotCreateExtraDirectory = prerenderContext._noExtraDir ?? pageContext.is404;
         fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
-    else {
-        assert(fileType === 'JSON');
+    else if (fileType === 'JSON') {
         fileUrl = getPageContextRequestUrl(urlOriginal);
     }
+    else {
+        assert(fileType === 'CONTENT');
+        fileUrl = getContentFileUrl(pageContext);
+    }
     assertPosixPath(fileUrl);
     assert(fileUrl.startsWith('/'));
     const filePathRelative = fileUrl.slice(1);
@@ -603,14 +628,15 @@ async function write(pageContext, fileType, fileContent, onPagePrerender, preren
             fileContent,
         },
     });
-    prerenderContext.output.push({
-        filePath,
-        fileType,
-        fileContent,
-        pageContext,
-    });
+    if (fileType === 'CONTENT') {
+        prerenderContext.output.push({ filePath, fileType, fileContent, pageContext });
+    }
+    else {
+        assert(typeof fileContent === 'string');
+        prerenderContext.output.push({ filePath, fileType, fileContent, pageContext });
+    }
     if (onPagePrerender) {
-        await onPagePrerender(pageContext);
+        await onPagePrerender(getPageContextPublicPrerendered(pageContext));
     }
     else {
         const { promises } = await import('node:fs');
@@ -629,6 +655,18 @@ async function write(pageContext, fileType, fileContent, onPagePrerender, preren
         }
     }
 }
+// With `pageContext.content` the URL is the file path: `/feed.atom` => `dist/client/feed.atom`
+function getContentFileUrl(pageContext) {
+    const { urlOriginal } = pageContext;
+    // The query string and the hash are ignored: a static host serves the file at the pathname
+    const { pathnameOriginal } = parseUrl(urlOriginal, '/');
+    const errPrefix = `Cannot pre-render ${pc.cyan(urlOriginal)} with ${pc.code('pageContext.content')}`;
+    const errSuffix = "pre-rendering writes the content to the file at the URL's pathname (e.g. /feed.atom => dist/client/feed.atom)";
+    assertUsage(!pageContext.is404, `${errPrefix} because it's the 404 page`);
+    const segments = pathnameOriginal.split('/').slice(1);
+    assertUsage(segments.every((s) => s !== '' && s !== '.' && s !== '..'), `${errPrefix} because the URL's pathname isn't a file path: ${errSuffix}`);
+    return pathnameOriginal;
+}
 function normalizeOnPrerenderHookResult(prerenderResult, prerenderHookFile, hookName) {
     if (isArray(prerenderResult)) {
         return prerenderResult.map(normalize);
@@ -719,14 +757,31 @@ function getPrerenderContextPublic(prerenderContext) {
             configurable: true,
         });
     }
-    // Required because of https://vike.dev/i18n#pre-rendering
-    // - Thus, we have to let users access the original pageContext object => we cannot use ES proxies and we cannot use getPageContextPublicShared()
-    prerenderContext.pageContexts.forEach((pageContext) => {
+    prerenderContext.pageContexts = prerenderContext.pageContexts.map((pageContext) => {
+        // Required because of https://vike.dev/i18n#pre-rendering
+        // - Users copy pageContext, e.g. `{ ...pageContext, locale }`, and Vike renders the copies => the copies need to be original objects
         changeEnumerable(pageContext, '_isOriginalObject', true);
+        return getPageContextPublicServer(pageContext);
+    });
+    prerenderContext.output.forEach((file) => {
+        file.pageContext = getPageContextPublicPrerendered(file.pageContext);
     });
     const prerenderContextPublic = getPublicProxy(prerenderContext, 'prerenderContext');
     return prerenderContextPublic;
 }
+// The user may return the public pageContext objects passed to +onPrerenderStart
+function getPageContextOriginal(pageContext) {
+    const obj = pageContext;
+    if (isObject(obj) && obj._isProxyObject)
+        return obj._originalObject;
+    return pageContext;
+}
+function getPageContextPublicPrerendered(pageContext) {
+    // Pre-rendered redirects don't have any real pageContext object, but only a plain object `{ urlOriginal, pageId: null, is404: false, isRedirect: true }` which we cannot pass to getPageContextPublicServer() as it only accepts real pageContext objects (it asserts pageContext._isOriginalObject)
+    if (pageContext.isRedirect)
+        return pageContext;
+    return getPageContextPublicServer(pageContext);
+}
 async function prerenderRedirects(globalContext, onComplete, showWarningUponDynamicRedirects) {
     const redirects = globalContext.config.redirects ?? [];
     const redirectsStatic = getStaticRedirectsForPrerender(redirects, showWarningUponDynamicRedirects);
@@ -737,6 +792,7 @@ async function prerenderRedirects(globalContext, onComplete, showWarningUponDyna
         await onComplete({
             pageContext: { urlOriginal, pageId: null, is404: false, isRedirect: true },
             htmlString,
+            content: null,
             pageContextSerialized: null,
         });
     }

package/dist/node/vite/assertEnvVite.js

@@ -11,8 +11,8 @@ function assertEnvVite() {
     markSetup_vikeVitePlugin();
     assertIsNotBrowser();
     assertNodeVersion();
-    assertViteVersion(viteVersion);
-    assertIsNotProductionRuntime(); // Don't bloat server with heavy dependencies like Vite and esbuild
+    assertViteVersion(viteVersion); // Early check — more reliable check using `this.meta.viteVersion` later
+    assertIsNotProductionRuntime(); // Don't bloat server with heavy dependencies like Vite
 }
 function onLoad() {
     installUncaughtErrorHandlers();

package/dist/node/vite/index.js

@@ -32,6 +32,7 @@ import { pluginSuppressRollupWarning } from './plugins/build/pluginSuppressRollu
 import { pluginDistFileNames } from './plugins/build/pluginDistFileNames.js';
 import { pluginProdBuildEntry } from './plugins/build/pluginProdBuildEntry.js';
 import { pluginBuildConfig } from './plugins/build/pluginBuildConfig.js';
+import { pluginEnvironmentEntries } from './plugins/build/pluginEnvironmentEntries.js';
 import { pluginModuleBanner } from './plugins/build/pluginModuleBanner.js';
 import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js';
 import { isVikeCliOrApi } from '../../shared-server-node/api-context.js';
@@ -83,6 +84,7 @@ function plugin(vikeVitePluginOptions = {}) {
 function pluginBuild() {
     return [
         ...pluginBuildConfig(),
+        ...pluginEnvironmentEntries(),
         ...pluginBuildApp(),
         ...pluginProdBuildEntry(),
         ...pluginDistPackageJsonFile(),

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

@@ -45,7 +45,7 @@ async function fixServerAssets(config) {
 }
 async function copyAssets(filesToMove, filesToRemove, config) {
     const { outDirClient, outDirServer } = getOutDirs(config, undefined);
-    const assetsDir = getAssetsDir(config);
+    const assetsDir = getAssetsDir(config.environments.ssr.build);
     const assetsDirServer = path.posix.join(outDirServer, assetsDir);
     if (!filesToMove.length && !filesToRemove.length && !existsSync(assetsDirServer))
         return;
@@ -180,7 +180,11 @@ function getPageId(key) {
     // to:
     //   virtual:vike:page-entry:client:/pages/index
     // (This seems to be needed only for vitest tests that use Vite's build() API with an inline config.)
-    key = key.substring(key.indexOf('virtual:vike'));
+    const prefix = key.split('virtual:vike')[0];
+    // Skip virtual modules wrapping a Vike virtual module, e.g. virtual:vite-rsc/client-references/group/facade:virtual:vike:page-entry:client:/pages/index
+    if (prefix && !prefix.endsWith('/'))
+        return null;
+    key = key.substring(prefix.length);
     const result = parseVirtualFileId(key);
     return result && result.type === 'page-entry' ? result.pageId : null;
 }
@@ -310,7 +314,8 @@ async function handleAssetsManifest_getBuildConfig(config) {
         if (config.build?.cssMinify === undefined)
             build.cssMinify = isVite8OrAbove(config) ? true : 'esbuild';
     }
-    if (config.build?.manifest === undefined)
+    assertWarning(config.build?.manifest !== false, `Setting Vite's configuration ${pc.cyan('build.manifest')} to ${pc.cyan('false')} is ignored — Vike overrides it to ${pc.cyan('true')} because Vike needs the manifest. Note that Vike removes the manifest from the client-side bundle, see ${pc.underline('https://github.com/vikejs/vike/issues/3505#issuecomment-5563748527')}`, { onlyOnce: true });
+    if (config.build?.manifest === undefined || config.build?.manifest === false)
         build.manifest = true;
     /* Already set by vike:build:pluginBuildApp
     if (config.build?.copyPublicDir === undefined) build.copyPublicDir = !isViteServerSide_viteEnvOptional(config)

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`);