vike 0.4.240 → 0.4.241-commit-206146b

package/dist/esm/node/vite/index.js

@@ -16,12 +16,12 @@ import { pluginExtractExportNames } from './plugins/pluginExtractExportNames.js'
 import { pluginSetGlobalContext } from './plugins/pluginSetGlobalContext.js';
 import { pluginCommon } from './plugins/pluginCommon.js';
 import { pluginBaseUrls } from './plugins/pluginBaseUrls.js';
-import { pluginEnvVars } from './plugins/pluginEnvVars.js';
+import { pluginReplaceConstantsEnvVars } from './plugins/pluginReplaceConstantsEnvVars.js';
 import { pluginFileEnv } from './plugins/pluginFileEnv.js';
 import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModuleHmr.js';
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
-import { pluginReplaceIsClientSide } from './plugins/pluginReplaceIsClientSide.js';
-import { pluginReplaceGlobalThisConstants } from './plugins/pluginReplaceGlobalThisConstants.js';
+import { pluginReplaceConstantsPageContext } from './plugins/pluginReplaceConstantsPageContext.js';
+import { pluginReplaceConstantsGlobalThis } from './plugins/pluginReplaceConstantsGlobalThis.js';
 import { pluginViteRPC } from './plugins/non-runnable-dev/pluginViteRPC.js';
 import { pluginBuildApp } from './plugins/build/pluginBuildApp.js';
 import { pluginDistPackageJsonFile } from './plugins/build/pluginDistPackageJsonFile.js';
@@ -46,12 +46,12 @@ function plugin(vikeVitePluginOptions = {}) {
         ...pluginExtractExportNames(),
         ...pluginSetGlobalContext(),
         ...pluginBaseUrls(),
-        ...pluginEnvVars(),
+        ...pluginReplaceConstantsEnvVars(),
         ...pluginFileEnv(),
         ...pluginWorkaroundCssModuleHmr(),
         ...pluginWorkaroundVite6HmrRegression(),
-        ...pluginReplaceIsClientSide(),
-        ...pluginReplaceGlobalThisConstants(),
+        ...pluginReplaceConstantsPageContext(),
+        ...pluginReplaceConstantsGlobalThis(),
         ...pluginNonRunnabeDev(),
     ];
     Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });

package/dist/esm/node/vite/onLoad.js

@@ -2,18 +2,13 @@ export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 import { assertIsNotProductionRuntime, markSetup_vikeVitePlugin } from '../../utils/assertSetup.js';
 import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
-import { assertVersion } from '../../utils/assertVersion.js';
-import { version } from 'vite';
+import { version as viteVersion } from 'vite';
+import { assertViteVersion } from '../../utils/assertViteVersion.js';
 function onLoad() {
     markSetup_vikeVitePlugin();
     assertIsNotBrowser();
     assertNodeVersion();
-    // package.json#peerDependencies isn't enough as users often ignore it
-    // This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
-    // TO-DO/eventually: let's also use this.meta.viteVersion
-    // - https://github.com/vitejs/vite/pull/20088
-    // - https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#700-2025-06-24
-    assertVersion('Vite', version, ['6.3.0']);
+    assertViteVersion(viteVersion);
     // Ensure we don't bloat the server runtime with heavy dependencies such Vite and esbuild
     assertIsNotProductionRuntime();
 }

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

@@ -310,7 +310,6 @@ async function handleAssetsManifest_getBuildConfig() {
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
     const isSsrEnv = isViteServerSide_onlySsrEnv(config, viteEnv);
     if (isSsrEnv) {
-        assert(!globalObject.assetsJsonFilePath);
         const outDirs = getOutDirs(config, viteEnv);
         globalObject.assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
         await writeAssetsManifestFile(globalObject.assetsJsonFilePath, config);

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

@@ -6,7 +6,7 @@ import { assertPosixPath, assert, assertUsage, isArray, isCallable } from '../..
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { getAssetsDir } from '../../shared/getAssetsDir.js';
-import { assertModuleId, getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
+import { assertModuleId, getFilePathToShowToUserModule } from '../../shared/getFilePath.js';
 function pluginDistFileNames() {
     return [
         {
@@ -63,7 +63,7 @@ function pluginDistFileNames() {
                                             name = isNodeModules[1];
                                         }
                                         else {
-                                            const filePath = getModuleFilePathAbsolute(id, config);
+                                            const filePath = getFilePathToShowToUserModule(id, config);
                                             name = filePath;
                                             name = name.split('.').slice(0, -1).join('.'); // remove file extension
                                             name = name.split('/').filter(Boolean).join('_');

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

@@ -91,6 +91,11 @@ function pluginCommon(vikeVitePluginOptions) {
                         // Set `--host` for Docker/Podman
                         setDefault('host', true, configFromUser, configFromVike);
                     }
+                    // https://vike.dev/force
+                    if (vikeConfig.config.force !== undefined && configFromUser.optimizeDeps?.force === undefined) {
+                        configFromVike.optimizeDeps ?? (configFromVike.optimizeDeps = {});
+                        configFromVike.optimizeDeps.force = vikeConfig.config.force;
+                    }
                     return configFromVike;
                 },
             },
@@ -131,10 +136,16 @@ function assertVikeCliOrApi(config) {
         assert(!isVitest());
         return;
     }
+    /* This warning is always shown: Vitest loads Vite *before* any Vike JavaScript API can be invoked.
     if (isVitest()) {
-        assertWarning(false, `Unexpected Vitest setup: you seem to be using Vitest together with Vike's Vite plugin but without using Vike's JavaScript API which is unexpected, see ${pc.underline('https://vike.dev/vitest')}`, { onlyOnce: true });
-        return;
+      assertWarning(
+        false,
+        `Unexpected Vitest setup: you seem to be using Vitest together with Vike's Vite plugin but without using Vike's JavaScript API which is unexpected, see ${pc.underline('https://vike.dev/vitest')}`,
+        { onlyOnce: true },
+      )
+      return
     }
+    */
     if (config.server.middlewareMode) {
         assertWarning(false, `${pc.cyan('vite.createServer()')} is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
             onlyOnce: true,

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

@@ -3,7 +3,7 @@ import { assert, assertUsage, assertWarning, capitalizeFirstLetter, isFilePathAb
 import { extractAssetsRE } from './pluginExtractAssets.js';
 import { extractExportNamesRE } from './pluginExtractExportNames.js';
 import pc from '@brillout/picocolors';
-import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
+import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
@@ -42,8 +42,10 @@ function pluginFileEnv() {
                     if (id.endsWith('?direct'))
                         id = id.slice(0, -1 * '?direct'.length);
                     const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
-                    assert(moduleInfo);
-                    const importers = Array.from(moduleInfo.importers)
+                    /* It can fail, no clue why — https://github.com/vikejs/vike/issues/2740
+                    assert(moduleInfo, { moduleId })
+                    */
+                    const importers = (!moduleInfo ? [] : Array.from(moduleInfo.importers))
                         .map((m) => m.id)
                         .filter((id) => id !== null);
                     assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 
@@ -122,7 +124,7 @@ function pluginFileEnv() {
         const envActual = isServerSide ? 'server' : 'client';
         const envExpect = isServerSide ? 'client' : 'server';
         let errMsg;
-        let modulePathPretty = getModuleFilePathAbsolute(modulePath, config);
+        let modulePathPretty = getFilePathToShowToUserModule(modulePath, config);
         if (!noColor) {
             const suffix = getSuffix(envExpect);
             modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
@@ -133,13 +135,14 @@ function pluginFileEnv() {
                 .filter((importer) => 
             // Can be Vike's virtual module: https://github.com/vikejs/vike/issues/2483
             isFilePathAbsolute(importer))
-                .map((importer) => getModuleFilePathAbsolute(importer, config));
+                .map((importer) => getFilePathToShowToUserModule(importer, config))
+                .map((importPath) => pc.cyan(importPath));
             if (importPaths.length > 0) {
                 errMsg += ` by ${joinEnglish(importPaths, 'and')}`;
             }
         }
         if (onlyWarn) {
-            errMsg += ' and, therefore, Vike will prevent building your app for production.';
+            errMsg += ". This is potentially a security issue and Vike won't allow you to build your app for production.";
         }
         return errMsg;
     }

package/dist/esm/node/vite/plugins/pluginReplaceConstantsEnvVars.d.ts

@@ -0,0 +1,3 @@
+export { pluginReplaceConstantsEnvVars };
+import type { Plugin } from 'vite';
+declare function pluginReplaceConstantsEnvVars(): Plugin[];

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

@@ -0,0 +1,129 @@
+export { pluginReplaceConstantsEnvVars };
+import { loadEnv } from 'vite';
+import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst, } from '../utils.js';
+import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { getMagicString } from '../shared/getMagicString.js';
+const PUBLIC_ENV_PREFIX = 'PUBLIC_ENV__';
+const PUBLIC_ENV_ALLOWLIST = [
+    // https://github.com/vikejs/vike/issues/1724
+    'STORYBOOK',
+];
+// TO-DO/eventually:
+// - Make import.meta.env work inside +config.js
+//   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
+//   - Or stop using Vite's `mode` implementation and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
+const skipNodeModules = '/node_modules/';
+const skipIrrelevant = 'import.meta.env.';
+const filterRolldown = {
+    id: {
+        exclude: `**${skipNodeModules}**`,
+    },
+    code: {
+        include: skipIrrelevant,
+    },
+};
+const filterFunction = (id, code) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!code.includes(skipIrrelevant))
+        return false;
+    return true;
+};
+function pluginReplaceConstantsEnvVars() {
+    let envVarsAll;
+    let envPrefix;
+    let config;
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsEnvVars',
+            enforce: 'post',
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                    envVarsAll = loadEnv(config.mode, config.envDir || config.root, '');
+                    envPrefix = getEnvPrefix(config);
+                    config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
+                },
+            },
+            transform: {
+                filter: filterRolldown,
+                handler(code, id, options) {
+                    id = normalizeId(id);
+                    assertPosixPath(id);
+                    assertPosixPath(config.root);
+                    if (!id.startsWith(config.root))
+                        return; // skip linked dependencies
+                    assert(filterFunction(id, code));
+                    const isBuild = config.command === 'build';
+                    const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    // Get regex operations
+                    const replacements = Object.entries(envVarsAll)
+                        // Skip env vars that start with [`config.envPrefix`](https://vite.dev/config/shared-options.html#envprefix) — they are already handled by Vite
+                        .filter(([envName]) => !envPrefix.some((prefix) => envName.startsWith(prefix)))
+                        // Skip constants like import.meta.env.DEV which are already handled by Vite
+                        .filter(([envName]) => !['DEV', 'PROD', 'SSR', 'MODE', 'BASE_URL'].includes(envName))
+                        .map(([envName, envVal]) => {
+                        const envStatement = `import.meta.env.${envName}`;
+                        const envStatementRegExpStr = escapeRegex(envStatement) + '\\b';
+                        // Show error (warning in dev) if client code contains a private environment variable (one that doesn't start with PUBLIC_ENV__ and that isn't included in `PUBLIC_ENV_ALLOWLIST`).
+                        if (isClientSide) {
+                            const skip = assertNoClientSideLeak({
+                                envName,
+                                envStatement,
+                                envStatementRegExpStr,
+                                code,
+                                id,
+                                config,
+                                isBuild,
+                            });
+                            if (skip)
+                                return null;
+                        }
+                        return { regExpStr: envStatementRegExpStr, replacement: envVal };
+                    })
+                        .filter(isNotNullish);
+                    // Apply regex operations
+                    replacements.forEach(({ regExpStr, replacement }) => {
+                        magicString.replaceAll(new RegExp(regExpStr, 'g'), JSON.stringify(replacement));
+                    });
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}
+function getEnvPrefix(config) {
+    const { envPrefix } = config;
+    if (!envPrefix)
+        return [];
+    if (!isArray(envPrefix))
+        return [envPrefix];
+    return envPrefix;
+}
+function assertNoClientSideLeak({ envName, envStatement, envStatementRegExpStr, code, id, config, isBuild, }) {
+    const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_ALLOWLIST.includes(envName);
+    // ✅ All good
+    if (!isPrivate)
+        return;
+    if (!new RegExp(envStatementRegExpStr).test(code))
+        return true;
+    // ❌ Security leak!
+    // - Warning in dev
+    // - assertUsage() and abort when building for production
+    const modulePath = getFilePathToShowToUserModule(id, config);
+    const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
+    const envNameFixed = `${PUBLIC_ENV_PREFIX}${envName}`;
+    const errMsg = `${envStatement} is used in client-side file ${modulePath} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${envNameFixed}, see https://vike.dev/env`;
+    if (isBuild) {
+        assertUsage(false, errMsg);
+    }
+    else {
+        // - Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`).
+        // - Although only showing a warning can be confusing: https://github.com/vikejs/vike/issues/1641
+        assertWarning(false, errMsg, { onlyOnce: true });
+    }
+    assert(!isBuild); // we should abort if building for production
+}

package/dist/esm/node/vite/plugins/pluginReplaceConstantsGlobalThis.d.ts

@@ -0,0 +1,10 @@
+export { pluginReplaceConstantsGlobalThis };
+import type { Plugin } from 'vite';
+declare global {
+    /** Like `import.meta.env.DEV` but works for `node_modules/` packages with `ssr.external` */
+    var __VIKE__IS_DEV: boolean;
+    /** Like `import.meta.env.SSR` but works for `node_modules/` packages with `ssr.external` */
+    var __VIKE__IS_CLIENT: boolean;
+    var __VIKE__IS_DEBUG: boolean;
+}
+declare function pluginReplaceConstantsGlobalThis(): Plugin[];

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

@@ -0,0 +1,77 @@
+export { pluginReplaceConstantsGlobalThis };
+import { assert, isDebug, addVirtualFileIdPrefix, escapeRegex } from '../utils.js';
+import { isViteServerSide_applyToEnvironment, isViteServerSide_configEnvironment, isViteServerSide_extraSafe, } from '../shared/isViteServerSide.js';
+const isDebugVal = isDebug();
+globalThis.__VIKE__IS_CLIENT = false;
+globalThis.__VIKE__IS_DEBUG = isDebugVal;
+const VIRTUAL_FILE_ID = 'virtual:vike:server:globalThis-constants';
+const filterRolldown = {
+    id: {
+        include: new RegExp(escapeRegex(VIRTUAL_FILE_ID)),
+    },
+};
+const filterFunction = (id) => id === VIRTUAL_FILE_ID || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID);
+function pluginReplaceConstantsGlobalThis() {
+    let config;
+    let isDev;
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsGlobalThis:define',
+            config: {
+                handler(config) {
+                    assert(typeof config._isDev === 'boolean');
+                    isDev = config._isDev;
+                    globalThis.__VIKE__IS_DEV = isDev;
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_DEV': JSON.stringify(isDev),
+                            'globalThis.__VIKE__IS_DEBUG': JSON.stringify(isDebugVal),
+                        },
+                    };
+                },
+            },
+            configEnvironment: {
+                handler(name, config) {
+                    const isClientSide = !isViteServerSide_configEnvironment(name, config);
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_CLIENT': JSON.stringify(isClientSide),
+                        },
+                    };
+                },
+            },
+            configResolved(config_) {
+                config = config_;
+            },
+        },
+        {
+            name: 'vike:pluginReplaceConstantsGlobalThis:virtual-file',
+            // We only need the virtual file for the server-side (for node_modules/ packages with ssr.external) — the `define` values above always apply to the client-side.
+            applyToEnvironment(env) {
+                return isViteServerSide_applyToEnvironment(env);
+            },
+            resolveId: {
+                filter: filterRolldown,
+                handler(id) {
+                    assert(filterFunction(id));
+                    assert(id === VIRTUAL_FILE_ID);
+                    return addVirtualFileIdPrefix(id);
+                },
+            },
+            load: {
+                filter: filterRolldown,
+                handler(id, options) {
+                    assert(filterFunction(id));
+                    assert(isViteServerSide_extraSafe(config, this.environment, options));
+                    assert(typeof isDev === 'boolean');
+                    const code = [
+                        `globalThis.__VIKE__IS_DEV = ${JSON.stringify(isDev)};`,
+                        `globalThis.__VIKE__IS_CLIENT = false;`,
+                        `globalThis.__VIKE__IS_DEBUG = ${JSON.stringify(isDebugVal)};`,
+                    ].join('\n');
+                    return code;
+                },
+            },
+        },
+    ];
+}

package/dist/esm/node/vite/plugins/pluginReplaceConstantsPageContext.d.ts

@@ -0,0 +1,3 @@
+export { pluginReplaceConstantsPageContext };
+import type { Plugin } from 'vite';
+declare function pluginReplaceConstantsPageContext(): Plugin[];

package/dist/esm/node/vite/plugins/{pluginReplaceIsClientSide.js → pluginReplaceConstantsPageContext.js}

@@ -1,4 +1,4 @@
-export { pluginReplaceIsClientSide };
+export { pluginReplaceConstantsPageContext };
 import { assert, assertPosixPath } from '../utils.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
@@ -9,6 +9,8 @@ const constantsIsClientSide = [
     'globalContext.isClientSide',
     'pageContext.globalContext.isClientSide',
 ];
+// - See https://vike.dev/pageContext#narrowing-down
+// - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because of https://github.com/rolldown/rolldown/issues/4300
 const skipNodeModules = '/node_modules/';
 const skipIrrelevant = 'Context.isClientSide';
 assert(constantsIsClientSide.every((constant) => constant.endsWith(skipIrrelevant)));
@@ -27,11 +29,11 @@ const filterFunction = (id, code) => {
         return false;
     return true;
 };
-function pluginReplaceIsClientSide() {
+function pluginReplaceConstantsPageContext() {
     let config;
     return [
         {
-            name: 'vike:pluginReplaceIsClientSide',
+            name: 'vike:pluginReplaceConstantsPageContext',
             enforce: 'post',
             apply: 'build',
             configResolved: {

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

@@ -12,6 +12,9 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
+    if (!isForClientSide) {
+        importStatements.push("import 'virtual:vike:server:globalThis-constants';");
+    }
     lines.push('export const pageConfigsSerialized = [');
     lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
     lines.push('];');
@@ -22,7 +25,10 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
         // https://vite.dev/guide/api-environment-frameworks.html
         lines.push('if (import.meta.hot) import.meta.hot.accept();');
     }
-    const code = [...importStatements, ...lines].join('\n');
+    let code = [...importStatements, ...lines].join('\n');
+    if (!isForClientSide) {
+        code = "import 'virtual:vike:server:globalThis-constants';\n" + code;
+    }
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }

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

@@ -23,6 +23,9 @@ async function getCode(config, isForClientSide, isClientRouting, isDev, id) {
     const isBuild = command === 'build';
     assert(isDev === !isBuild);
     let content = '';
+    if (!isForClientSide) {
+        content += "import 'virtual:vike:server:globalThis-constants';\n";
+    }
     {
         const globRoots = getGlobRoots(config);
         debugGlob('Glob roots: ', globRoots);

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

@@ -7,7 +7,7 @@ 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';
-import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
+import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
 import { isRunnable, updateUserFiles } from '../../runtime/globalContext.js';
 import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
@@ -176,7 +176,7 @@ function reloadConfig(filePath, config, op, server) {
     // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
     invalidateVikeVirtualFiles(server);
     {
-        const filePathToShowToUserResolved = getModuleFilePathAbsolute(filePath, config);
+        const filePathToShowToUserResolved = getFilePathToShowToUserModule(filePath, config);
         const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
         logConfigInfo(msg, 'info');
     }

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

@@ -1,9 +1,8 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
 export { getFilePathAbsoluteUserRootDir };
-export { getFilePathToShowToUserFromUnknown };
-export { getModuleFilePathAbsolute };
-export { getModuleFilePathRelative };
+export { getFilePathToShowToUserUnknown };
+export { getFilePathToShowToUserModule };
 export { cleanFilePathUnknown };
 export { assertModuleId };
 import type { FilePathResolved, FilePathUnresolved } from '../../../types/FilePath.js';
@@ -24,8 +23,7 @@ declare function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, us
     filePathAbsoluteFilesystem: string;
     userRootDir: string;
 }): string | null;
-declare function getModuleFilePathAbsolute(moduleId: string, config: ResolvedConfig): string;
-declare function getModuleFilePathRelative(moduleId: string, config: ResolvedConfig): string;
+declare function getFilePathToShowToUserModule(moduleId: string, config: ResolvedConfig): string;
 declare function assertModuleId(moduleId: string): void;
-declare function getFilePathToShowToUserFromUnknown(filePathUnknown: string, userRootDir: string): string;
+declare function getFilePathToShowToUserUnknown(filePathUnknown: string, userRootDir: string): string;
 declare function cleanFilePathUnknown(filePathUnknown: string): string;

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

@@ -1,9 +1,8 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
 export { getFilePathAbsoluteUserRootDir };
-export { getFilePathToShowToUserFromUnknown };
-export { getModuleFilePathAbsolute };
-export { getModuleFilePathRelative };
+export { getFilePathToShowToUserUnknown };
+export { getFilePathToShowToUserModule };
 export { cleanFilePathUnknown };
 export { assertModuleId };
 import path from 'node:path';
@@ -107,15 +106,11 @@ function getFilePathRelative({ filePathAbsoluteFilesystem, userRootDir, }) {
         return { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
     }
 }
-function getModuleFilePathAbsolute(moduleId, config) {
-    const { filePathAbsoluteUserRootDir, filePathAbsoluteFilesystem } = getModuleFilePath(moduleId, config);
+function getFilePathToShowToUserModule(moduleId, config) {
+    const { filePathAbsoluteUserRootDir, filePathAbsoluteFilesystem } = getFilePathModule(moduleId, config);
     return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
 }
-function getModuleFilePathRelative(moduleId, config) {
-    const { filePathRelativeUserRootDir } = getModuleFilePath(moduleId, config);
-    return filePathRelativeUserRootDir;
-}
-function getModuleFilePath(moduleId, config) {
+function getFilePathModule(moduleId, config) {
     const userRootDir = config.root;
     assertModuleId(moduleId);
     assertPosixPath(userRootDir);
@@ -132,7 +127,7 @@ function assertModuleId(moduleId) {
     assertPosixPath(moduleId);
     assertFilePathAbsoluteFilesystem(moduleId); // Can moduleId be something else than the filesystem absolute path?
 }
-function getFilePathToShowToUserFromUnknown(
+function getFilePathToShowToUserUnknown(
 // We don't have any guarantee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
 filePathUnknown, userRootDir) {
     assertPosixPath(userRootDir);

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

@@ -1,18 +1,21 @@
 export { isViteServerSide };
-export { isViteClientSide };
 export { isViteServerSide_viteEnvOptional };
 export { isViteServerSide_onlySsrEnv };
 export { isViteServerSide_extraSafe };
+export { isViteServerSide_applyToEnvironment };
+export { isViteServerSide_configEnvironment };
 export type { ViteEnv };
-import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig } from 'vite';
+import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig, Plugin } from 'vite';
 type ViteEnv = {
     name?: string;
     config: EnvironmentOptions | Environment['config'];
 };
 declare function isViteServerSide(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_viteEnvOptional(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv | undefined): boolean;
-declare function isViteClientSide(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_extraSafe(config: ResolvedConfig, viteEnv: ViteEnv, options: {
     ssr?: boolean;
 } | undefined): boolean;
+type PartialEnvironment = Parameters<NonNullable<Plugin['applyToEnvironment']>>[0];
+declare function isViteServerSide_applyToEnvironment(env: PartialEnvironment): boolean;
+declare function isViteServerSide_configEnvironment(name: string, config: EnvironmentOptions): boolean;

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

@@ -1,8 +1,9 @@
 export { isViteServerSide };
-export { isViteClientSide };
 export { isViteServerSide_viteEnvOptional };
 export { isViteServerSide_onlySsrEnv };
 export { isViteServerSide_extraSafe };
+export { isViteServerSide_applyToEnvironment };
+export { isViteServerSide_configEnvironment };
 import { assert } from '../../../utils/assert.js';
 function isViteServerSide_impl(configGlobal, viteEnv) {
     assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
@@ -42,9 +43,6 @@ function isViteServerSide(configGlobal, viteEnv) {
 function isViteServerSide_viteEnvOptional(configGlobal, viteEnv) {
     return isViteServerSide_impl(configGlobal, viteEnv);
 }
-function isViteClientSide(configGlobal, viteEnv) {
-    return !isViteServerSide(configGlobal, viteEnv);
-}
 // Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
 function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
     return viteEnv.name ? viteEnv.name === 'ssr' : isViteServerSide(configGlobal, viteEnv);
@@ -64,3 +62,14 @@ function isViteServerSide_extraSafe(config, viteEnv, options) {
     assert(options.ssr === isServerSide, debug);
     return isServerSide;
 }
+function isViteServerSide_applyToEnvironment(env) {
+    const { consumer } = env.config;
+    return isViteServerSide_consumer(consumer);
+}
+function isViteServerSide_configEnvironment(name, config) {
+    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
+    return isViteServerSide_consumer(consumer);
+}
+function isViteServerSide_consumer(consumer) {
+    return consumer !== 'client';
+}

package/dist/esm/node/vite/shared/loggerNotProd/errorWithCodeSnippet.js

@@ -8,7 +8,7 @@ export { getPrettyErrMessage };
 // Copied & adapted from https://github.com/vitejs/vite/blob/9c114c5c72a6af87e3330d5573362554b4511265/packages/vite/src/node/server/middlewares/error.ts
 import pc from '@brillout/picocolors';
 import { assert, escapeRegex, isObject, removeEmptyLines, stripAnsi } from '../../utils.js';
-import { cleanFilePathUnknown, getFilePathToShowToUserFromUnknown } from '../getFilePath.js';
+import { cleanFilePathUnknown, getFilePathToShowToUserUnknown } from '../getFilePath.js';
 function isErrorWithCodeSnippet(err) {
     if (!isObject(err)) {
         return false;
@@ -47,7 +47,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     let { id, frame } = err;
     const msgFirstLine = [
         pc.red('Failed to transpile'),
-        pc.bold(pc.red(getFilePathToShowToUserFromUnknown(id, userRootDir))),
+        pc.bold(pc.red(getFilePathToShowToUserUnknown(id, userRootDir))),
         pc.red('because:'),
     ].join(' ');
     const errMsg = getPrettyErrMessage(err);