vike 0.4.266 → 0.4.267-commit-7884d91

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;

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

@@ -4,6 +4,7 @@ export { getVikeConfig };
 export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { setVikeConfigContext };
+export { setViteEnvironmentNames };
 export { isVikeConfigContextSet };
 export { reloadVikeConfig };
 export { isV1Design };
@@ -12,7 +13,6 @@ export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 export { EARLY_SETTINGS };
 import { deepEqual } from '../../../utils/deepEqual.js';
-import { assertKeys } from '../../../utils/assertKeys.js';
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { getMostSimilar } from '../../../utils/getMostSimilar.js';
 import { objectEntries } from '../../../utils/objectEntries.js';
@@ -23,6 +23,7 @@ import { checkType } from '../../../utils/checkType.js';
 import { genPromise } from '../../../utils/genPromise.js';
 import { getGlobalObject } from '../../../utils/getGlobalObject.js';
 import { hasProp } from '../../../utils/hasProp.js';
+import { includes } from '../../../utils/includes.js';
 import { isCallable } from '../../../utils/isCallable.js';
 import { isObject } from '../../../utils/isObject.js';
 import { joinEnglish } from '../../../utils/joinEnglish.js';
@@ -42,6 +43,7 @@ import { loadPointerImport, loadValueFile } from './resolveVikeConfigInternal/lo
 import { resolvePointerImport } from './resolveVikeConfigInternal/resolvePointerImport.js';
 import { parsePointerImportData } from './resolveVikeConfigInternal/pointerImports.js';
 import { getFilePathResolved } from './getFilePath.js';
+import { isEnvironmentBuiltIn, isEnvironmentNameValid } from '../../../shared-server-node/vike-environments.js';
 import { getConfigValueBuildTime } from '../../../shared-server-client/page-configs/getConfigValueBuildTime.js';
 import { resolveGlobalConfigPublic, } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
 import { getConfigValuesBase, isJsonValue, } from '../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
@@ -65,12 +67,13 @@ const globalObject = getGlobalObject('vite/shared/resolveVikeConfigInternal.ts',
     vikeConfigSync: null,
     vikeConfigCtx: null, // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
     prerenderContext: null,
+    viteEnvironmentNames: null,
 });
 function reloadVikeConfig() {
     assert(globalObject.vikeConfigCtx);
-    const { userRootDir, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
+    const { userRootDir, isDev, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
     assert(vikeVitePluginOptions);
-    resolveVikeConfigInternal_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
+    resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions);
 }
 async function getVikeConfigInternal(
 // I don't remember the logic behind it — neither why we restart Vite's dev server, nor why we sometimes don't.
@@ -110,6 +113,32 @@ function setVikeConfigContext(vikeConfigCtx_) {
     // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
     globalObject.vikeConfigCtx = vikeConfigCtx_;
 }
+// Vike's config is resolved before Vite's environments are known (Vike's config can modify Vite's config)
+async function setViteEnvironmentNames(viteEnvironmentNames) {
+    globalObject.viteEnvironmentNames = viteEnvironmentNames;
+    if (!globalObject.vikeConfigPromise)
+        return;
+    const vikeConfig = await globalObject.vikeConfigPromise;
+    // Resolve again: to report a missing environment like any other config error, or to recover from one (e.g. the user added the environment to Vite's config)
+    const isMissing = getAdditionalEnvironmentsMissing(vikeConfig._additionalEnvironmentNames).length > 0;
+    if (!isMissing && !globalObject.vikeConfigHasBuildError)
+        return;
+    reloadVikeConfig();
+    await globalObject.vikeConfigPromise;
+}
+function getAdditionalEnvironmentsMissing(additionalEnvironmentNames) {
+    const { viteEnvironmentNames } = globalObject;
+    if (!viteEnvironmentNames)
+        return [];
+    return additionalEnvironmentNames.filter((name) => !viteEnvironmentNames.includes(name));
+}
+function assertAdditionalEnvironmentsExist(additionalEnvironmentNames) {
+    const [name] = getAdditionalEnvironmentsMissing(additionalEnvironmentNames);
+    if (name === undefined)
+        return;
+    assert(globalObject.viteEnvironmentNames);
+    assertUsage(false, `The environment ${pc.cyan(JSON.stringify(name))} is used by ${pc.cyan('meta.env')} but it doesn't exist in Vite's ${pc.cyan('config.environments')} (${joinEnglish(globalObject.viteEnvironmentNames.map((n) => pc.cyan(n)), 'and')})`);
+}
 function isVikeConfigContextSet() {
     return !!globalObject.vikeConfigCtx;
 }
@@ -134,7 +163,7 @@ function isV1Design() {
 async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     const { promise, resolve, reject } = genPromise();
     globalObject.vikeConfigPromise = promise;
-    const esbuildCache = {
+    const vikeTranspileCache = {
         transpileCache: {},
         vikeConfigDependencies: new Set(),
     };
@@ -143,7 +172,7 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     let ret;
     let err;
     try {
-        ret = await resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache);
+        ret = await resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, vikeTranspileCache);
     }
     catch (err_) {
         hasError = true;
@@ -193,7 +222,7 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
         }
         else {
             logErrorServerDev(err, null);
-            resolve(await getVikeConfigDummy(esbuildCache));
+            resolve(await getVikeConfigDummy(vikeTranspileCache));
         }
     }
 }
@@ -215,10 +244,12 @@ function hasViteConfigChanged(vikeConfigOld, vikeConfigNew) {
     }
     return false;
 }
-async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache) {
-    const plusFilesByLocationId = await getPlusFiles(userRootDir, esbuildCache);
-    const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbuildCache);
+async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, vikeTranspileCache) {
+    const plusFilesByLocationId = await getPlusFiles(userRootDir, vikeTranspileCache);
+    const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesByLocationId, userRootDir, vikeTranspileCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesByLocationId, userRootDir);
+    const additionalEnvironmentNames = getAdditionalEnvironmentNames(getMetaEnvAll(configDefinitionsResolved, [pageConfigGlobal, ...pageConfigs]));
+    assertAdditionalEnvironmentsExist(additionalEnvironmentNames);
     if (!globalObject.isV1Design_)
         globalObject.isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
@@ -239,8 +270,9 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
         prerenderContext,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
-        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
+        _vikeConfigDependencies: vikeTranspileCache.vikeConfigDependencies,
         _extensions,
+        _additionalEnvironmentNames: additionalEnvironmentNames,
     };
     globalObject.vikeConfigSync = vikeConfig;
     return vikeConfig;
@@ -249,14 +281,14 @@ function resolveGlobalConfig(pageConfigGlobal, pageConfigs) {
     const globalConfigPublic = resolveGlobalConfigPublic(pageConfigs, pageConfigGlobal, getConfigValues);
     return globalConfigPublic;
 }
-async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbuildCache) {
+async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, vikeTranspileCache) {
     const plusFilesByLocationIdOrdered = Object.values(plusFilesByLocationId)
         .flat()
         .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderGlobal(plusFile1, plusFile2, plusFilesByLocationId, null));
     const configDefinitionsGlobal = getConfigDefinitions(
     // We use `plusFilesByLocationId` in order to allow non-global Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
     plusFilesByLocationIdOrdered, (configDef) => !!configDef.global);
-    await loadCustomConfigBuildTimeFiles(plusFilesByLocationId, configDefinitionsGlobal, userRootDir, esbuildCache);
+    await loadCustomConfigBuildTimeFiles(plusFilesByLocationId, configDefinitionsGlobal, userRootDir, vikeTranspileCache);
     const configNamesKnownAll = getConfigNames(Object.values(plusFilesByLocationId).flat());
     const configNamesKnownGlobal = Object.keys(configDefinitionsGlobal);
     assert(configNamesKnownGlobal.every((configName) => configNamesKnownAll.includes(configName)));
@@ -268,7 +300,7 @@ async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbu
             .flat()
             .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderPage(plusFile1, plusFile2, locationIdPage, null));
         const { configDefinitions, peerDependencyConfigNames } = collectConfigDefinitions(plusFilesRelevant, (configDef) => configDef.global !== true);
-        await loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache);
+        await loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, vikeTranspileCache);
         const configNamesKnownLocal = unique([
             ...Object.keys(configDefinitions),
             ...peerDependencyConfigNames,
@@ -293,15 +325,15 @@ async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbu
 }
 // Load value files (with `env.config===true`) of *custom* configs.
 // - The value files of *built-in* configs are already loaded at `getPlusFiles()`.
-async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache) {
+async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, vikeTranspileCache) {
     const plusFileList = Object.values(plusFiles).flat(1);
     await Promise.all(plusFileList.map(async (plusFile) => {
         if (!plusFile.isConfigFile) {
-            await loadValueFile(plusFile, configDefinitions, userRootDir, esbuildCache);
+            await loadValueFile(plusFile, configDefinitions, userRootDir, vikeTranspileCache);
         }
         else {
             await Promise.all(Object.entries(plusFile.pointerImportsByConfigName).map(async ([configName, pointerImports]) => {
-                await Promise.all(pointerImports.map((pointerImport) => loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache)));
+                await Promise.all(pointerImports.map((pointerImport) => loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, vikeTranspileCache)));
             }));
         }
     }));
@@ -330,6 +362,23 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesByLocationI
     assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal };
 }
+// Get all the `meta.env` of all configs
+function getMetaEnvAll(configDefinitionsResolved, pageConfigs) {
+    const configDefinitionsAll = [
+        configDefinitionsResolved.configDefinitionsGlobal,
+        ...Object.values(configDefinitionsResolved.configDefinitionsLocal).map(({ configDefinitions }) => configDefinitions),
+    ];
+    return [
+        ...configDefinitionsAll.flatMap((configDefinitions) => Object.values(configDefinitions).map(({ env }) => env)),
+        ...pageConfigs.flatMap(({ configValueSources }) => Object.values(configValueSources).flatMap((sources) => sources.map(({ configEnv }) => configEnv))),
+    ];
+}
+function getAdditionalEnvironmentNames(configEnvs) {
+    const names = configEnvs.flatMap((configEnv) => Object.entries(configEnv)
+        .filter(([, value]) => value)
+        .map(([name]) => name));
+    return unique(names.filter(isAdditionalEnvironmentName));
+}
 function resolvePageConfigBuildTime(pageId, locationId, plusFilesRelevant, configDefinitionsLocal, plusFilesByLocationId, userRootDir) {
     const configValueSources = {};
     objectEntries(configDefinitionsLocal)
@@ -1091,11 +1140,13 @@ function applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEf
     });
 }
 function getComputed(pageConfig) {
+    assert(globalObject.vikeConfigCtx);
+    const { isDev } = globalObject.vikeConfigCtx;
     const configValuesComputed = {};
     objectEntries(pageConfig.configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef._computed)
             return;
-        const value = configDef._computed(pageConfig);
+        const value = configDef._computed(pageConfig, isDev);
         if (value === undefined)
             return;
         configValuesComputed[configName] = {
@@ -1220,6 +1271,14 @@ function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
+// Keys of `meta.env` that only Vike sets
+const configEnvKeysInternal = ['clientRoutingOnly', 'eager'];
+// Keys of `meta.env` that can't be environment names
+// - Including file suffixes such as `.ssr.js`, `.shared.js`, `.clear.js`, `.default.js`
+const configEnvKeysReserved = ['ssr', 'shared', 'clear', 'default', ...configEnvKeysInternal];
+function isAdditionalEnvironmentName(configEnvKey) {
+    return (!isEnvironmentBuiltIn(configEnvKey) && !['config', 'production', ...configEnvKeysInternal].includes(configEnvKey));
+}
 function getConfigEnvValue(val, errMsgIntro) {
     const errInvalidValue = `${errMsgIntro} an invalid value ${pc.cyan(JSON.stringify(val))}`;
     // Legacy outdated values
@@ -1235,22 +1294,23 @@ function getConfigEnvValue(val, errMsgIntro) {
             if (val === 'config-only')
                 return { config: true };
             if (val === '_routing-lazy')
-                return { server: true, client: 'if-client-routing' };
+                return { server: true, client: true, clientRoutingOnly: true };
             if (val === '_routing-eager')
-                return { server: true, client: 'if-client-routing', eager: true };
+                return { server: true, client: true, clientRoutingOnly: true, eager: true };
             assertUsage(false, errInvalidValue);
         })();
         assertWarning(false, `${errMsgIntro} ${pc.cyan(val)} which is deprecated and will be removed in the next major release`, { onlyOnce: true });
         return valConverted;
     }
     assertUsage(isObject(val), `${errMsgIntro} an invalid type ${pc.cyan(typeof val)}`);
-    assertKeys(val, ['config', 'server', 'client'], `${errInvalidValue}:`);
-    assertUsage(hasProp(val, 'config', 'undefined') || hasProp(val, 'config', 'boolean'), errInvalidValue);
-    assertUsage(hasProp(val, 'server', 'undefined') || hasProp(val, 'server', 'boolean'), errInvalidValue);
-    assertUsage(hasProp(val, 'client', 'undefined') || hasProp(val, 'client', 'boolean'), errInvalidValue);
+    Object.entries(val).forEach(([key, value]) => {
+        assertUsage(!includes(configEnvKeysReserved, key), `${errInvalidValue}: ${pc.cyan(key)} can't be an environment name, because ${includes(configEnvKeysInternal, key) ? 'Vike uses it internally' : `it's a file suffix (${pc.cyan(`+Page.${key}.js`)})`}`);
+        assertUsage(isEnvironmentNameValid(key), `${errInvalidValue}: ${pc.cyan(key)} isn't a valid environment name`);
+        assertUsage(value === undefined || typeof value === 'boolean', errInvalidValue);
+    });
     /* To allow users to set an eager config:
      * - Uncomment line below.
-     * - Add 'eager' to assertKeys() call above.
+     * - Move 'eager' from configEnvKeysInternal to the keys that isAdditionalEnvironmentName() excludes.
      * - Add `eager: boolean` to ConfigEnv type.
     assertUsage(hasProp(val, 'eager', 'undefined') || hasProp(val, 'eager', 'boolean'), errInvalidValue)
     */
@@ -1279,11 +1339,21 @@ function resolveConfigEnv(configEnv, filePath) {
         else if (suffixes.includes('client')) {
             configEnvResolved.client = true;
             configEnvResolved.server = false;
+            // Additional environments (e.g. `rsc`) are server-side
+            Object.keys(configEnvResolved).forEach((key) => {
+                if (isAdditionalEnvironmentName(key))
+                    delete configEnvResolved[key];
+            });
         }
         else if (suffixes.includes('shared')) {
             configEnvResolved.server = true;
             configEnvResolved.client = true;
         }
+        else {
+            return configEnvResolved;
+        }
+        // The file suffix decides, regardless of Client Routing
+        delete configEnvResolved.clientRoutingOnly;
     }
     return configEnvResolved;
 }
@@ -1325,7 +1395,7 @@ function restartViteDevServer() {
     })();
     swallowViteLogForceOptimization_disable();
 }
-async function getVikeConfigDummy(esbuildCache) {
+async function getVikeConfigDummy(vikeTranspileCache) {
     const pageConfigsDummy = [];
     const pageConfigGlobalDummy = {
         configValueSources: {},
@@ -1345,8 +1415,9 @@ async function getVikeConfigDummy(esbuildCache) {
         },
         ...globalConfigPublicDummy,
         prerenderContext: prerenderContextDummy,
-        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
+        _vikeConfigDependencies: vikeTranspileCache.vikeConfigDependencies,
         _extensions: [],
+        _additionalEnvironmentNames: [],
     };
     globalObject.vikeConfigSync = vikeConfigDummy;
     globalObject.isV1Design_ = true;

package/dist/server/runtime/globalContext.d.ts

@@ -54,6 +54,10 @@ declare function getGlobalContextServerInternal(): Promise<{
         _pageFilesAll: import("../__internal/index.js").PageFile[];
         _pageConfigs: import("../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & {
         isClientSide: false;
@@ -102,6 +106,10 @@ declare function getGlobalContextServerInternal(): Promise<{
         _pageFilesAll: import("../__internal/index.js").PageFile[];
         _pageConfigs: import("../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & {
         isClientSide: false;
@@ -151,6 +159,10 @@ declare function getGlobalContextServerInternal(): Promise<{
         _pageFilesAll: import("../__internal/index.js").PageFile[];
         _pageConfigs: import("../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & {
         isClientSide: false;
@@ -202,6 +214,10 @@ declare function getGlobalContextServerInternalOptional(): (Record<string, unkno
     _pageFilesAll: import("../__internal/index.js").PageFile[];
     _pageConfigs: import("../__internal/index.js").PageConfig[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: import("../__internal/index.js").PageConfig[];
+        pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & (({
     isClientSide: false;
@@ -309,6 +325,10 @@ declare function createGlobalContext(virtualFileExportsGlobalEntry: unknown): Pr
     _pageFilesAll: import("../__internal/index.js").PageFile[];
     _pageConfigs: import("../__internal/index.js").PageConfig[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: import("../__internal/index.js").PageConfig[];
+        pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & (({
     isClientSide: false;

package/dist/server/runtime/renderPageServer/analyzePage.js

@@ -18,14 +18,14 @@ function analyzePage(pageContext) {
             clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
-            id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: true }),
+            id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, environmentName: 'client' }),
             onlyAssets: isClientRuntimeLoaded ? false : true,
             eagerlyImported: false,
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
         if (!globalContext._isProduction) {
             clientDependencies.push({
-                id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: false }),
+                id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, environmentName: 'server' }),
                 onlyAssets: true,
                 eagerlyImported: false,
             });
@@ -36,7 +36,7 @@ function analyzePage(pageContext) {
             const { env } = configElement
             assert(env)
             const onlyAssets = env === { server: true }
-            const eagerlyImported = env === { server: true, client: 'if-client-routing', eager: true }
+            const eagerlyImported = env === { server: true, client: true, clientRoutingOnly: true, eager: true }
             if (onlyAssets || eagerlyImported) {
               clientDependencies.push({
                 id: configElement.importPath,

package/dist/server/runtime/renderPageServer/createHttpResponse.d.ts

@@ -1,4 +1,5 @@
-export { createHttpResponsePage };
+export { createHttpResponsePageHtml };
+export { createHttpResponsePageContent };
 export { createHttpResponsePageJson };
 export { createHttpResponseErrorFallback };
 export { createHttpResponseErrorFallback_noGlobalContext };
@@ -10,8 +11,9 @@ export { createHttpResponseFromUniversalMiddleware };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from './html/renderHtml.js';
-import type { RenderHook } from './execHookOnRenderHtml.js';
-import type { AbortStatusCode, UrlRedirect } from '../../../shared-server-client/route/abort.js';
+import type { StreamReadableWeb } from './html/stream.js';
+import type { Content, RenderHook } from './execHookOnRenderHtml.js';
+import type { AbortStatusCode, UrlRedirect, PageContextAborted } from '../../../shared-server-client/route/abort.js';
 import { HttpResponseBody } from './getHttpResponseBody.js';
 import { type EarlyHint } from './getEarlyHints.js';
 import type { PageContextBegin } from '../renderPageServer.js';
@@ -24,7 +26,7 @@ type HttpResponse = {
     /** **Deprecated**: use `headers` instead, see https://vike.dev/migration/0.4.134 */
     contentType: string | undefined;
 } & HttpResponseBody;
-declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: {
+type PageContextHttpResponsePage = {
     pageId: null | string;
     is404: null | boolean;
     errorWhileRendering: null | Error;
@@ -32,14 +34,25 @@ declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null
     _globalContext: GlobalContextServerInternal;
     abortStatusCode?: AbortStatusCode;
     headersResponse?: Headers;
-}): Promise<HttpResponse>;
+    pageContextsAborted: PageContextAborted[];
+};
+declare function createHttpResponsePageHtml(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: PageContextHttpResponsePage): Promise<HttpResponse>;
+declare function createHttpResponsePageContent(content: Content, renderHook: RenderHook, pageContext: PageContextHttpResponsePage & {
+    urlOriginal: string;
+}): HttpResponse;
 declare function createHttpResponse404(errMsg404: string): HttpResponse;
 declare function createHttpResponseBaseIsMissing(urlOriginal: string, baseServer: string): HttpResponse;
 declare function createHttpResponseErrorFallback(pageContext: {
     _globalContext: GlobalContextServerInternal;
+    pageContextsAborted: PageContextAborted[];
 }): HttpResponse;
 declare function createHttpResponseErrorFallback_noGlobalContext(): HttpResponse;
-declare function createHttpResponseErrorFallbackJson(): HttpResponse;
-declare function createHttpResponsePageJson(pageContextSerialized: string): Promise<HttpResponse>;
+declare function createHttpResponseErrorFallbackJson(pageContext: {
+    pageContextsAborted: PageContextAborted[];
+}): HttpResponse;
+declare function createHttpResponsePageJson(pageContextJson: string | StreamReadableWeb, pageContext: {
+    headersResponse?: Headers;
+    pageContextsAborted: PageContextAborted[];
+}): Promise<HttpResponse>;
 declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: PageContextBegin): HttpResponse;
 declare function createHttpResponseFromUniversalMiddleware(response: Response, earlyHints?: EarlyHint[]): HttpResponse;

package/dist/server/runtime/renderPageServer/createHttpResponse.js

@@ -1,4 +1,5 @@
-export { createHttpResponsePage };
+export { createHttpResponsePageHtml };
+export { createHttpResponsePageContent };
 export { createHttpResponsePageJson };
 export { createHttpResponseErrorFallback };
 export { createHttpResponseErrorFallback_noGlobalContext };
@@ -10,16 +11,31 @@ export { createHttpResponseFromUniversalMiddleware };
 import { escapeHtml } from '../../../utils/escapeHtml.js';
 import { assert, assertWarning } from '../../../utils/assert.js';
 import { getErrorPageId, isErrorPage } from '../../../shared-server-client/error-page.js';
+import { getContentTypeFromUrl } from '../../../utils/getContentTypeFromUrl.js';
 import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
 import { getEarlyHints } from './getEarlyHints.js';
 import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfiniteHttpRedirect.js';
-import { resolveHeadersResponseFinal } from './headersResponse.js';
+import { getHeadersSetCookieAborted, resolveHeadersResponseFinal, resolveHeadersResponseSetCookie, } from './headersResponse.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import '../../assertEnvServer.js';
 const contentTypeJson = 'application/json';
 const contentTypeHtml = 'text/html;charset=utf-8';
 const htmlFallbackLog = 'This HTML was generated by Vike.';
-async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
+async function createHttpResponsePageHtml(htmlRender, renderHook, pageContext) {
+    const statusCode = getStatusCode(pageContext);
+    const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
+    const headers = resolveHeadersResponseFinal(pageContext, statusCode);
+    return createHttpResponse(statusCode, contentTypeHtml, headers, htmlRender, earlyHints, renderHook);
+}
+function createHttpResponsePageContent(content, renderHook, pageContext) {
+    const statusCode = getStatusCode(pageContext);
+    const headers = resolveHeadersResponseFinal(pageContext, statusCode);
+    if (!headers.some(([k]) => k.toLowerCase() === 'content-type')) {
+        headers.push(['Content-Type', getContentTypeFromUrl(pageContext.urlOriginal) ?? 'application/octet-stream']);
+    }
+    return createHttpResponseCommon(statusCode, headers, content, [], renderHook);
+}
+function getStatusCode(pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
         const isError = !pageContext.pageId || isErrorPage(pageContext.pageId, pageContext._globalContext._pageConfigs);
@@ -35,9 +51,7 @@ async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
             statusCode = pageContext.is404 ? 404 : 500;
         }
     }
-    const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
-    const headers = resolveHeadersResponseFinal(pageContext, statusCode);
-    return createHttpResponse(statusCode, contentTypeHtml, headers, htmlRender, earlyHints, renderHook);
+    return statusCode;
 }
 function createHttpResponse404(errMsg404) {
     const httpResponse = createHttpResponse(404, contentTypeHtml, [], getHtmlFallback(`<p>${errMsg404}.</p>`));
@@ -76,21 +90,26 @@ function createHttpResponseErrorFallback(pageContext) {
             return 'no error page (https://vike.dev/error-page) is defined, make sure to create one';
         }
     })();
-    return createHttpResponseError_(reason);
+    // Cookies set before `throw redirect()` or `throw render()` are kept
+    return createHttpResponseError_(reason, getHeadersSetCookieAborted(pageContext));
 }
 function createHttpResponseErrorFallback_noGlobalContext() {
-    return createHttpResponseError_('no error page (https://vike.dev/error-page) could be rendered');
+    return createHttpResponseError_('no error page (https://vike.dev/error-page) could be rendered', []);
 }
-function createHttpResponseError_(reason) {
-    const httpResponse = createHttpResponse(500, contentTypeHtml, [], getHtmlFallback('<p>An error occurred.</p>', `${htmlFallbackLog} Vike returned this HTML because ${reason}.`));
+function createHttpResponseError_(reason, headers) {
+    const httpResponse = createHttpResponse(500, contentTypeHtml, headers, getHtmlFallback('<p>An error occurred.</p>', `${htmlFallbackLog} Vike returned this HTML because ${reason}.`));
     return httpResponse;
 }
-function createHttpResponseErrorFallbackJson() {
-    const httpResponse = createHttpResponse(500, contentTypeJson, [], stringify({ serverSideError: true }));
+function createHttpResponseErrorFallbackJson(pageContext) {
+    const headers = getHeadersSetCookieAborted(pageContext);
+    const httpResponse = createHttpResponse(500, contentTypeJson, headers, stringify({ serverSideError: true }));
     return httpResponse;
 }
-async function createHttpResponsePageJson(pageContextSerialized) {
-    const httpResponse = createHttpResponse(200, contentTypeJson, [], pageContextSerialized, [], null);
+async function createHttpResponsePageJson(pageContextJson, pageContext) {
+    const headers = resolveHeadersResponseSetCookie(pageContext);
+    headers.push(['Content-Type', contentTypeJson]);
+    // A stream if there are streamed pageContext values, see https://vike.dev/passToClient#streaming
+    const httpResponse = createHttpResponseCommon(200, headers, pageContextJson);
     return httpResponse;
 }
 function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
@@ -98,7 +117,7 @@ function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
     assert(url);
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);
-    const headers = [['Location', url]];
+    const headers = [['Location', url], ...resolveHeadersResponseSetCookie(pageContextInit)];
     return createHttpResponse(statusCode, contentTypeHtml, headers, 
     // For bots / programmatic crawlig: show what's going on.
     // For users: showing a blank page is probably better than a flickering text.

package/dist/server/runtime/renderPageServer/createPageContextServer.d.ts

@@ -53,6 +53,10 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
         _pageFilesAll: import("../../__internal/index.js").PageFile[];
         _pageConfigs: import("../../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & (({
         isClientSide: false;

package/dist/server/runtime/renderPageServer/csp.d.ts

@@ -3,9 +3,10 @@ export { inferNonceAttr };
 export { addCspResponseHeader };
 export type { PageContextCspNonce };
 import type { PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
+import type { PageContextPublicMinimum } from '../../../shared-server-client/getPageContextPublicShared.js';
 import type { PageContextServer } from '../../../types/PageContext.js';
 import '../../assertEnvServer.js';
-declare function resolvePageContextCspNone(pageContext: PageContextConfig & Partial<PageContextCspNonce>): Promise<null | {
+declare function resolvePageContextCspNone(pageContext: PageContextConfig & PageContextPublicMinimum & Partial<PageContextCspNonce>): Promise<null | {
     cspNonce: string | null;
 }>;
 type PageContextCspNonce = Pick<PageContextServer, 'cspNonce'>;

package/dist/server/runtime/renderPageServer/csp.js

@@ -3,6 +3,7 @@ export { inferNonceAttr };
 export { addCspResponseHeader };
 import { import_ } from '@brillout/import';
 import { assert } from '../../../utils/assert.js';
+import { getPageContextPublicServer } from './getPageContextPublicServer.js';
 import '../../assertEnvServer.js';
 async function resolvePageContextCspNone(pageContext) {
     if (pageContext.cspNonce)
@@ -14,7 +15,7 @@ async function resolvePageContextCspNone(pageContext) {
             pageContextAddendum.cspNonce = await generateNonce();
         }
         else {
-            pageContextAddendum.cspNonce = await csp.nonce(pageContext);
+            pageContextAddendum.cspNonce = await csp.nonce(getPageContextPublicServer(pageContext));
         }
     }
     return pageContextAddendum;

package/dist/server/runtime/renderPageServer/execHookOnError.js

@@ -23,7 +23,7 @@ function execHookOnError(err, pageContext) {
     const hooks = getHooksFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onError');
     for (const hook of hooks) {
         try {
-            execHookSingleSync(hook, globalContext, pageContext, getPageContextPublicServer, () => hook.hookFn(err, pageContext));
+            execHookSingleSync(hook, globalContext, pageContext, getPageContextPublicServer, (pageContextPublic) => hook.hookFn(err, pageContextPublic));
         }
         catch (hookErr) {
             console.error(hookErr);