vike 0.4.267 → 0.4.268

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

@@ -65,6 +65,8 @@ const optimizeDeps = {
                 */
                 '@brillout/vite-plugin-server-entry',
                 'vike',
+                // Needed so that Vike doesn't get the user's @universal-middleware/core version (that might differ from Vike's @universal-middleware/core version). (Vite pre-bundles one copy per package name for every importer: https://github.com/vitejs/vite/issues/9948)
+                '@universal-middleware/core',
             ],
         },
     },
@@ -191,7 +193,7 @@ async function getPageDeps(config, pageConfigs, pageConfigGlobal) {
             [...pageConfigs, pageConfigGlobal].forEach((pageConfig) => {
                 Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
                     const runtimeEnv = {
-                        isForClientSide,
+                        environmentName: isForClientSide ? 'client' : 'server',
                         isDev: true,
                         // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
                         isClientRouting: true,
@@ -211,7 +213,7 @@ async function getPageDeps(config, pageConfigs, pageConfigGlobal) {
     }
     // V0.4 design
     {
-        const pageFiles = await findPageFiles(config, ['.page', '.page.client'], true);
+        const pageFiles = await findPageFiles(config, ['.page', '.page.client']);
         const userRootDir = config.root;
         pageFiles.forEach((filePathAbsoluteUserRootDir) => {
             const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });

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

@@ -16,7 +16,10 @@ const filterRolldown = {
         include: new RegExp(escapeRegex(VIRTUAL_FILE_ID_constantsGlobalThis)),
     },
 };
-const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
+const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis ||
+    // Vite re-resolves the resolved ID and its URL when a plugin adds the module as a watch file (@vitejs/plugin-rsc)
+    id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis) ||
+    id === `/@id/__x00__${VIRTUAL_FILE_ID_constantsGlobalThis}`;
 // ===
 function pluginReplaceConstantsGlobalThis() {
     let config;
@@ -63,9 +66,8 @@ function pluginReplaceConstantsGlobalThis() {
             resolveId: {
                 filter: filterRolldown,
                 handler(id) {
-                    assert(filterFunction(id));
-                    assert(id === VIRTUAL_FILE_ID_constantsGlobalThis);
-                    return addVirtualFileIdPrefix(id);
+                    assert(filterFunction(id), { id });
+                    return addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
                 },
             },
             load: {

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,11 +6,13 @@ import { pluginServerEntryInject } from './pluginUniversalDeploy/pluginServerEnt
 import { getDeployConfig } from './pluginUniversalDeploy/getDeployConfig.js';
 import { pluginCommon } from './pluginUniversalDeploy/common.js';
 import { hasVikeServerOrVikePhoton } from './pluginUniversalDeploy/detectDeprecated.js';
-import { getServerConfig } from './pluginUniversalDeploy/getServerConfig.js';
+import { getServerConfig, getServerEntryFilePath_ifDev } from './pluginUniversalDeploy/getServerConfig.js';
 import { pluginServerEntryAlias } from './pluginUniversalDeploy/pluginServerEntryAlias.js';
-import { pluginUnwrapProdOptions } from './pluginUniversalDeploy/pluginUnwrapProdOptions.js';
+import { pluginWrapServerFile } from './pluginUniversalDeploy/pluginWrapServerFile.js';
+import { getViteCliCommand } from '../shared/isViteCli.js';
 import { unique } from '../../../utils/unique.js';
 import { assertUsage } from '../../../utils/assert.js';
+import pc from '@brillout/picocolors';
 import '../assertEnvVite.js';
 function pluginUniversalDeploy(vikeConfig) {
     if (hasVikeServerOrVikePhoton(vikeConfig))
@@ -25,9 +27,31 @@ function pluginUniversalDeploy(vikeConfig) {
             }),
             precompress(vikeConfig.config.precompress),
         ];
-    const { serverEntryVike, serverEntryId, serverFilePath } = serverConfig;
+    const { serverEntryVike, serverEntryId, serverFilePath, serverEntryFilePath } = serverConfig;
+    const isServerEntryDev = !!getServerEntryFilePath_ifDev(vikeConfig);
+    // Vite's CLI always starts Vite's own server => it can't run +serverEntry.js
+    assertUsage(!(isServerEntryDev && getViteCliCommand() === 'dev'), `${pc.cyan('+serverEntry.js')} (without ${pc.cyan('+server.js')}) requires ${pc.cyan('$ vike dev')} instead of ${pc.cyan('$ vite dev')} (because Vite's CLI always starts Vite's own server)`);
     return [
-        ...universalDeploy({ node: { precompress: vikeConfig.config.precompress } }),
+        ...(!serverEntryFilePath
+            ? universalDeploy({ node: { precompress: vikeConfig.config.precompress } })
+            : [
+                // +serverEntry.js is the production server entry dist/server/index.mjs (instead of @universal-deploy/node's server)
+                // https://vike.dev/serverEntry
+                ...universalDeploy({
+                    entry: {
+                        id: serverEntryFilePath,
+                        // Without +server.js, +serverEntry.js handles requests itself (it calls renderPage() instead of using vike:server) and `$ vike dev` runs it
+                        catchAll: !isServerEntryDev,
+                    },
+                }),
+                precompress(vikeConfig.config.precompress),
+                resolveTargets((targets) => {
+                    const target = targets[0];
+                    assertUsage(target === undefined, `+serverEntry cannot be used with ${target} (because it uses its own server entry)`);
+                }),
+                // dist/server/index.mjs loads dist/server/entry.mjs
+                pluginServerEntryInject(serverEntryFilePath),
+            ]),
         {
             name: 'vike:pluginUniversalDeploy:entries',
             config() {
@@ -55,6 +79,6 @@ function pluginUniversalDeploy(vikeConfig) {
         },
         pluginServerEntryInject(serverFilePath ?? serverEntryId),
         pluginServerEntryAlias(serverFilePath),
-        !serverFilePath ? null : pluginUnwrapProdOptions(serverFilePath),
+        !serverFilePath ? null : pluginWrapServerFile(serverFilePath),
     ].filter((p) => p !== null);
 }

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,14 +3,18 @@ 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;
-} | {
-    isForConfig: true;
+type RuntimeEnv = (RuntimeEnvRuntime & {
+    isConfigEnvironment?: undefined;
+}) | {
+    isConfigEnvironment: 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[];

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

@@ -44,19 +44,13 @@ function getConfigValueSourceRelevantAnyEnv(configName, pageConfig) {
     return source;
 }
 function isRuntimeEnvMatch(configEnv, runtimeEnv) {
-    if ('isForConfig' in runtimeEnv)
+    if (runtimeEnv.isConfigEnvironment)
         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

@@ -1,8 +1,10 @@
 export { addSsrMiddleware };
-import { renderPageServer } from '../../../server/runtime/renderPageServer.js';
-import { assertWarning } from '../../../utils/assert.js';
-import pc from '@brillout/picocolors';
+import { vikeUniversalMiddleware } from '../../../server/runtime/universal-middleware/vikeUniversalMiddleware.js';
+import { getAdapterRuntime } from '@universal-middleware/core';
+import { createRequestAdapter } from '@universal-middleware/node/request';
+import { sendResponse } from '@universal-middleware/node/response';
 import '../assertEnvVite.js';
+const requestAdapter = createRequestAdapter();
 function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled) {
     middlewares.use(async (req, res, next) => {
         if (res.headersSent)
@@ -10,26 +12,11 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
         const url = req.originalUrl || req.url;
         if (!url)
             return next();
-        const { headers } = req;
-        const pageContextInit = {
-            urlOriginal: url,
-            headersOriginal: headers,
-            _nodeDev: { req, res },
-        };
-        Object.defineProperty(pageContextInit, 'userAgent', {
-            get() {
-                // TO-DO/next-major-release: assertUsage() instead of assertWarning()
-                assertWarning(false, `${pc.cyan('pageContext.userAgent')} is deprecated: use ${pc.cyan("pageContext.headers['user-agent']")} instead.`, {
-                    showStackTrace: true,
-                    onlyOnce: true,
-                });
-                return headers['user-agent'];
-            },
-            enumerable: false,
-        });
-        let pageContext;
+        let response;
         try {
-            pageContext = await renderPageServer(pageContextInit);
+            const runtime = Object.assign(getAdapterRuntime('other', { params: undefined }), { req, res });
+            const context = { urlOriginal: url };
+            response = await vikeUniversalMiddleware(requestAdapter(req, res), context, runtime);
         }
         catch (err) {
             // Throwing an error in a connect middleware shuts down the server
@@ -39,7 +26,7 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
             // - We purposely don't use next(err) to align behavior: we use our own/copied implementation of buildErrorMessage() regardless of whether the user uses Vite's dev middleware or Vite's standalone dev server
             return next();
         }
-        if (pageContext.httpResponse.statusCode === 404 && isPreview && isPrerenderingEnabled) {
+        if (response.status === 404 && isPreview && isPrerenderingEnabled) {
             // Serve /dist/client/404.html instead
             return next();
         }
@@ -49,9 +36,6 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
                 if (value)
                     res.setHeader(name, value);
         }
-        const { httpResponse } = pageContext;
-        httpResponse.headers.forEach(([name, value]) => res.setHeader(name, value));
-        res.statusCode = httpResponse.statusCode;
-        httpResponse.pipe(res);
+        await sendResponse(response, res);
     });
 }

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

@@ -2,4 +2,4 @@ export { findPageFiles };
 import type { ResolvedConfig } from 'vite';
 import type { FileType } from '../../../shared-server-client/getPageFiles/fileTypes.js';
 import '../assertEnvVite.js';
-declare function findPageFiles(config: ResolvedConfig, fileTypes: FileType[], isDev: boolean): Promise<string[]>;
+declare function findPageFiles(config: ResolvedConfig, fileTypes: FileType[]): Promise<string[]>;