vike 0.4.236 → 0.4.237-commit-8749e81

package/dist/esm/node/vite/plugins/pluginVirtualFiles/{getVirtualFileEntry.js → generateVirtualFileGlobalEntryWithOldDesign.js}

@@ -1,19 +1,19 @@
-export { getVirtualFileEntry };
+export { generateVirtualFileGlobalEntryWithOldDesign };
 import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionOrAbove, assertWarning, } from '../../utils.js';
-import { isVirtualFileIdEntry } from '../../../shared/virtualFiles/virtualFileEntry.js';
+import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
 import { version as viteVersion } from 'vite';
 import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'node:path';
-import { getVirtualFilePageConfigsEager } from './getVirtualFilePageConfigsEager.js';
+import { generateVirtualFileGlobalEntry } from './generateVirtualFileGlobalEntry.js';
 import { getVikeConfigInternal, isV1Design as isV1Design_ } from '../../shared/resolveVikeConfigInternal.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
-import { isViteServerBuild_options } from '../../shared/isViteServerBuild.js';
-import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
-async function getVirtualFileEntry(id, options, config, isDev) {
-    const idParsed = isVirtualFileIdEntry(id);
-    assert(idParsed);
+import { isViteServerBuild_extraSafe } from '../../shared/isViteServerBuild.js';
+import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
+async function generateVirtualFileGlobalEntryWithOldDesign(id, options, config, env, isDev) {
+    const idParsed = parseVirtualFileId(id);
+    assert(idParsed && idParsed.type === 'global-entry');
     const { isForClientSide, isClientRouting } = idParsed;
-    assert(isForClientSide === !isViteServerBuild_options(options));
+    assert(isForClientSide === !isViteServerBuild_extraSafe(config, options, env));
     const code = await getCode(config, isForClientSide, isClientRouting, isDev, id);
     return code;
 }
@@ -66,7 +66,7 @@ export const pageFilesExportNamesEager = {};
 export const pageFilesList = [];
 export const neverLoaded = {};
 
-${await getVirtualFilePageConfigsEager(isForClientSide, isDev, id, isClientRouting)}
+${await generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting)}
 
 `;
     // We still use import.meta.glob() when using th V1 design in order to not break the V1 design deprecation warning
@@ -168,7 +168,7 @@ function getGlobRoots(config) {
     const globRoots = [
         {
             includeDir: '/',
-            excludeDir: path.posix.relative(config.root, getOutDirs(config).outDirRoot),
+            excludeDir: path.posix.relative(config.root, getOutDirs(config, undefined).outDirRoot),
         },
     ];
     return globRoots;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/generateVirtualFilePageEntry.d.ts

@@ -0,0 +1,3 @@
+export { generateVirtualFilePageEntry };
+import type { ResolvedConfig } from 'vite';
+declare function generateVirtualFilePageEntry(id: string, isDev: boolean, config: ResolvedConfig): Promise<string>;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/{getVirtualFilePageConfigLazy.js → generateVirtualFilePageEntry.js}

@@ -1,17 +1,16 @@
-export { getVirtualFilePageConfigLazy };
+export { generateVirtualFilePageEntry };
 import { assert, getProjectError } from '../../utils.js';
-import { getVirtualFileIdPageConfigLazy, isVirtualFileIdPageConfigLazy, } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { parseVirtualFileId, generateVirtualFileId } from '../../../shared/virtualFileId.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
-import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { handleAssetsManifest_isFixEnabled } from '../pluginBuild/handleAssetsManifest.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
-async function getVirtualFilePageConfigLazy(id, isDev, config) {
-    const result = isVirtualFileIdPageConfigLazy(id);
-    assert(result);
+import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
+async function generateVirtualFilePageEntry(id, isDev, config) {
+    const result = parseVirtualFileId(id);
+    assert(result && result.type === 'page-entry');
     /* This assertion fails when using includeAssetsImportedByServer
     {
       const isForClientSide = !config.build.ssr
@@ -33,20 +32,20 @@ async function getVirtualFilePageConfigLazy(id, isDev, config) {
             throw getProjectError('Outdated request');
         //*/
     }
-    const code = getLoadConfigLazy(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), config, isDev);
+    const code = getCode(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), config, isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
-function getLoadConfigLazy(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, config, isDev) {
+function getCode(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, config, isDev) {
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
     const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesSerialized = {');
-    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '', false));
+    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '', false));
     lines.push('};');
     if (!handleAssetsManifest_isFixEnabled(config) && includeAssetsImportedByServer && isForClientSide && !isDev) {
-        importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigLazy(pageId, false))}'`);
+        importStatements.push(`import '${extractAssetsAddQuery(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide: false }))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');
     return code;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.d.ts

@@ -0,0 +1,14 @@
+export { getConfigValueSourcesRelevant };
+export { isRuntimeEnvMatch };
+export type { RuntimeEnv };
+import type { ConfigEnvInternal, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
+type RuntimeEnv = {
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+    isDev?: boolean;
+} | {
+    isForConfig: true;
+};
+declare function getConfigValueSourcesRelevant(configName: string, runtimeEnv: RuntimeEnv, pageConfig: PageConfigPartial): ConfigValueSource[];
+declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtimeEnv: RuntimeEnv): boolean;
+type PageConfigPartial = Pick<PageConfigBuildTime | PageConfigGlobalBuildTime, 'configValueSources' | 'configDefinitions'>;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js

@@ -0,0 +1,65 @@
+export { getConfigValueSourcesRelevant };
+export { isRuntimeEnvMatch };
+import { assert } from '../../utils.js';
+function getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig) {
+    const configDef = pageConfig.configDefinitions[configName];
+    assert(configDef);
+    let sourcesRelevant = pageConfig.configValueSources[configName];
+    if (!sourcesRelevant)
+        return [];
+    if (!configDef.cumulative) {
+        const source = sourcesRelevant[0];
+        if (source) {
+            sourcesRelevant = [source];
+        }
+        else {
+            assert(sourcesRelevant.length === 0);
+        }
+    }
+    else {
+        // isOverridden() must be called before isRuntimeEnvMatch() is called (otherwise isOverridden() will return a wrong value)
+        sourcesRelevant = sourcesRelevant.filter((source) => !isOverridden(source, configName, pageConfig));
+    }
+    sourcesRelevant = sourcesRelevant.filter((source) => isRuntimeEnvMatch(source.configEnv, runtimeEnv));
+    return sourcesRelevant;
+}
+function isRuntimeEnvMatch(configEnv, runtimeEnv) {
+    if ('isForConfig' in runtimeEnv)
+        return !!configEnv.config;
+    // Runtime
+    if (!runtimeEnv.isForClientSide) {
+        if (!configEnv.server)
+            return false;
+    }
+    else {
+        if (!configEnv.client)
+            return false;
+        if (configEnv.client === 'if-client-routing' && !runtimeEnv.isClientRouting)
+            return false;
+    }
+    // Production/development
+    if (configEnv.production !== undefined) {
+        assert(typeof configEnv.production === 'boolean');
+        assert(typeof runtimeEnv.isDev === 'boolean');
+        if (configEnv.production) {
+            if (runtimeEnv.isDev)
+                return false;
+        }
+        else {
+            if (!runtimeEnv.isDev)
+                return false;
+        }
+    }
+    return true;
+}
+function isOverridden(source, configName, pageConfig) {
+    const configDef = pageConfig.configDefinitions[configName];
+    assert(configDef);
+    if (configDef.cumulative)
+        return false;
+    const sources = pageConfig.configValueSources[configName];
+    assert(sources);
+    const idx = sources.indexOf(source);
+    assert(idx >= 0);
+    return idx > 0;
+}

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

@@ -1,11 +1,9 @@
 export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
-import { getVirtualFilePageConfigLazy } from './pluginVirtualFiles/getVirtualFilePageConfigLazy.js';
-import { getVirtualFileEntry } from './pluginVirtualFiles/getVirtualFileEntry.js';
-import { assert, assertPosixPath, isScriptFile } from '../utils.js';
-import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtualFiles.js';
-import { isVirtualFileIdPageConfigLazy } from '../../shared/virtualFiles/virtualFilePageConfigLazy.js';
-import { isVirtualFileIdEntry } from '../../shared/virtualFiles/virtualFileEntry.js';
+import { generateVirtualFilePageEntry } from './pluginVirtualFiles/generateVirtualFilePageEntry.js';
+import { generateVirtualFileGlobalEntryWithOldDesign } from './pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js';
+import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
+import { parseVirtualFileId } from '../../shared/virtualFileId.js';
 import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerNotProd.js';
@@ -26,7 +24,7 @@ function pluginVirtualFiles() {
         },
         resolveId(id) {
             if (isVirtualFileId(id)) {
-                return resolveVirtualFileId(id);
+                return addVirtualFileIdPrefix(id);
             }
         },
         async handleHotUpdate(ctx) {
@@ -42,16 +40,19 @@ function pluginVirtualFiles() {
         async load(id, options) {
             if (!isVirtualFileId(id))
                 return undefined;
-            id = getVirtualFileId(id);
+            id = removeVirtualFileIdPrefix(id);
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
-            if (isVirtualFileIdPageConfigLazy(id)) {
-                const code = await getVirtualFilePageConfigLazy(id, isDev, config);
-                return code;
-            }
-            if (isVirtualFileIdEntry(id)) {
-                const code = await getVirtualFileEntry(id, options, config, isDev);
-                return code;
+            const idParsed = parseVirtualFileId(id);
+            if (idParsed) {
+                if (idParsed.type === 'page-entry') {
+                    const code = await generateVirtualFilePageEntry(id, isDev, config);
+                    return code;
+                }
+                if (idParsed.type === 'global-entry') {
+                    const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
+                    return code;
+                }
             }
         },
         configureServer(server) {
@@ -164,7 +165,7 @@ function reloadConfig(filePath, config, op, server) {
 }
 function getVikeVirtualFiles(server) {
     const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
-        .filter((url) => isVirtualFileIdPageConfigLazy(url) || isVirtualFileIdEntry(url))
+        .filter((url) => parseVirtualFileId(url))
         .map((url) => {
         const mod = server.moduleGraph.urlToModuleMap.get(url);
         assert(mod);

package/dist/esm/node/vite/shared/findPageFiles.js

@@ -5,7 +5,7 @@ import pc from '@brillout/picocolors';
 import { getOutDirs } from './getOutDirs.js';
 async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
-    const { outDirRoot } = getOutDirs(config);
+    const { outDirRoot } = getOutDirs(config, undefined);
     const timeBase = new Date().getTime();
     let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensionPattern}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false, expandDirectories: false });
     pageFiles = pageFiles.map((p) => '/' + toPosixPath(p));

package/dist/esm/node/vite/shared/getClientEntrySrcDev.d.ts

@@ -0,0 +1,4 @@
+export { getClientEntrySrcDev };
+export type GetClientEntrySrcDev = typeof getClientEntrySrcDev;
+import type { ViteDevServer } from 'vite';
+declare function getClientEntrySrcDev(clientEntry: string, viteDevServer: ViteDevServer): string;

package/dist/esm/node/vite/shared/{resolveClientEntriesDev.js → getClientEntrySrcDev.js}

@@ -1,7 +1,7 @@
-export { resolveClientEntriesDev };
+export { getClientEntrySrcDev };
 import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsImportPathNpmPackage, assertIsNotProductionRuntime, requireResolveNpmPackage, requireResolveVikeDistFile, } from '../utils.js';
 assertIsNotProductionRuntime();
-function resolveClientEntriesDev(clientEntry, viteDevServer) {
+function getClientEntrySrcDev(clientEntry, viteDevServer) {
     let userRootDir = viteDevServer.config.root;
     assert(userRootDir);
     userRootDir = toPosixPath(userRootDir);

package/dist/esm/node/vite/shared/getMagicString.d.ts

@@ -0,0 +1,9 @@
+export { getMagicString };
+import MagicString from 'magic-string';
+declare function getMagicString(code: string, id: string): {
+    magicString: MagicString;
+    getMagicStringResult: () => {
+        code: string;
+        map: import("magic-string").SourceMap;
+    };
+};

package/dist/esm/node/vite/shared/getMagicString.js

@@ -0,0 +1,13 @@
+export { getMagicString };
+import MagicString from 'magic-string';
+// Used everywhere instead of `new MagicString()` for consistent source map generation
+function getMagicString(code, id) {
+    const magicString = new MagicString(code);
+    const getMagicStringResult = () => {
+        return {
+            code: magicString.toString(),
+            map: magicString.generateMap({ hires: true, source: id }),
+        };
+    };
+    return { magicString, getMagicStringResult };
+}

package/dist/esm/node/vite/shared/getManifestFilePathRelative.d.ts

@@ -0,0 +1,2 @@
+export { getManifestFilePathRelative };
+declare function getManifestFilePathRelative(manifestConfig: string | boolean): string;

package/dist/esm/node/vite/shared/getManifestFilePathRelative.js

@@ -0,0 +1,8 @@
+export { getManifestFilePathRelative };
+import { assert } from '../utils.js';
+function getManifestFilePathRelative(manifestConfig) {
+    assert(['string', 'boolean'].includes(typeof manifestConfig));
+    assert(manifestConfig !== false);
+    const manifestFileRelative = typeof manifestConfig === 'string' ? manifestConfig : '.vite/manifest.json';
+    return manifestFileRelative;
+}

package/dist/esm/node/vite/shared/getOutDirs.d.ts

@@ -1,7 +1,9 @@
 export { getOutDirs };
 export { resolveOutDir };
+export { resolveOutDir_configEnvironment };
 export type { OutDirs };
-import type { UserConfig, ResolvedConfig, Environment } from 'vite';
+import type { UserConfig, ResolvedConfig, EnvironmentOptions } from 'vite';
+import { ViteEnv } from './isViteServerBuild.js';
 type OutDirs = {
     /** Absolute path to `outDir` */
     outDirRoot: string;
@@ -10,6 +12,7 @@ type OutDirs = {
     /** Absolute path to `${outDir}/server` */
     outDirServer: string;
 };
-declare function getOutDirs(configGlobal: ResolvedConfig, viteEnv?: Environment): OutDirs;
+declare function getOutDirs(configGlobal: ResolvedConfig, viteEnv: ViteEnv | undefined): OutDirs;
+declare function resolveOutDir_configEnvironment(configGlobal: UserConfig, envName: string, configEnv: EnvironmentOptions): string;
 /** Appends `client/` or `server/` to `config.build.outDir` */
-declare function resolveOutDir(config: UserConfig, isSSR?: true): string;
+declare function resolveOutDir(config: UserConfig, isServerSide: boolean): string;

package/dist/esm/node/vite/shared/getOutDirs.js

@@ -1,22 +1,26 @@
 export { getOutDirs };
 export { resolveOutDir };
+export { resolveOutDir_configEnvironment };
 import pc from '@brillout/picocolors';
 import { assert, assertPosixPath, assertUsage, createDebugger, pathJoin, toPosixPath } from '../utils.js';
-import { isViteServerBuild } from './isViteServerBuild.js';
+import { isViteServerBuild, isViteServerBuild_withoutEnv } from './isViteServerBuild.js';
 const debug = createDebugger('vike:outDir');
 function getOutDirs(configGlobal, viteEnv) {
-    const configEnv = viteEnv?.config ?? configGlobal;
     debug('getOutDirs()', new Error().stack);
-    const outDir = getOutDirFromViteResolvedConfig(configEnv);
-    if (!isOutDirRoot(outDir))
-        assertOutDirResolved(outDir, configEnv);
-    const outDirs = getOutDirsAll(outDir, configEnv.root);
+    const outDir = getOutDirFromResolvedConfig(configGlobal);
+    assertOutDirResolved(outDir, configGlobal, viteEnv);
+    const outDirs = getOutDirsAll(outDir, configGlobal.root);
     return outDirs;
 }
+function resolveOutDir_configEnvironment(configGlobal, envName, configEnv) {
+    assert(configGlobal && envName && configEnv);
+    const viteEnv = { name: envName, config: configEnv };
+    const isServerSide = isViteServerBuild(configGlobal, viteEnv);
+    return resolveOutDir(configEnv, isServerSide);
+}
 /** Appends `client/` or `server/` to `config.build.outDir` */
-function resolveOutDir(config, isSSR) {
+function resolveOutDir(config, isServerSide) {
     debug('resolveOutDir()', new Error().stack);
-    const isServerSide = isViteServerBuild(config) || isSSR;
     debug('isServerSide', isServerSide);
     const outDir = getOutDirFromViteUserConfig(config) || 'dist';
     debug('outDir', outDir);
@@ -98,14 +102,16 @@ function isOutDirRoot(outDirRot) {
 function assertIsNotOutDirRoot(outDir) {
     assert(outDir.endsWith('/client') || outDir.endsWith('/server'));
 }
-/** Assert that `outDir` ends with `/server` or `/client` */
-function assertOutDirResolved(outDir, config) {
+/** Assert that `outDir` ends with the correct directory `/server` or `/client` */
+function assertOutDirResolved(outDir, configGlobal, viteEnv) {
     assertPosixPath(outDir);
-    assertIsNotOutDirRoot(outDir);
+    if (isOutDirRoot(outDir))
+        return;
+    assert(outDir.endsWith('/client') || outDir.endsWith('/server')); // we normalized outDir
     assert('/client'.length === '/server'.length);
     const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
     const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
-    if (isViteServerBuild(config)) {
+    if (isViteServerBuild_withoutEnv(configGlobal, viteEnv)) {
         assertUsage(outDir.endsWith('/server'), wrongUsage);
     }
     else {
@@ -119,7 +125,7 @@ function getOutDirFromViteUserConfig(config) {
     outDir = normalizeOutDir(outDir);
     return outDir;
 }
-function getOutDirFromViteResolvedConfig(config) {
+function getOutDirFromResolvedConfig(config) {
     let outDir = config.build.outDir;
     assert(outDir);
     outDir = normalizeOutDir(outDir);

package/dist/esm/node/vite/shared/getViteConfigRuntime.js

@@ -3,7 +3,7 @@ import { assert, assertFilePathAbsoluteFilesystem, hasProp } from '../utils.js';
 import { getOutDirs } from './getOutDirs.js';
 function getViteConfigRuntime(config) {
     assert(hasProp(config, '_baseViteOriginal', 'string'));
-    const { outDirRoot } = getOutDirs(config);
+    const { outDirRoot } = getOutDirs(config, undefined);
     assertFilePathAbsoluteFilesystem(outDirRoot);
     const viteConfigRuntime = {
         root: config.root,

package/dist/esm/node/vite/shared/isViteServerBuild.d.ts

@@ -1,15 +1,18 @@
 export { isViteServerBuild };
 export { isViteClientBuild };
-export { isViteServerBuild_options };
-export { isViteServerBuild_safe };
+export { isViteServerBuild_withoutEnv };
 export { isViteServerBuild_onlySsrEnv };
-import type { Environment, ResolvedConfig, UserConfig } from 'vite';
-declare function isViteServerBuild(configGlobal: ResolvedConfig | UserConfig, viteEnv?: Environment): boolean;
-declare function isViteServerBuild_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: Environment | undefined): boolean;
-declare function isViteClientBuild(configGlobal: ResolvedConfig, viteEnv: Environment): boolean;
-declare function isViteServerBuild_options(options: {
+export { isViteServerBuild_extraSafe };
+export type { ViteEnv };
+import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig } from 'vite';
+type ViteEnv = {
+    name?: string;
+    config: EnvironmentOptions | Environment['config'];
+};
+declare function isViteServerBuild_withoutEnv(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv): boolean;
+declare function isViteServerBuild(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
+declare function isViteClientBuild(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerBuild_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerBuild_extraSafe(config: ResolvedConfig, options: {
     ssr?: boolean;
-} | undefined): boolean;
-declare function isViteServerBuild_safe(config: ResolvedConfig, options: {
-    ssr?: boolean;
-} | undefined): boolean;
+} | undefined, viteEnv: ViteEnv): boolean;

package/dist/esm/node/vite/shared/isViteServerBuild.js

@@ -1,45 +1,72 @@
+// TODO/now: rename to isViteServerSide
 export { isViteServerBuild };
+// TODO/now: rename to isViteClientSide
 export { isViteClientBuild };
-export { isViteServerBuild_options };
-export { isViteServerBuild_safe };
+export { isViteServerBuild_withoutEnv };
 export { isViteServerBuild_onlySsrEnv };
+export { isViteServerBuild_extraSafe };
 import { assert } from '../../../utils/assert.js';
-function isViteServerBuild(configGlobal, viteEnv) {
-    const configEnv = viteEnv?.config ?? configGlobal;
-    return !!configEnv?.build?.ssr;
+function isViteServerBuild_withoutEnv(configGlobal, viteEnv) {
+    assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
+    const isServerSide1 = !viteEnv?.config.consumer ? null : viteEnv.config.consumer !== 'client';
+    const isServerSide2 = !viteEnv?.name ? null : viteEnv.name !== 'client'; // I can't think of a use case for creating another client-side environment
+    const isServerSide3 = !viteEnv ? null : !!viteEnv.config.build?.ssr;
+    const isServerSide4 = !!configGlobal.build?.ssr;
+    const debug = {
+        envIsUndefined: !viteEnv,
+        envName: viteEnv?.name ?? null,
+        envConsumer: viteEnv?.config.consumer ?? null,
+        configEnvBuildSsr: viteEnv?.config.build?.ssr ?? null,
+        configGlobalBuildSsr: configGlobal.build?.ssr ?? null,
+        isServerSide1,
+        isServerSide2,
+        isServerSide3,
+        isServerSide4,
+    };
+    if (isServerSide1 !== null) {
+        assert(isServerSide1 === isServerSide2 || isServerSide2 === null, debug);
+        /* This assertion can fail, seems to be a Vite bug?
+        assert(isServerSide1 === isServerSide3, debug)
+        */
+        return isServerSide1;
+    }
+    if (isServerSide2 !== null) {
+        /* This assertion can fail, seems to be a Vite bug?
+        assert(isServerSide2 === isServerSide3, debug)
+        */
+        return isServerSide2;
+    }
+    if (isServerSide3 !== null) {
+        return isServerSide3;
+    }
+    return isServerSide4;
 }
-// Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
-function isViteServerBuild_onlySsrEnv(configGlobal, viteEnv) {
-    return viteEnv ? viteEnv.name === 'ssr' : isViteServerBuild(configGlobal);
+function isViteServerBuild(configGlobal, viteEnv) {
+    return isViteServerBuild_withoutEnv(configGlobal, viteEnv);
 }
 function isViteClientBuild(configGlobal, viteEnv) {
-    const yes = !isViteServerBuild(configGlobal, viteEnv);
-    const isVite5 = viteEnv === undefined;
-    if (!isVite5) {
-        const yes2 = viteEnv.name === 'client';
-        assert(yes === yes2);
-    }
-    return yes;
+    return !isViteServerBuild(configGlobal, viteEnv);
 }
-function isViteServerBuild_options(options) {
-    return !!options?.ssr;
+// Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
+function isViteServerBuild_onlySsrEnv(configGlobal, viteEnv) {
+    return viteEnv ? viteEnv.name === 'ssr' : isViteServerBuild(configGlobal, viteEnv);
 }
-// Vite is quite messy about setting `ssr: boolean`, thus we use an extra safe implementation for security purposes.
-// It's used for .client.js and .server.js guarantee thus we use aggressive assert() calls for added safety.
-function isViteServerBuild_safe(config, options) {
+// Vite is quite messy about setting config.build.ssr — for security purposes, we use an extra safe implementation with lots of assertions, which is needed for the .client.js and .server.js guarantee.
+function isViteServerBuild_extraSafe(config, options, viteEnv) {
     if (config.command === 'build') {
-        assert(typeof config.build.ssr === 'boolean');
-        const val = config.build.ssr;
-        if (options?.ssr !== undefined)
-            assert(val === options.ssr);
-        return val;
+        const res = config.build.ssr;
+        assert(typeof res === 'boolean');
+        assert(res === options?.ssr || options?.ssr === undefined);
+        assert(res === isViteServerBuild(config, viteEnv));
+        return res;
     }
     else {
-        assert(typeof options?.ssr === 'boolean');
-        const val = options.ssr;
-        /* This assert() fails (which is very unexpected).
-        if (typeof config.build.ssr === 'boolean') assert(val === config.build.ssr)
-        //*/
-        return val;
+        const res = options?.ssr;
+        assert(typeof res === 'boolean');
+        /* This assertion can fail, seems to be a Vite bug? It's very unexpected.
+        if (typeof config.build.ssr === 'boolean') assert(res === config.build.ssr)
+        */
+        assert(res === isViteServerBuild(config, viteEnv));
+        return res;
     }
 }

package/dist/esm/node/vite/shared/loggerVite.js

@@ -31,7 +31,7 @@ function intercept(logType, config) {
             // We swallow Vite's message: we didn't see it add any value so far.
             //  - It can even be confusing, such as the following:
             //    ```
-            //    Error when evaluating SSR module virtual:vike:pageConfigLazy:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
+            //    Error when evaluating SSR module virtual:vike:page-entry:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
             //    ```
             assert(!isErrorDebug());
             return;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.d.ts

@@ -4,7 +4,7 @@ export type { ConfigDefinitions };
 export type { ConfigDefinitionsInternal };
 export type { ConfigDefinitionInternal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources, DefinedAtFilePath } from '../../../../types/PageConfig.js';
+import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath, PageConfigBuildTime } from '../../../../types/PageConfig.js';
 import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../types/Config.js';
 import { type ConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
 /** The meta definition of a config.
@@ -75,7 +75,7 @@ type ConfigEffect = (config: {
 }) => Config | undefined;
 /** For Vike internal use */
 type ConfigDefinitionInternal = Omit<ConfigDefinition_, 'env'> & {
-    _computed?: (configValueSources: ConfigValueSources) => unknown;
+    _computed?: (pageConfig: Omit<PageConfigBuildTime, 'configValuesComputed'>) => unknown;
     _valueIsFilePath?: true;
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     env: ConfigEnvInternal;