vike 0.4.267-commit-b005535 → 0.4.267-commit-5676e14

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;
 }
@@ -219,6 +248,8 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, vik
     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
@@ -241,6 +272,7 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, vik
         _pageConfigGlobal: pageConfigGlobal,
         _vikeConfigDependencies: vikeTranspileCache.vikeConfigDependencies,
         _extensions,
+        _additionalEnvironmentNames: additionalEnvironmentNames,
     };
     globalObject.vikeConfigSync = vikeConfig;
     return vikeConfig;
@@ -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;
 }
@@ -1347,6 +1417,7 @@ async function getVikeConfigDummy(vikeTranspileCache) {
         prerenderContext: prerenderContextDummy,
         _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/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);

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

@@ -1,14 +1,17 @@
 export { execHookOnRenderHtml };
 export type { RenderHook };
+export type { Content };
 import { type HtmlRender } from './html/renderHtml.js';
 import { type HookInternal } from '../../../shared-server-client/hooks/getHook.js';
 import type { PageAsset } from './getPageAssets.js';
+import { type StreamReadableWeb } from './html/stream.js';
 import type { PageContextSerialization } from './html/serializeContext.js';
 import { type PageContextExecHook } from '../../../shared-server-client/hooks/execHook.js';
 import type { PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
 import type { PageContextInternalServer } from '../../../types/PageContext.js';
 import '../../assertEnvServer.js';
 type GetPageAssets = () => Promise<PageAsset[]>;
+type Content = string | Uint8Array | StreamReadableWeb;
 type RenderHook = HookInternal & {
     hookName: HookName;
 };
@@ -19,7 +22,13 @@ declare function execHookOnRenderHtml(pageContext: PageContextConfig & PageConte
     _isHtmlOnly: boolean;
     _baseServer: string;
     _requestId: number;
+    content?: unknown;
 }): Promise<{
     renderHook: RenderHook;
     htmlRender: HtmlRender;
+    content: null;
+} | {
+    renderHook: RenderHook;
+    htmlRender: null;
+    content: Content;
 }>;

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

@@ -6,7 +6,7 @@ import { isCallable } from '../../../utils/isCallable.js';
 import { assert, assertUsage, assertWarning } from '../../../utils/assert.js';
 import { isObject } from '../../../utils/isObject.js';
 import { objectAssign } from '../../../utils/objectAssign.js';
-import { isStream } from './html/stream.js';
+import { awaitFirstChunk, isStream, isStreamReadableWeb } from './html/stream.js';
 import { assertPageContextProvidedByUser } from '../../../shared-server-client/assertPageContextProvidedByUser.js';
 import { getPageContextPublicServer } from './getPageContextPublicServer.js';
 import { assertHookReturnedObject } from '../../../shared-server-client/assertHookReturnedObject.js';
@@ -18,9 +18,6 @@ async function execHookOnRenderHtml(pageContext) {
     const hook = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: hook });
     const { hookReturn } = await execHookSingleWithReturn(hook, pageContext, getPageContextPublicServer);
-    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
-    Object.assign(pageContext, pageContextProvidedByRenderHook);
-    objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
     const onErrorWhileStreaming = (err) => {
         // Should the stream inject the following?
         // ```
@@ -31,9 +28,24 @@ async function execHookOnRenderHtml(pageContext) {
             pageContext.errorWhileRendering = err;
         }
     };
+    // The render hook sets `pageContext.content` instead of returning `documentHtml`
+    if (hookReturn === undefined && pageContext.content !== undefined) {
+        const content = await getContent(pageContext.content, onErrorWhileStreaming);
+        return { content, htmlRender: null, renderHook: hook };
+    }
+    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
+    Object.assign(pageContext, pageContextProvidedByRenderHook);
+    objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
     const htmlRender = await renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
     assert(typeof htmlRender === 'string' || isStream(htmlRender));
-    return { htmlRender, renderHook: hook };
+    return { htmlRender, content: null, renderHook: hook };
+}
+async function getContent(content, onErrorWhileStreaming) {
+    if (typeof content === 'string' || content instanceof Uint8Array)
+        return content;
+    assertUsage(isStreamReadableWeb(content), `${pc.code('pageContext.content')} is a value that isn't a string, a Uint8Array, nor a ReadableStream, see https://vike.dev/pageContext#content`);
+    // Errors before the first chunk => error page
+    return await awaitFirstChunk(content, onErrorWhileStreaming);
 }
 function getRenderHook(pageContext) {
     let hookFound;

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

@@ -20,8 +20,8 @@ type HttpResponseBody = {
     /** @deprecated */
     pipeToWebWritable: StreamPipeWeb;
 };
-declare function getHttpResponseBody(htmlRender: HtmlRender, renderHook: null | RenderHook): string;
-declare function getHttpResponseBodyStreamHandlers(htmlRender: HtmlRender, renderHook: null | RenderHook): {
+declare function getHttpResponseBody(htmlRender: HtmlRender | Uint8Array, renderHook: null | RenderHook): string;
+declare function getHttpResponseBodyStreamHandlers(htmlRender: HtmlRender | Uint8Array, renderHook: null | RenderHook): {
     pipe(writable: StreamWritableNode | StreamWritableWeb): void;
     getReadableWebStream(): StreamReadableWeb;
     getReadableNodeStream(): Promise<import("stream").Readable>;

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

@@ -53,7 +53,16 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             }
             return nodeStream;
         },
+        // Decodes the body as UTF-8 text
         async getBody() {
+            if (htmlRender instanceof Uint8Array) {
+                try {
+                    return new TextDecoder('utf-8', { fatal: true }).decode(htmlRender);
+                }
+                catch {
+                    assertUsage(false, getErrMsg(htmlRender, renderHook, 'getBody()', `The Uint8Array isn't UTF-8 text: use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`));
+                }
+            }
             const body = await getHtmlString(htmlRender);
             return body;
         },
@@ -99,7 +108,8 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
     function getFixMsg(kind, type) {
         const streamName = getStreamName(kind, type);
         assert(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
-        assert(renderHook);
+        if (!renderHook)
+            return `Use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`;
         const { hookFilePath, hookName } = renderHook;
         return `Make sure the ${hookName}() hook defined by ${hookFilePath} provides ${streamName} instead`;
     }
@@ -112,7 +122,9 @@ function getErrMsg(htmlRender, renderHook, method, msgAddendum) {
         .join('. ');
 }
 function getErrMsgBody(htmlRender, renderHook) {
-    assert(renderHook);
+    // E.g. a pageContext.json response with streamed pageContext values
+    if (!renderHook)
+        return `HTTP response body is ${getHookReturnType(htmlRender)}`;
     const { hookFilePath, hookName } = renderHook;
     const hookReturnType = getHookReturnType(htmlRender);
     assert(['a ', 'an ', 'the '].some((s) => hookReturnType.startsWith(s)));
@@ -124,6 +136,9 @@ function getHookReturnType(htmlRender) {
     if (typeof htmlRender === 'string') {
         return 'an HTML string';
     }
+    else if (htmlRender instanceof Uint8Array) {
+        return 'a Uint8Array';
+    }
     else if (isStream(htmlRender)) {
         return inferStreamName(htmlRender);
     }

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

@@ -0,0 +1,8 @@
+export { getPageContextJson };
+export { getPageContextJsonFile };
+import { type PageContextSerialization } from './html/serializeContext.js';
+import type { PageContext_logRuntime } from '../loggerRuntime.js';
+import '../../assertEnvServer.js';
+type PageContextForJson = PageContextSerialization & NonNullable<PageContext_logRuntime>;
+declare function getPageContextJson(pageContext: PageContextForJson): string | ReadableStream<Uint8Array>;
+declare function getPageContextJsonFile(pageContext: PageContextSerialization, lines: null | string[]): string;