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

package/dist/server/runtime/renderPageServer/streamedValues/registry.d.ts

@@ -0,0 +1,28 @@
+export { getReplacer };
+export type { StreamedValue };
+export type { StreamedValueType };
+import type { Replacer } from '@brillout/json-serializer/stringify';
+import type { LineContent } from '../../../../shared-server-client/streamedValues.js';
+import '../../../assertEnvServer.js';
+type StreamedValueType<Value = any, Result = any> = {
+    marker: string;
+    is: (value: unknown) => value is Value;
+    read: (value: Value) => {
+        next: () => Promise<Result>;
+        /** `isLast`: the value ended */
+        toLine: (result: Result) => {
+            line: LineContent;
+            isLast: boolean;
+        };
+        cancel: () => unknown;
+    };
+};
+type StreamedValue = {
+    id: number;
+    type: StreamedValueType;
+    value: unknown;
+};
+declare function getReplacer(pageContext: object): {
+    replacer: Replacer;
+    streamedValues: StreamedValue[];
+};

package/dist/server/runtime/renderPageServer/streamedValues/registry.js

@@ -0,0 +1,33 @@
+// The types of streamed pageContext values (see shared-server-client/streamedValues.ts), and the serializer's replacer
+// that replaces them with their marker and id.
+export { getReplacer };
+import { readableStream } from './readableStream.js';
+import { promise } from './promise.js';
+import { asyncIterable } from './asyncIterable.js';
+import '../../../assertEnvServer.js';
+// A ReadableStream is also an async iterable
+const types = [readableStream, promise, asyncIterable];
+// Per pageContext: the HTML and the `index.pageContext.json` of a pre-rendered page reference the same values with the
+// same ids.
+const idsByPageContext = new WeakMap();
+// `streamedValues`: the values not seen before, filled while serializing
+function getReplacer(pageContext) {
+    let ids = idsByPageContext.get(pageContext);
+    if (!ids)
+        idsByPageContext.set(pageContext, (ids = { byValue: new Map(), idNext: 0 }));
+    const streamedValues = [];
+    const replacer = (_key, value) => {
+        const type = types.find((type) => type.is(value));
+        if (!type)
+            return undefined;
+        let streamedValue = ids.byValue.get(value);
+        if (!streamedValue) {
+            streamedValue = { id: ids.idNext++, type, value };
+            ids.byValue.set(value, streamedValue);
+            // The same value referenced twice is sent once (a stream can be read only once)
+            streamedValues.push(streamedValue);
+        }
+        return { replacement: type.marker + streamedValue.id };
+    };
+    return { replacer, streamedValues };
+}

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

@@ -52,6 +52,10 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
         _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.js

@@ -17,12 +17,13 @@ import { updateType } from '../../utils/updateType.js';
 import { getPageContextAddendumAbort, isAbortError, logAbort, addNewPageContextAborted, } from '../../shared-server-client/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPageServer/handlePageContextRequestUrl.js';
+import { getPageContextPublicServer } from './renderPageServer/getPageContextPublicServer.js';
 import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageJson, createHttpResponseErrorFallback, createHttpResponseErrorFallback_noGlobalContext, createHttpResponseBaseIsMissing, createHttpResponseFromUniversalMiddleware, } from './renderPageServer/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
 import { assertArguments } from './renderPageServer/assertArguments.js';
 import { log404 } from './renderPageServer/log404/index.js';
 import pc from '@brillout/picocolors';
-import { getPageContextClientSerializedAbort, getPageContextClientSerialized, } from './renderPageServer/html/serializeContext.js';
+import { getPageContextClientSerializedAbort } from './renderPageServer/html/serializeContext.js';
 import { getErrorPageId } from '../../shared-server-client/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPageServer/handleErrorWithoutErrorPage.js';
 import { loadPageConfigsLazyServerSide, } from './renderPageServer/loadPageConfigsLazyServerSide.js';
@@ -30,6 +31,7 @@ import { resolveRedirects } from './renderPageServer/resolveRedirects.js';
 import { getVikeConfigError } from '../../shared-server-node/getVikeConfigError.js';
 import { forkPageContext } from '../../shared-server-client/forkPageContext.js';
 import { getAsyncLocalStorage } from './asyncHook.js';
+import { getPageContextJson } from './renderPageServer/getPageContextJson.js';
 import '../assertEnvServer.js';
 import { enhance, apply, universalSymbol, UniversalRouter, getAdapterRuntime, } from '@universal-middleware/core';
 import { createRequestAdapter } from '@universal-middleware/node/request';
@@ -55,7 +57,12 @@ async function renderPageServer(pageContextInit) {
     logHttpResponse(urlOriginalPretty, pageContextFinish);
     checkType(pageContextFinish);
     assertPageContextFinish(pageContextFinish);
-    return pageContextFinish;
+    return getPageContextReturn(pageContextFinish);
+}
+function getPageContextReturn(pageContextFinish) {
+    if (!hasProp(pageContextFinish, '_globalContext', 'object'))
+        return pageContextFinish;
+    return getPageContextPublicServer(pageContextFinish);
 }
 async function renderPageServerEntryOnceBegin(pageContextInit, requestId, asyncStore) {
     // Invalid config
@@ -217,7 +224,9 @@ async function renderPageServerEntryRecursive_onError(err, pageContextBegin, pag
     catch (errErrorPage) {
         // Handle `throw redirect()` and `throw render()` while rendering error page
         if (isAbortError(errErrorPage)) {
-            const handled = await handleAbort(errErrorPage, pageContextBegin, pageContextNominalPageBegin, requestId, pageContextErrorPageInit, globalContext);
+            const handled = await handleAbort(errErrorPage, pageContextBegin, 
+            // The error page is the page that aborted
+            pageContextErrorPageInit, requestId, pageContextErrorPageInit, globalContext);
             if (handled.pageContextReturn) {
                 // - throw redirect()
                 // - throw render(url)
@@ -470,14 +479,14 @@ pageContextNominalPageBegin, requestId, pageContextErrorPageInit, globalContext)
     logAbort(errAbort, globalContext._isProduction, pageContextNominalPageBegin);
     const pageContextAbort = errAbort._pageContextAbort;
     assert(pageContextAbort);
-    addNewPageContextAborted(pageContextBegin.pageContextsAborted, pageContextNominalPageBegin, pageContextAbort);
+    addNewPageContextAborted(pageContextBegin.pageContextsAborted, pageContextNominalPageBegin, pageContextAbort, getPageContextPublicServer);
     const pageContext = fork(pageContextBegin);
     const pageContextAddendumAbort = getPageContextAddendumAbort(pageContextBegin.pageContextsAborted);
     objectAssign(pageContext, pageContextAddendumAbort);
     assert(pageContextAddendumAbort === pageContextAbort);
     // Client-side navigation — [`pageContext.json` request](https://vike.dev/pageContext.json)
     if (pageContextBegin.isClientSideNavigation) {
-        let pageContextSerialized;
+        let pageContextJson;
         if (pageContextAbort.abortStatusCode) {
             const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
             const abortCall = pageContextAbort._abortCall;
@@ -487,12 +496,12 @@ pageContextNominalPageBegin, requestId, pageContextErrorPageInit, globalContext)
             objectAssign(pageContext, pageContextErrorPageInit, true);
             updateType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
-            pageContextSerialized = getPageContextClientSerialized(pageContext, false);
+            pageContextJson = getPageContextJson(pageContext);
         }
         else {
-            pageContextSerialized = getPageContextClientSerializedAbort(pageContextAbort, false);
+            pageContextJson = getPageContextClientSerializedAbort(pageContextAbort, false);
         }
-        const httpResponse = await createHttpResponsePageJson(pageContextSerialized);
+        const httpResponse = await createHttpResponsePageJson(pageContextJson, pageContext);
         objectAssign(pageContext, { httpResponse });
         return { pageContextReturn: pageContext };
     }

package/dist/shared-server-client/createGlobalContextShared.d.ts

@@ -42,6 +42,10 @@ declare function createGlobalContextShared<GlobalContextAdded extends {}, Global
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: PageConfigRuntime[];
+        pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & GlobalContextAdded & Awaited<GlobalContextAddedAsync>>;
 type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
@@ -74,5 +78,9 @@ declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown)
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: PageConfigRuntime[];
+        pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 };

package/dist/shared-server-client/createGlobalContextShared.js

@@ -79,7 +79,7 @@ addGlobalContextTmp, addGlobalContextAsync) {
     }
 }
 function createGlobalContextBase(virtualFileExportsGlobalEntry) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
+    const { pageFilesAll, pageConfigs, pageConfigGlobal, environmentEntries } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
     const globalContextAddendum = resolveGlobalContextConfig(pageConfigs, pageConfigGlobal);
     const globalContext = {
@@ -94,6 +94,7 @@ function createGlobalContextBase(virtualFileExportsGlobalEntry) {
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
+        _environmentEntries: environmentEntries,
         _allPageIds: allPageIds,
         ...globalContextAddendum,
     };

package/dist/shared-server-client/getPageContextPublicShared.js

@@ -3,14 +3,12 @@ export { assertPropertyGetters };
 import { assert, assertWarning } from '../utils/assert.js';
 import { compareString } from '../utils/compareString.js';
 import { isPropertyGetter } from '../utils/isPropertyGetter.js';
-import { addIs404ToPageProps } from './addIs404ToPageProps.js';
 import { getGlobalContextPublicShared } from './getGlobalContextPublicShared.js';
 import { getPublicProxy } from './getPublicProxy.js';
 function getPageContextPublicShared(pageContext) {
     assert(!pageContext._isProxyObject);
     assert(!pageContext.globalContext); // pageContext.globalContext should only be available to users — Vike itself should use pageContext._globalContext instead
     assert(pageContext._isOriginalObject); // ensure we preserve the original object reference
-    addIs404ToPageProps(pageContext);
     // TO-DO/next-major-release: remove
     if (!('_pageId' in pageContext)) {
         Object.defineProperty(pageContext, '_pageId', {

package/dist/shared-server-client/getPageFiles/parseVirtualFileExportsGlobalEntry.d.ts

@@ -1,8 +1,16 @@
 export { parseVirtualFileExportsGlobalEntry };
+export { parseGlobalEntryPageConfigs };
+export type { EnvironmentEntry };
 import { type PageFile } from './getPageFileObject.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../types/PageConfig.js';
 declare function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry: unknown): {
     pageFilesAll: PageFile[];
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;
+    environmentEntries: Record<string, null | EnvironmentEntry>;
+};
+type EnvironmentEntry = ReturnType<typeof parseGlobalEntryPageConfigs>;
+declare function parseGlobalEntryPageConfigs(virtualFileExportsGlobalEntry: unknown): {
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
 };

package/dist/shared-server-client/getPageFiles/parseVirtualFileExportsGlobalEntry.js

@@ -1,4 +1,5 @@
 export { parseVirtualFileExportsGlobalEntry };
+export { parseGlobalEntryPageConfigs };
 // TO-DO/next-major-release: remove old design code, and remove all assertions.
 import { assert } from '../../utils/assert.js';
 import { cast } from '../../utils/cast.js';
@@ -6,6 +7,7 @@ import { hasProp } from '../../utils/hasProp.js';
 import { isArray } from '../../utils/isArray.js';
 import { isCallable } from '../../utils/isCallable.js';
 import { isObject } from '../../utils/isObject.js';
+import { objectMap } from '../../utils/objectMap.js';
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
@@ -21,12 +23,12 @@ function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry) {
     assert(hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page.client') ||
         hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page.server'));
     assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesList', 'string[]'));
-    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigsSerialized'));
-    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigGlobalSerialized'));
-    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExportsGlobalEntry;
-    assertPageConfigsSerialized(pageConfigsSerialized);
-    assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
-    const { pageConfigs, pageConfigGlobal } = parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized);
+    const { pageConfigs, pageConfigGlobal } = parseGlobalEntryPageConfigs(virtualFileExportsGlobalEntry);
+    // The global entries of the additional environments (e.g. `rsc`)
+    // - `null` in development: they're imported with environment.runner.import()
+    const environmentEntries = hasProp(virtualFileExportsGlobalEntry, 'environmentEntries', 'object')
+        ? objectMap(virtualFileExportsGlobalEntry.environmentEntries, (environmentEntry) => environmentEntry === null ? null : parseGlobalEntryPageConfigs(environmentEntry))
+        : {};
     const pageFilesMap = {};
     parseGlobResult(virtualFileExportsGlobalEntry.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
@@ -72,7 +74,15 @@ function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry) {
     pageFilesAll.forEach(({ filePath }) => {
         assert(!filePath.includes('\\'));
     });
-    return { pageFilesAll, pageConfigs, pageConfigGlobal };
+    return { pageFilesAll, pageConfigs, pageConfigGlobal, environmentEntries };
+}
+function parseGlobalEntryPageConfigs(virtualFileExportsGlobalEntry) {
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigsSerialized'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExportsGlobalEntry;
+    assertPageConfigsSerialized(pageConfigsSerialized);
+    assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
+    return parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized);
 }
 function parseGlobResult(globObject) {
     const ret = [];

package/dist/shared-server-client/hooks/execHook.d.ts

@@ -38,7 +38,7 @@ declare function execHookSingleWithReturn<PageContext extends PageContextExecHoo
 }>;
 declare function isUserHookError(err: unknown): false | HookLoc;
 declare function execHookSingleWithoutPageContext<HookReturn>(hook: Omit<HookInternal, 'hookFn'>, globalContext: GlobalContextPublicMinimum, hookFnCaller: () => HookReturn): Promise<HookReturn>;
-declare function execHookSingleSync<PageContext extends PageContextExecHook>(hook: Omit<HookInternal<PageContext>, 'hookTimeout'>, globalContext: GlobalContextPublicMinimum, pageContext: PageContext | null, getPageContextPublic: (pageContext: PageContext) => PageContext, hookFnCaller?: () => unknown): {
+declare function execHookSingleSync<PageContext extends PageContextExecHook>(hook: Omit<HookInternal<PageContext>, 'hookTimeout'>, globalContext: GlobalContextPublicMinimum, pageContext: PageContext | null, getPageContextPublic: (pageContext: PageContext) => PageContext, hookFnCaller?: (pageContextPublic: PageContext | null) => unknown): {
     hookReturn: unknown;
 };
 type HookPublic = {

package/dist/shared-server-client/hooks/execHook.js

@@ -61,8 +61,8 @@ async function execHookSingleWithoutPageContext(hook, globalContext, hookFnCalle
 }
 function execHookSingleSync(hook, globalContext, pageContext, getPageContextPublic, hookFnCaller) {
     const pageContextPublic = pageContext && getPageContextPublic(pageContext);
-    hookFnCaller ?? (hookFnCaller = () => hook.hookFn(pageContextPublic));
-    const hookReturn = execHookBase(hookFnCaller, hook, globalContext, pageContextPublic);
+    const call = hookFnCaller ? () => hookFnCaller(pageContextPublic) : () => hook.hookFn(pageContextPublic);
+    const hookReturn = execHookBase(call, hook, globalContext, pageContextPublic);
     return { hookReturn };
 }
 function execHookBaseAsync(hookFnCaller, hook, globalContext, pageContextPublic) {

package/dist/shared-server-client/route/abort.d.ts

@@ -113,7 +113,7 @@ type PageContextAborted = {
     _pageContextAbort: PageContextAbort;
 } & PageContextMin;
 declare function getPageContextAddendumAbort(pageContextsAborted: PageContextAborted[]): PageContextAbort | null;
-declare function addNewPageContextAborted(pageContextsAborted: PageContextAborted[], pageContext: PageContextMin, pageContextAbort: PageContextAbort): void;
+declare function addNewPageContextAborted<PageContext extends PageContextMin>(pageContextsAborted: PageContextAborted[], pageContext: PageContext, pageContextAbort: PageContextAbort, getPageContextPublic: (pageContext: PageContext & PageContextAborted) => PageContextAborted): void;
 type InferTwoOverloads<F extends Function> = F extends {
     (...a1: infer A1): infer R1;
     (...a0: infer A0): infer R0;

package/dist/shared-server-client/route/abort.js

@@ -189,9 +189,11 @@ function getPageContextAddendumAbort(pageContextsAborted) {
     // Sets pageContext._urlRewrite from pageContextAbort._urlRewrite
     return pageContextAbort;
 }
-function addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort) {
+function addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort, 
+// `pageContextsAborted` is exposed to users: https://vike.dev/pageContext#pageContextsAborted
+getPageContextPublic) {
     objectAssign(pageContext, { _pageContextAbort: pageContextAbort });
-    pageContextsAborted.push(pageContext);
+    pageContextsAborted.push(getPageContextPublic(pageContext));
     assertNoInfiniteAbortLoop(pageContextsAborted);
 }
 // There doesn't seem to be a way to count the number of HTTP redirects (Vike doesn't have access to the HTTP request headers/cookies)

package/dist/shared-server-client/streamedValues.d.ts

@@ -0,0 +1,22 @@
+export { markers };
+export type { Line };
+export type { LineContent };
+declare const markers: {
+    readableStream: string;
+    promise: string;
+    asyncIterable: string;
+};
+type LineContent = {
+    t: string;
+} | {
+    b: string;
+} | {
+    v: unknown;
+} | {
+    end: true;
+} | {
+    error: true;
+};
+type Line = {
+    s: number;
+} & LineContent;

package/dist/shared-server-client/streamedValues.js

@@ -0,0 +1,24 @@
+// The wire format of streamed pageContext values: a ReadableStream, a Promise or an async iterable (e.g. an async
+// generator) anywhere in a passToClient value. https://vike.dev/passToClient#streaming
+//
+// - Serialization: a marker followed by the value's id, e.g. `"!VikePromise:0"` (the serializer escapes user strings
+//   starting with `!`, so a user string can't be mistaken for a marker).
+// - Delivery: the serialized pageContext is wrapped in a JSON array (the client loads its decoder only then) followed, in
+//   the same response, by one JSON line per chunk / result:
+//   - HTML: see server/runtime/renderPageServer/html/streamedValuesHtml.ts
+//   - `.pageContext.json`: see server/runtime/renderPageServer/getPageContextJson.ts
+//
+// Lines:
+//   {"s":<id>,"t":<text>}      A chunk that is a Uint8Array of valid UTF-8
+//   {"s":<id>,"b":<base64url>} A chunk that is any other Uint8Array
+//   {"s":<id>,"v":<value>}     Any other chunk, or the value of a Promise (@brillout/json-serializer)
+//   {"s":<id>,"end":true}      The end of a ReadableStream / async iterable
+//   {"s":<id>,"error":true}    The value failed (the error is logged on the server-side and isn't sent to the client)
+//
+// A chunk or a Promise value can contain further streamed values: they get new ids and their lines follow.
+export { markers };
+const markers = {
+    readableStream: '!VikeStream:',
+    promise: '!VikePromise:',
+    asyncIterable: '!VikeAsyncIterable:',
+};

package/dist/shared-server-node/vike-environments.d.ts

@@ -0,0 +1,4 @@
+export { isEnvironmentBuiltIn };
+export { isEnvironmentNameValid };
+declare function isEnvironmentBuiltIn(environmentName: string): boolean;
+declare function isEnvironmentNameValid(environmentName: string): boolean;

package/dist/shared-server-node/vike-environments.js

@@ -0,0 +1,10 @@
+export { isEnvironmentBuiltIn };
+export { isEnvironmentNameValid };
+// Vike's built-in environments; every other environment name is an additional environment (e.g. `rsc`)
+function isEnvironmentBuiltIn(environmentName) {
+    return environmentName === 'server' || environmentName === 'client';
+}
+// `:` separates the environment name from the page ID in virtual file IDs
+function isEnvironmentNameValid(environmentName) {
+    return environmentName !== '' && !environmentName.includes(':');
+}

package/dist/shared-server-node/virtualFileId.d.ts

@@ -1,5 +1,6 @@
 export { parseVirtualFileId };
 export { generateVirtualFileId };
+export { generateVirtualFileIdAdditionalEnvironment };
 export { virtualFileIdGlobalEntryServer };
 export { virtualFileIdGlobalEntryClientSR };
 export { virtualFileIdGlobalEntryClientCR };
@@ -8,21 +9,22 @@ declare const virtualFileIdGlobalEntryClientSR = "virtual:vike:global-entry:clie
 declare const virtualFileIdGlobalEntryClientCR = "virtual:vike:global-entry:client:client-routing";
 type VirtualFileIdEntryParsed = {
     type: 'global-entry';
-    isForClientSide: boolean;
+    environmentName: string;
     isClientRouting: boolean;
 } | {
     type: 'page-entry';
-    isForClientSide: boolean;
+    environmentName: string;
     pageId: string;
     isExtractAssets: boolean;
 };
 declare function parseVirtualFileId(id: string): false | VirtualFileIdEntryParsed;
 declare function generateVirtualFileId(args: {
     type: 'global-entry';
-    isForClientSide: boolean;
-    isClientRouting: boolean;
+    environmentName: string;
+    isClientRouting?: boolean;
 } | {
     type: 'page-entry';
     pageId: string;
-    isForClientSide: boolean;
+    environmentName: string;
 }): string;
+declare function generateVirtualFileIdAdditionalEnvironment(environmentName: string): string;

package/dist/shared-server-node/virtualFileId.js

@@ -1,10 +1,12 @@
 export { parseVirtualFileId };
 export { generateVirtualFileId };
+export { generateVirtualFileIdAdditionalEnvironment };
 export { virtualFileIdGlobalEntryServer };
 export { virtualFileIdGlobalEntryClientSR };
 export { virtualFileIdGlobalEntryClientCR };
 import { extractAssetsRemoveQuery } from './extractAssetsQuery.js';
 import { assert } from '../utils/assert.js';
+import { isEnvironmentBuiltIn, isEnvironmentNameValid } from './vike-environments.js';
 import { assertIsNotBrowser } from '../utils/assertIsNotBrowser.js';
 import { removeVirtualFileIdPrefix } from '../utils/virtualFileId.js';
 assertIsNotBrowser();
@@ -18,13 +20,6 @@ const virtualFileIdGlobalEntryClientSR =
 const virtualFileIdGlobalEntryClientCR = 
 //
 'virtual:vike:global-entry:client:client-routing';
-// Page entries
-const virtualFileIdPageEntryClient = 
-//
-'virtual:vike:page-entry:client:'; // ${pageId}
-const virtualFileIdPageEntryServer = 
-//
-'virtual:vike:page-entry:server:'; //  ${pageId}
 // Virtual ID prefixes
 const virtualFileIdPageEntryPrefix = 
 //
@@ -38,11 +33,11 @@ function parseVirtualFileId(id) {
         return false;
     // Global entry
     if (id.includes(virtualFileIdGlobalEntryPrefix)) {
-        const isForClientSide = id !== virtualFileIdGlobalEntryServer;
         const isClientRouting = id === virtualFileIdGlobalEntryClientCR;
+        const environmentName = parseGlobalEntryEnvironmentName(id);
         return {
             type: 'global-entry',
-            isForClientSide,
+            environmentName,
             isClientRouting,
         };
     }
@@ -51,52 +46,57 @@ function parseVirtualFileId(id) {
         const idOriginal = id;
         id = extractAssetsRemoveQuery(id);
         const isExtractAssets = idOriginal !== id;
-        if (id.startsWith(virtualFileIdPageEntryClient)) {
+        const environmentNameBegin = virtualFileIdPageEntryPrefix.length;
+        const environmentNameEnd = id.indexOf(':', environmentNameBegin);
+        assert(environmentNameEnd > environmentNameBegin);
+        const environmentName = id.slice(environmentNameBegin, environmentNameEnd);
+        const pageIdSerialized = id.slice(environmentNameEnd + 1);
+        const pageId = deserializePageId(pageIdSerialized);
+        if (environmentName === 'client')
             assert(isExtractAssets === false);
-            const pageIdSerialized = id.slice(virtualFileIdPageEntryClient.length);
-            const pageId = deserializePageId(pageIdSerialized);
-            return {
-                type: 'page-entry',
-                pageId,
-                isForClientSide: true,
-                isExtractAssets,
-            };
-        }
-        if (id.startsWith(virtualFileIdPageEntryServer)) {
-            const pageIdSerialized = id.slice(virtualFileIdPageEntryServer.length);
-            const pageId = deserializePageId(pageIdSerialized);
-            return {
-                type: 'page-entry',
-                pageId,
-                isForClientSide: false,
-                isExtractAssets,
-            };
-        }
-        assert(false);
+        return {
+            type: 'page-entry',
+            environmentName,
+            pageId,
+            isExtractAssets,
+        };
     }
     return false;
 }
+function parseGlobalEntryEnvironmentName(id) {
+    if (id === virtualFileIdGlobalEntryServer)
+        return 'server';
+    if (id === virtualFileIdGlobalEntryClientSR || id === virtualFileIdGlobalEntryClientCR)
+        return 'client';
+    const environmentName = id.slice(virtualFileIdGlobalEntryPrefix.length);
+    assert(isEnvironmentNameValid(environmentName));
+    return environmentName;
+}
 function generateVirtualFileId(args) {
     if (args.type === 'global-entry') {
-        const { isForClientSide, isClientRouting } = args;
-        if (!isForClientSide) {
-            return virtualFileIdGlobalEntryServer;
-        }
-        else if (isClientRouting) {
-            return virtualFileIdGlobalEntryClientCR;
-        }
-        else {
-            return virtualFileIdGlobalEntryClientSR;
+        const { environmentName, isClientRouting } = args;
+        assert(isEnvironmentNameValid(environmentName));
+        if (environmentName === 'client') {
+            return isClientRouting ? virtualFileIdGlobalEntryClientCR : virtualFileIdGlobalEntryClientSR;
         }
+        assert(!isClientRouting);
+        if (environmentName === 'server')
+            return virtualFileIdGlobalEntryServer;
+        return `${virtualFileIdGlobalEntryPrefix}${environmentName}`;
     }
     if (args.type === 'page-entry') {
-        const { pageId, isForClientSide } = args;
+        const { pageId, environmentName } = args;
         const pageIdSerialized = serializePageId(pageId);
-        const id = `${isForClientSide ? virtualFileIdPageEntryClient : virtualFileIdPageEntryServer}${pageIdSerialized}`;
-        return id;
+        assert(isEnvironmentNameValid(environmentName));
+        return `${virtualFileIdPageEntryPrefix}${environmentName}:${pageIdSerialized}`;
     }
     assert(false);
 }
+// The global entry of an additional environment (e.g. `rsc`)
+function generateVirtualFileIdAdditionalEnvironment(environmentName) {
+    assert(!isEnvironmentBuiltIn(environmentName));
+    return generateVirtualFileId({ type: 'global-entry', environmentName });
+}
 // Workaround:
 // - We replace virtual:vike:page-entry:client:/ with virtual:vike:page-entry:client:ROOT
 // - In order to avoid Vite to replace `virtual:vike:page-entry:client:/` with `virtual:vike:page-entry:client:`

package/dist/types/Config.d.ts

@@ -211,7 +211,7 @@ type OnRenderHtmlAsync = (pageContext: PageContextServer) => Promise<OnRenderHtm
  * - https://vike.dev/onRenderHtml
  */
 type OnRenderHtmlSync = (pageContext: PageContextServer) => OnRenderHtmlReturn;
-type OnRenderHtmlReturn = DocumentHtml | {
+type OnRenderHtmlReturn = DocumentHtml | void | {
     injectFilter?: (assets: InjectFilterEntry[]) => void;
     documentHtml?: DocumentHtml;
     pageContext?: OnRenderHtmlPageContextReturn | (() => Promise<OnRenderHtmlPageContextReturn> | OnRenderHtmlPageContextReturn);

package/dist/types/PageConfig.d.ts

@@ -78,19 +78,27 @@ type VirtualFileExportsPageEntry = {
  *
  * https://vike.dev/meta
  */
-type ConfigEnv = ({
+type ConfigEnv = {
     /** Load value on the client-side */
     client?: boolean;
-} | {
-    /** @experimental */
-    client?: 'if-client-routing';
-}) & {
     /** Load value on the server-side */
     server?: boolean;
     /** Load value for config files */
     config?: boolean;
     /** Load value only in production (`true`), or only in development (`false`), or always (`undefined`). */
     production?: boolean;
+    /** Load value on the client-side only if the page uses Client Routing
+     *
+     * @experimental
+     */
+    clientRoutingOnly?: boolean;
+    /** Load value in an additional Vike environment, e.g. `rsc`
+     *
+     * @experimental
+     *
+     * https://vike.dev/meta#vike-environments
+     */
+    [environmentName: string]: boolean | undefined;
 };
 type ConfigValueSources = Record<string, // configName
 ConfigValueSource[]>;

package/dist/types/PageContext.d.ts

@@ -27,11 +27,19 @@ import type { PageContextPublicProxyClient } from '../client/runtime-client-rout
 type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & {
     /** https://vike.dev/warning/internals */
     dangerouslyUseInternals: DangerouslyUseInternals<PageContextInternalServer & PageContextAfterRender & PageContextPublicServer>;
-} & Vike.PageContext & Vike.PageContextServer & (Vike.Server extends {
+} & Vike.PageContext & Vike.PageContextServer & PageContextContent & (Vike.Server extends {
     server: string;
 } ? {
     runtime: RuntimeAdapterTarget<Vike.Server['server']>;
 } & PageContextReqResAlias<Vike.Server['server']> : {});
+type PageContextContent = {
+    /**
+     * The content of a non-HTML page — the HTTP response body (SSR) or the file content (pre-rendering).
+     *
+     * https://vike.dev/pageContext#content
+     */
+    content?: string | Uint8Array | ReadableStream<Uint8Array>;
+};
 type PageContextReqResAlias<Server extends string> = ReqResAlias<'req', RuntimeAdapterTarget<Server>> & ReqResAlias<'res', RuntimeAdapterTarget<Server>>;
 type ReqResAlias<Key extends 'req' | 'res', Runtime> = Key extends keyof (Vike.PageContext & Vike.PageContextServer) ? unknown : Key extends keyof Runtime ? Record<Key, Runtime[Key]> : unknown;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
@@ -194,6 +202,15 @@ type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageConte
      * https://vike.dev/pageContext#pageContextsAborted
      */
     pageContextsAborted: Partial<PageContextServer<Data>>[];
+    /**
+     * @experimental
+     *
+     * https://vike.dev/meta#vike-environments
+     */
+    environments?: Record<string, {
+        config: PageContextConfig['config'];
+        pageContext: PageContextServer<Data>;
+    }>;
     isHydration?: undefined;
     isBackwardNavigation?: undefined;
     isHistoryNavigation?: undefined;