vike 0.4.267-commit-b005535 → 0.4.267-commit-7884d91

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntry.d.ts

@@ -1,3 +1,4 @@
 export { generateVirtualFileGlobalEntry };
+import type { RuntimeEnvRuntime } from './getConfigValueSourcesRelevant.js';
 import '../../assertEnvVite.js';
-declare function generateVirtualFileGlobalEntry(isForClientSide: boolean, isDev: boolean, id: string, isClientRouting: boolean): Promise<string>;
+declare function generateVirtualFileGlobalEntry(runtimeEnv: RuntimeEnvRuntime, id: string): Promise<string>;

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

@@ -4,25 +4,31 @@ import { debug } from './debug.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { serializeConfigValues, } from '../../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
 import { VIRTUAL_FILE_ID_constantsGlobalThis } from '../pluginReplaceConstantsGlobalThis.js';
+import { getEnvironmentEntryPlaceholder } from '../build/pluginEnvironmentEntries.js';
 import '../../assertEnvVite.js';
-async function generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting) {
+async function generateVirtualFileGlobalEntry(runtimeEnv, id) {
     const vikeConfig = await getVikeConfigInternal(true);
-    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
-    return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
+    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal, _additionalEnvironmentNames: additionalEnvironmentNames, } = vikeConfig;
+    return getCode(pageConfigs, pageConfigGlobal, runtimeEnv, id, additionalEnvironmentNames);
 }
-function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
+function getCode(pageConfigs, pageConfigGlobal, runtimeEnv, id, additionalEnvironmentNames) {
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
+    const { environmentName, isDev } = runtimeEnv;
+    const isForClientSide = environmentName === 'client';
     if (!isForClientSide) {
         importStatements.push(`import '${VIRTUAL_FILE_ID_constantsGlobalThis}';`);
     }
     lines.push('export const pageConfigsSerialized = [');
-    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
+    lines.push(getCodePageConfigsSerialized(pageConfigs, runtimeEnv, importStatements, filesEnv));
     lines.push('];');
     lines.push('export const pageConfigGlobalSerialized = {');
-    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
+    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, runtimeEnv, importStatements, filesEnv));
     lines.push('};');
+    if (environmentName === 'server') {
+        lines.push(getCodeEnvironmentEntries(additionalEnvironmentNames, isDev, importStatements));
+    }
     if (!isForClientSide && isDev) {
         // https://vite.dev/guide/api-environment-frameworks.html
         lines.push('if (import.meta.hot) import.meta.hot.accept();');
@@ -31,10 +37,21 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     if (!isForClientSide) {
         code = `import '${VIRTUAL_FILE_ID_constantsGlobalThis}';\n` + code;
     }
-    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    debug(id, `${environmentName.toUpperCase()}-SIDE`, code);
     return code;
 }
-function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
+// The global entries of the additional environments (e.g. `rsc`), loaded by loadPageContextEnvironments.ts
+// - In development, they're loaded with the environment's module runner instead
+function getCodeEnvironmentEntries(additionalEnvironmentNames, isDev, importStatements) {
+    const entries = additionalEnvironmentNames.map((name, i) => {
+        if (isDev)
+            return `${JSON.stringify(name)}: null`;
+        importStatements.push(`import * as environmentEntry${i} from ${JSON.stringify(getEnvironmentEntryPlaceholder(name))};`);
+        return `${JSON.stringify(name)}: environmentEntry${i}`;
+    });
+    return `export const environmentEntries = { ${entries.join(', ')} };`;
+}
+function getCodePageConfigsSerialized(pageConfigs, runtimeEnv, importStatements, filesEnv) {
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
@@ -42,20 +59,20 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        const virtualFileId = JSON.stringify(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide }));
+        const virtualFileId = JSON.stringify(generateVirtualFileId({ type: 'page-entry', pageId, environmentName: runtimeEnv.environmentName }));
         lines.push(`    loadVirtualFilePageEntry: () => ({ moduleId: ${virtualFileId}, moduleExportsPromise: import(${virtualFileId}) }),`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', true));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, runtimeEnv, '    ', true));
         lines.push(`    },`);
         lines.push(`  },`);
     });
     const code = lines.join('\n');
     return code;
 }
-function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
+function getCodePageConfigGlobalSerialized(pageConfigGlobal, runtimeEnv, importStatements, filesEnv) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', null));
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, runtimeEnv, '    ', null));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

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

@@ -18,7 +18,8 @@ import '../../assertEnvVite.js';
 async function generateVirtualFileGlobalEntryWithOldDesign(id, options, config, env, isDev) {
     const idParsed = parseVirtualFileId(id);
     assert(idParsed && idParsed.type === 'global-entry');
-    const { isForClientSide, isClientRouting } = idParsed;
+    const { environmentName, isClientRouting } = idParsed;
+    const isForClientSide = environmentName === 'client';
     assert(isForClientSide === !isViteServerSide_extraSafe(config, env, options));
     const code = await getCode(config, isForClientSide, isClientRouting, isDev, id);
     return code;
@@ -75,7 +76,7 @@ export const pageFilesExportNamesEager = {};
 export const pageFilesList = [];
 export const neverLoaded = {};
 
-${await generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting)}
+${await generateVirtualFileGlobalEntry({ environmentName: isForClientSide ? 'client' : 'server', isClientRouting, isDev }, id)}
 
 `;
     const vikeConfig = await getVikeConfigInternal();

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

@@ -18,7 +18,7 @@ async function generateVirtualFilePageEntry(id, isDev) {
       assert(result.isForClientSide === isForClientSide)
     }
     */
-    const { pageId, isForClientSide } = result;
+    const { pageId, environmentName } = result;
     const vikeConfig = await getVikeConfigInternal(true);
     const { _pageConfigs: pageConfigs } = vikeConfig;
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
@@ -31,20 +31,20 @@ async function generateVirtualFilePageEntry(id, isDev) {
             throw getProjectError(`Outdated request. Try again. ${getDebugInfoStr({ id, pageId })}`);
         }
     }
-    const code = getCode(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
-    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    const code = getCode(pageConfig, environmentName, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
+    debug(id, `${environmentName.toUpperCase()}-SIDE`, code);
     return code;
 }
-function getCode(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
+function getCode(pageConfig, environmentName, pageId, includeAssetsImportedByServer, 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, { isForClientSide, isClientRouting, isDev }, '', false));
+    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { environmentName, isClientRouting, isDev }, '', false));
     lines.push('};');
-    if (!handleAssetsManifest_isFixEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
-        importStatements.push(`import '${extractAssetsAddQuery(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide: false }))}'`);
+    if (!handleAssetsManifest_isFixEnabled() && includeAssetsImportedByServer && environmentName === 'client' && !isDev) {
+        importStatements.push(`import '${extractAssetsAddQuery(generateVirtualFileId({ type: 'page-entry', pageId, environmentName: 'server' }))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');
     return code;

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

@@ -3,15 +3,17 @@ export { getConfigValueSourceRelevantAnyEnv };
 export { isRuntimeEnvMatch };
 export { isConfigSourceValueNull };
 export type { RuntimeEnv };
+export type { RuntimeEnvRuntime };
 import type { ConfigEnv, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
 import '../../assertEnvVite.js';
-type RuntimeEnv = {
-    isForClientSide: boolean;
-    isClientRouting: boolean;
-    isDev?: boolean;
-} | {
+type RuntimeEnv = RuntimeEnvRuntime | {
     isForConfig: true;
 };
+type RuntimeEnvRuntime = {
+    environmentName: string;
+    isClientRouting?: boolean;
+    isDev: boolean;
+};
 type PageConfigPartial = Pick<PageConfigBuildTime | PageConfigGlobalBuildTime, 'configValueSources' | 'configDefinitions'>;
 declare function getConfigValueSourcesRelevant(configName: string, runtimeEnv: RuntimeEnv, pageConfig: PageConfigPartial): ConfigValueSource[];
 declare function getConfigValueSourceRelevantAnyEnv(configName: string, pageConfig: PageConfigPartial): null | ConfigValueSource;

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

@@ -47,16 +47,10 @@ 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;
-    }
+    if (!configEnv[runtimeEnv.environmentName])
+        return false;
+    if (runtimeEnv.environmentName === 'client' && configEnv.clientRoutingOnly && !runtimeEnv.isClientRouting)
+        return false;
     // Production/development
     if (configEnv.production !== undefined) {
         assert(typeof configEnv.production === 'boolean');

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

@@ -2,6 +2,7 @@ export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
 import { generateVirtualFilePageEntry } from './pluginVirtualFiles/generateVirtualFilePageEntry.js';
 import { generateVirtualFileGlobalEntryWithOldDesign } from './pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js';
+import { generateVirtualFileGlobalEntry } from './pluginVirtualFiles/generateVirtualFileGlobalEntry.js';
 import { escapeRegex } from '../../../utils/escapeRegex.js';
 import { isScriptFile } from '../../../utils/isScriptFile.js';
 import { addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, virtualFileIdPrefix1, virtualFileIdPrefix2, } from '../../../utils/virtualFileId.js';
@@ -9,6 +10,8 @@ import { assert } from '../../../utils/assert.js';
 import { assertPosixPath } from '../../../utils/path.js';
 import { parseVirtualFileId } from '../../../shared-server-node/virtualFileId.js';
 import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
+import { isEnvironmentBuiltIn } from '../../../shared-server-node/vike-environments.js';
+import { isRunnableDevEnvironment } from '../../../utils/isRunnableDevEnvironment.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerDev.js';
 import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
@@ -73,6 +76,9 @@ function pluginVirtualFiles() {
                             return code;
                         }
                         if (idParsed.type === 'global-entry') {
+                            if (!isEnvironmentBuiltIn(idParsed.environmentName)) {
+                                return generateVirtualFileGlobalEntry({ environmentName: idParsed.environmentName, isDev }, id);
+                            }
                             const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
                             return code;
                         }
@@ -179,6 +185,20 @@ function invalidateVikeVirtualFiles(server) {
     vikeVirtualFiles.forEach((mod) => {
         server.moduleGraph.invalidateModule(mod);
     });
+    // - `server.moduleGraph` only covers the `client` and `ssr` environments, while additional environments (e.g. `rsc`) also load Vike's virtual files
+    Object.values(server.environments).forEach((environment) => {
+        environment.moduleGraph.idToModuleMap.forEach((mod, id) => {
+            if (parseVirtualFileId(id))
+                environment.moduleGraph.invalidateModule(mod);
+        });
+        if (!isRunnableDevEnvironment(environment))
+            return;
+        const { evaluatedModules } = environment.runner;
+        evaluatedModules.idToModuleMap.forEach((mod, id) => {
+            if (parseVirtualFileId(id))
+                evaluatedModules.invalidateModule(mod);
+        });
+    });
 }
 function getVikeVirtualFiles(server) {
     const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())

package/dist/node/vite/shared/addSsrMiddleware.js

@@ -50,8 +50,20 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
                     res.setHeader(name, value);
         }
         const { httpResponse } = pageContext;
-        httpResponse.headers.forEach(([name, value]) => res.setHeader(name, value));
+        setHeadersWithMultipleCookies(res, httpResponse.headers);
         res.statusCode = httpResponse.statusCode;
         httpResponse.pipe(res);
     });
 }
+// A response can have several Set-Cookie headers: res.setHeader() would only keep the last one
+function setHeadersWithMultipleCookies(res, headers) {
+    const cookies = [];
+    headers.forEach(([name, value]) => {
+        if (name.toLowerCase() === 'set-cookie')
+            cookies.push(value);
+        else
+            res.setHeader(name, value);
+    });
+    if (cookies.length > 0)
+        res.setHeader('set-cookie', cookies);
+}

package/dist/node/vite/shared/getAssetsDir.d.ts

@@ -1,4 +1,5 @@
 export { getAssetsDir };
-import type { ResolvedConfig } from 'vite';
 import '../assertEnvVite.js';
-declare function getAssetsDir(config: ResolvedConfig): string;
+declare function getAssetsDir(build: {
+    assetsDir: string;
+}): string;

package/dist/node/vite/shared/getAssetsDir.js

@@ -1,9 +1,9 @@
 export { getAssetsDir };
 import { assertUsage } from '../../../utils/assert.js';
 import '../assertEnvVite.js';
-function getAssetsDir(config) {
-    let { assetsDir } = config.build;
-    assertUsage(assetsDir, `${assetsDir} cannot be an empty string`);
+function getAssetsDir(build) {
+    let { assetsDir } = build;
+    assertUsage(assetsDir, "Vite's build.assetsDir cannot be an empty string");
     assetsDir = assetsDir.split(/\/|\\/).filter(Boolean).join('/');
     return assetsDir;
 }

package/dist/node/vite/shared/isViteCli.d.ts

@@ -1,6 +1,6 @@
 export { isViteCli };
 export { getViteCliArgs };
-export { getViteBuildCliArgs };
+export { getViteCliArgsMinimal };
 export { getViteCliCommand };
 import '../assertEnvVite.js';
 declare function isViteCli(): boolean;
@@ -12,8 +12,8 @@ type ConfigFromCli = {
 };
 type ViteCommand = 'dev' | 'build' | 'optimize' | 'preview';
 declare function getViteCliCommand(): ViteCommand | null;
-declare function getViteBuildCliArgs(): null | ConfigFromCli;
-declare function getViteCliArgs(): null | {
+declare function getViteCliArgsMinimal(): null | {
     root: string | undefined;
     configFile: string | undefined;
 };
+declare function getViteCliArgs(): null | ConfigFromCli;

package/dist/node/vite/shared/isViteCli.js

@@ -1,7 +1,8 @@
 export { isViteCli };
 export { getViteCliArgs };
-export { getViteBuildCliArgs };
+export { getViteCliArgsMinimal };
 export { getViteCliCommand };
+// Copied from Vite's CLI
 import { assert } from '../../../utils/assert.js';
 import { isObject } from '../../../utils/isObject.js';
 import { isToolCli } from '../../../utils/isToolCli.js';
@@ -11,48 +12,23 @@ const desc = 'vike:vite-cli-simulation';
 function isViteCli() {
     return isToolCli('vite');
 }
-function getViteCliCommand() {
-    if (!isViteCli())
-        return null;
-    let command;
-    const setCommand = (cmd) => {
-        assert(command === undefined);
-        command = cmd;
+function parseViteCli() {
+    let viteCli;
+    const onCommand = (command) => (root, options) => {
+        assert(viteCli === undefined);
+        assert(root === undefined || typeof root === 'string');
+        assert(isObject(options));
+        // Same as Vite: duplicated options => the last value wins
+        for (const [key, value] of Object.entries(options)) {
+            if (Array.isArray(value))
+                options[key] = value[value.length - 1];
+        }
+        assert(options.config === undefined || typeof options.config === 'string');
+        viteCli = { command, root, options };
     };
-    // Copied & adapted from Vite
-    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L186-L188
-    const cli = cac(desc);
-    // dev
-    cli
-        .command('[root]', desc)
-        .alias('serve')
-        .alias('dev')
-        .action(() => {
-        setCommand('dev');
-    });
-    // build
-    cli.command('build [root]', desc).action(() => {
-        setCommand('build');
-    });
-    // optimize
-    cli.command('optimize [root]', desc).action(() => {
-        setCommand('optimize');
-    });
-    // preview
-    cli.command('preview [root]', desc).action(() => {
-        setCommand('preview');
-    });
-    cli.parse();
-    assert(command);
-    return command;
-}
-function getViteBuildCliArgs() {
-    if (!isViteCli())
-        return null;
-    // Copied & adapted from Vite
+    // We need to declare all Vite's options, otherwise cac consumes the next argument as the value of boolean options (e.g. `vite build --emptyOutDir some-root`).
     const cli = cac(desc);
     // Common configs
-    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L169-L182
     cli
         .option('-c, --config <file>', desc)
         .option('--base <path>', desc)
@@ -62,8 +38,22 @@ function getViteBuildCliArgs() {
         .option('-d, --debug [feat]', desc)
         .option('-f, --filter <filter>', desc)
         .option('-m, --mode <mode>', desc);
-    // Build configs
-    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L286-L322
+    // dev
+    cli
+        .command('[root]', desc)
+        .alias('serve')
+        .alias('dev')
+        .option('--host [host]', desc)
+        .option('--port <port>', desc)
+        .option('--open [path]', desc)
+        .option('--cors', desc)
+        .option('--strictPort', desc)
+        .option('--force', desc)
+        .option('--experimentalBundle', desc)
+        // Options that this copy doesn't declare (e.g. added by newer Vite versions) are still validated by Vite's own CLI, which throws `Unknown option` for options Vite doesn't know
+        .allowUnknownOptions()
+        .action(onCommand('dev'));
+    // build
     cli
         .command('build [root]', desc)
         .option('--target <target>', desc)
@@ -71,35 +61,61 @@ function getViteBuildCliArgs() {
         .option('--assetsDir <dir>', desc)
         .option('--assetsInlineLimit <number>', desc)
         .option('--ssr [entry]', desc)
-        .option('--sourcemap', desc)
+        .option('--sourcemap [output]', desc)
         .option('--minify [minifier]', desc)
         .option('--manifest [name]', desc)
         .option('--ssrManifest [name]', desc)
         .option('--emptyOutDir', desc)
         .option('-w, --watch', desc)
         .option('--app', desc)
-        .action((root, options) => {
-        assert(isObject(options));
-        assert(root === undefined || typeof root === 'string');
-        assert(options.config === undefined || typeof options.config === 'string');
-        // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L331-L346
-        const buildOptions = cleanGlobalCLIOptions(cleanBuilderCLIOptions(options));
-        configFromCli = {
-            root,
-            base: options.base,
-            mode: options.mode,
-            configFile: options.config,
-            configLoader: options.configLoader,
-            logLevel: options.logLevel,
-            clearScreen: options.clearScreen,
-            build: buildOptions,
-            ...(options.app ? { builder: {} } : {}),
-        };
-    });
-    let configFromCli = null;
+        .allowUnknownOptions()
+        .action(onCommand('build'));
+    // optimize
+    cli.command('optimize [root]', desc).option('--force', desc).allowUnknownOptions().action(onCommand('optimize'));
+    // preview
+    cli
+        .command('preview [root]', desc)
+        .option('--host [host]', desc)
+        .option('--port <port>', desc)
+        .option('--strictPort', desc)
+        .option('--open [path]', desc)
+        .option('--outDir <dir>', desc)
+        .allowUnknownOptions()
+        .action(onCommand('preview'));
     cli.parse();
-    return configFromCli;
-    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L99
+    assert(viteCli);
+    return viteCli;
+}
+function getViteCliCommand() {
+    if (!isViteCli())
+        return null;
+    return parseViteCli().command;
+}
+function getViteCliArgsMinimal() {
+    if (!isViteCli())
+        return null;
+    const { root, options } = parseViteCli();
+    return { root, configFile: options.config };
+}
+function getViteCliArgs() {
+    if (!isViteCli())
+        return null;
+    const { command, root, options } = parseViteCli();
+    if (command !== 'build')
+        return null;
+    // Like Vite: all options except the global ones go to `build`
+    const buildOptions = cleanGlobalCLIOptions(cleanBuilderCLIOptions(options));
+    return {
+        root,
+        base: options.base,
+        mode: options.mode,
+        configFile: options.config,
+        configLoader: options.configLoader,
+        logLevel: options.logLevel,
+        clearScreen: options.clearScreen,
+        build: buildOptions,
+        ...(options.app ? { builder: {} } : {}),
+    };
     function cleanGlobalCLIOptions(options) {
         const ret = { ...options };
         delete ret['--'];
@@ -129,29 +145,9 @@ function getViteBuildCliArgs() {
         }
         return ret;
     }
-    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L141
     function cleanBuilderCLIOptions(options) {
         const ret = { ...options };
         delete ret.app;
         return ret;
     }
 }
-function getViteCliArgs() {
-    if (!isViteCli())
-        return null;
-    const cli = cac(desc);
-    cli.option('-c, --config <file>', desc);
-    let result = null;
-    const setResult = (root, options) => {
-        assert(root === undefined || typeof root === 'string');
-        assert(isObject(options));
-        assert(options.config === undefined || typeof options.config === 'string');
-        result = { root, configFile: options.config };
-    };
-    cli.command('[root]', desc).alias('serve').alias('dev').action(setResult);
-    cli.command('build [root]', desc).action(setResult);
-    cli.command('optimize [root]', desc).action(setResult);
-    cli.command('preview [root]', desc).action(setResult);
-    cli.parse();
-    return result;
-}

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

@@ -4,8 +4,7 @@ export { isViteServerSide_onlySsrEnv };
 export { isViteServerSide_extraSafe };
 export { isViteServerSide_applyToEnvironment };
 export { isViteServerSide_configEnvironment };
-import { viteVersionMin } from '../../../utils/assertViteVersion.js';
-import { assert, assertUsage } from '../../../utils/assert.js';
+import { assert } from '../../../utils/assert.js';
 import '../assertEnvVite.js';
 function isViteServerSide_impl(configGlobal, viteEnv) {
     assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
@@ -60,11 +59,7 @@ function isViteServerSide_extraSafe(config, viteEnv, options) {
         optionsSsr: options?.ssr ?? null,
     };
     assert(options, debug);
-    /* TO-DO/eventually: use internal assert() instead of assertUsage() once we can use this.meta.viteVersion — see utils/assertViteVersion.ts
-    assert(typeof options.ssr === 'boolean', debug)
-    /*/
-    assertUsage(typeof options.ssr === 'boolean', `You're using an old Vite version — update Vite to ${viteVersionMin} or above.`);
-    //*/
+    assert(typeof options.ssr === 'boolean', debug);
     assert(options.ssr === isServerSide, debug);
     return isServerSide;
 }

package/dist/node/vite/shared/resolveVikeConfigInternal/metaBuiltIn.d.ts

@@ -57,7 +57,7 @@ type ConfigDefinition = {
     /** Whether changes to the configuration should trigger a Vite restart. */
     vite?: boolean;
     /** @experimental */
-    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
+    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed, isDev: boolean) => unknown;
     /** @experimental */
     _valueIsFilePath?: true;
     /** @experimental */

package/dist/node/vite/shared/resolveVikeConfigInternal/metaBuiltIn.js

@@ -53,14 +53,15 @@ const metaBuiltIn = {
     route: {
         env: {
             server: true,
-            client: 'if-client-routing',
+            client: true,
+            clientRoutingOnly: true,
             // For vite-plugin-vercel
             config: true,
         },
         eager: true,
     },
     guard: {
-        env: { server: true, client: 'if-client-routing' },
+        env: { server: true, client: true, clientRoutingOnly: true },
     },
     data: {
         env: { server: true },
@@ -70,7 +71,7 @@ const metaBuiltIn = {
         cumulative: true,
     },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
-        env: { server: true, client: 'if-client-routing' },
+        env: { server: true, client: true, clientRoutingOnly: true },
         eager: true,
     },
     filesystemRoutingRoot: {
@@ -114,12 +115,13 @@ const metaBuiltIn = {
     hasServerOnlyHook: {
         env: { client: true },
         eager: true,
-        _computed: (pageConfig) => {
+        _computed: (pageConfig, isDev) => {
             const sources = ['data', 'onBeforeRender', 'onCreatePageContext', 'guard']
                 .map((hookName) => getConfigValueSourcesRelevant(hookName, {
-                isForClientSide: false,
+                environmentName: 'server',
                 // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
                 isClientRouting: true,
+                isDev,
             }, pageConfig))
                 .flat(1)
                 // Server-only
@@ -253,7 +255,7 @@ const metaBuiltIn = {
         global: true,
     },
     onBeforeRoute: {
-        env: { server: true, client: 'if-client-routing' },
+        env: { server: true, client: true, clientRoutingOnly: true },
         eager: true,
         global: true,
     },

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

@@ -3,6 +3,7 @@ export type { VikeConfig };
 export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { setVikeConfigContext };
+export { setViteEnvironmentNames };
 export { isVikeConfigContextSet };
 export { reloadVikeConfig };
 export { isV1Design };
@@ -36,6 +37,7 @@ type VikeConfigInternal = GlobalConfigPublic & {
     _pageConfigGlobal: PageConfigGlobalBuildTime;
     _vikeConfigDependencies: Set<string>;
     _extensions: PlusFile[];
+    _additionalEnvironmentNames: string[];
     prerenderContext: PrerenderContext;
 };
 declare function reloadVikeConfig(): void;
@@ -53,6 +55,7 @@ type VikeConfig = Pick<VikeConfigInternal, 'config' | 'pages' | 'prerenderContex
     dangerouslyUseInternals: DangerouslyUseInternals<VikeConfigInternal>;
 };
 declare function setVikeConfigContext(vikeConfigCtx_: VikeConfigContext): void;
+declare function setViteEnvironmentNames(viteEnvironmentNames: string[]): Promise<void>;
 declare function isVikeConfigContextSet(): boolean;
 declare function getVikeConfigInternalOptional(): Promise<null | VikeConfigInternal>;
 declare function isV1Design(): boolean;
@@ -74,7 +77,7 @@ declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinition
         isGlobalLocation: boolean;
     }) => boolean);
     vite?: boolean;
-    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
+    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed, isDev: boolean) => unknown;
     _valueIsFilePath?: true;
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     isDefinedByPeerDependency?: undefined;