vike 0.4.235 → 0.4.236-commit-64431e7

package/dist/esm/node/runtime/renderPage/createPageContextServerSide.d.ts

@@ -13,7 +13,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
 } | {
     isPrerendering: true;
     ssr?: undefined;
-}): Promise<{
+}): {
     _isOriginalObject: true;
     isPageContext: true;
 } & {
@@ -41,24 +41,12 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         pages: {
             [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
         };
-    } & ({
+    } & (({
         _isProduction: false;
         _isPrerendering: false;
         assetsManifest: null;
-        _viteDevServer: import("vite").ViteDevServer;
-        viteConfig: import("vite").ResolvedConfig;
-        viteConfigRuntime: {
-            root: string;
-            build: {
-                outDir: string;
-            };
-            _baseViteOriginal: string;
-            vitePluginServerEntry: {
-                inject: boolean | undefined;
-            };
-        };
-        baseServer: string;
-        baseAssets: string;
+        _viteDevServer: import("vite").ViteDevServer | undefined;
+        viteConfig: import("vite").ResolvedConfig | undefined;
         isClientSide: false;
         _pageRoutes: import("../../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -68,19 +56,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         _isProduction: true;
         assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
-        viteConfigRuntime: {
-            root: string;
-            build: {
-                outDir: string;
-            };
-            _baseViteOriginal: string;
-            vitePluginServerEntry: {
-                inject: boolean | undefined;
-            };
-        };
         _usesClientRouter: boolean;
-        baseServer: string;
-        baseAssets: string;
         isClientSide: false;
         _pageRoutes: import("../../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -90,6 +66,13 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         _isProduction: true;
         assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+    }) & {
+        baseServer: string;
+        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -100,12 +83,6 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
                 inject: boolean | undefined;
             };
         };
-        _usesClientRouter: boolean;
-        baseServer: string;
-        baseAssets: string;
-        isClientSide: false;
-        _pageRoutes: import("../../../__internal/index.js").PageRoutes;
-        _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
     });
     _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
     _baseServer: string;
@@ -125,7 +102,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
     url: string;
 } & {
     headers: Record<string, string> | null;
-}>;
+};
 declare function createPageContextServerSideWithoutGlobalContext(pageContextInit: PageContextInit): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/esm/node/runtime/renderPage/createPageContextServerSide.js

@@ -3,7 +3,7 @@ export { createPageContextServerSideWithoutGlobalContext };
 import { assert, assertUsage, assertWarning, augmentType, normalizeHeaders, objectAssign } from '../utils.js';
 import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
 import { createPageContextObject, createPageContextShared } from '../../../shared/createPageContextShared.js';
-async function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
+function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
     urlHandler: null,
     isClientSideNavigation: false,
 }, }) {
@@ -11,7 +11,7 @@ async function createPageContextServerSide(pageContextInit, globalContext, { isP
     const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
     objectAssign(pageContextCreated, {
         _globalContext: globalContext,
-        _pageFilesAll: globalContext._pageFilesAll, // TODO/v1-release: remove
+        _pageFilesAll: globalContext._pageFilesAll, // TO-DO/next-major-release: remove
         // We use pageContext._baseServer and pageContext._baseAssets instead of pageContext._globalContext.baseServer and pageContext._globalContext.baseAssets because the Base URLs can (eventually one day if needed) be made non-global
         _baseServer: globalContext.baseServer,
         _baseAssets: globalContext.baseAssets,
@@ -33,7 +33,7 @@ async function createPageContextServerSide(pageContextInit, globalContext, { isP
         }
         else if (pageContextInit.headers) {
             headers = pageContextInit.headers;
-            // TODO/next-major-release: remove
+            // TO-DO/next-major-release: remove
             assertWarning(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
         }
         else {
@@ -41,7 +41,7 @@ async function createPageContextServerSide(pageContextInit, globalContext, { isP
         }
         objectAssign(pageContextCreated, { headers });
     }
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal);
+    const pageContextAugmented = createPageContextShared(pageContextCreated, globalContext._vikeConfigPublicGlobal);
     augmentType(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }

package/dist/esm/node/runtime/renderPage/execHookDataAndOnBeforeRender.js

@@ -6,7 +6,7 @@ async function execHookDataAndOnBeforeRender(pageContext) {
         return;
     }
     const hooks = await execHookServer('data', pageContext);
-    const dataHook = hooks[0]; // TO-DO/soon: support cumulative
+    const dataHook = hooks[0]; // TO-DO/soon/cumulative-hooks: support cumulative
     if (dataHook) {
         // Note: hookReturn can be anything (e.g. an object) and is to be assigned to pageContext.data
         const pageContextFromHook = {
@@ -19,7 +19,7 @@ async function execHookDataAndOnBeforeRender(pageContext) {
         }
     }
     const res = await execHookServer('onBeforeRender', pageContext);
-    const onBeforeRenderHook = res[0]; // TO-DO/soon: support cumulative
+    const onBeforeRenderHook = res[0]; // TO-DO/soon/cumulative-hooks: support cumulative
     if (onBeforeRenderHook) {
         const { hookReturn } = onBeforeRenderHook;
         assertOnBeforeRenderHookReturn(hookReturn, onBeforeRenderHook.hookFilePath);

package/dist/esm/node/runtime/renderPage/getCacheControl.d.ts

@@ -0,0 +1,5 @@
+export { getCacheControl };
+export { cacheControlDisable };
+import type { PageConfigRuntime } from '../../../types/PageConfig.js';
+declare const cacheControlDisable = "no-store, max-age=0";
+declare function getCacheControl(pageId: string | null, pageConfigs: PageConfigRuntime[]): string;

package/dist/esm/node/runtime/renderPage/{createHttpResponse/getCacheControl.js → getCacheControl.js}

@@ -1,13 +1,12 @@
 export { getCacheControl };
-import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValueRuntime.js';
-const defaultValue = 'no-store, max-age=0';
-function getCacheControl(pageId, pageConfigs, statusCode) {
-    // TODO/v1-release: remove
+export { cacheControlDisable };
+import { getPageConfig } from '../../../shared/page-configs/helpers.js';
+import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValueRuntime.js';
+const cacheControlDisable = 'no-store, max-age=0';
+function getCacheControl(pageId, pageConfigs) {
+    // TO-DO/next-major-release: remove this line
     if (pageConfigs.length === 0)
-        return defaultValue;
-    if (statusCode > 499)
-        return defaultValue;
+        return cacheControlDisable;
     if (pageId) {
         const pageConfig = getPageConfig(pageId, pageConfigs);
         const configValue = getConfigValueRuntime(pageConfig, 'cacheControl', 'string');
@@ -18,5 +17,5 @@ function getCacheControl(pageId, pageConfigs, statusCode) {
     // - Disabling caching by default is the safest strategy, because caching is problematic with authentication as described in https://github.com/vikejs/vike/issues/1275#issuecomment-1824366875
     // - Are there use cases when we don't need to disable caching?
     //   - When there isn't any <script id="vike_pageContext" type="application/json"> then we can safely have caching. (We don't implement this exception because we're lazy and it's quite a rare situation.)
-    return defaultValue;
+    return cacheControlDisable;
 }

package/dist/esm/node/runtime/renderPage/getHttpResponseBody.js

@@ -56,7 +56,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             const body = await getHtmlString(htmlRender);
             return body;
         },
-        // TODO/v1-release: remove
+        // TO-DO/next-major-release: remove
         async getNodeStream() {
             assertWarning(false, '`pageContext.httpResponse.getNodeStream()` is outdated, use `pageContext.httpResponse.getReadableNodeStream()` instead. ' +
                 streamDocs, { onlyOnce: true, showStackTrace: true });
@@ -66,7 +66,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             }
             return nodeStream;
         },
-        // TODO/v1-release: remove
+        // TO-DO/next-major-release: remove
         getWebStream() {
             assertWarning(false, '`pageContext.httpResponse.getWebStream(res)` is outdated, use `pageContext.httpResponse.getReadableWebStream(res)` instead. ' +
                 streamDocs, { onlyOnce: true, showStackTrace: true });
@@ -76,7 +76,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             }
             return webStream;
         },
-        // TODO/v1-release: remove
+        // TO-DO/next-major-release: remove
         pipeToWebWritable(writable) {
             assertWarning(false, '`pageContext.httpResponse.pipeToWebWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
                 streamDocs, { onlyOnce: true, showStackTrace: true });
@@ -85,7 +85,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
                 assertUsage(false, getErrMsg(htmlRender, renderHook, 'pipeToWebWritable()'));
             }
         },
-        // TODO/v1-release: remove
+        // TO-DO/next-major-release: remove
         pipeToNodeWritable(writable) {
             assertWarning(false, '`pageContext.httpResponse.pipeToNodeWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
                 streamDocs, { onlyOnce: true, showStackTrace: true });

package/dist/esm/node/runtime/renderPage/getPageAssets/retrieveAssetsProd.js

@@ -9,7 +9,7 @@ function retrieveAssetsProd(clientDependencies, assetsManifest, includeAssetsImp
     clientDependencies.forEach(({ id, onlyAssets, eagerlyImported }) => {
         if (eagerlyImported)
             return; // Eagerly imported assets aren't imported with import() and therefore don't create a new Rollup entry and aren't listed in the manifest file
-        // TODO/v1-release: remove
+        // TO-DO/next-major-release: remove
         if (includeAssetsImportedByServer &&
             onlyAssets &&
             id.includes('.page.server.') &&

package/dist/esm/node/runtime/renderPage/getPageAssets.js

@@ -1,7 +1,7 @@
 export { getPageAssets };
 export { setResolveClientEntriesDev };
 export { resolveIncludeAssetsImportedByServer };
-import { assert, prependBase, toPosixPath, unique, getGlobalObject } from '../utils.js';
+import { assert, prependBase, toPosixPath, unique, getGlobalObject, getViteRPC } from '../utils.js';
 import { retrieveAssetsDev } from './getPageAssets/retrieveAssetsDev.js';
 import { retrieveAssetsProd } from './getPageAssets/retrieveAssetsProd.js';
 import { inferMediaType } from './inferMediaType.js';
@@ -14,18 +14,11 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     const globalContext = pageContext._globalContext;
     const { _isProduction: isProduction } = globalContext;
     const isDev = !isProduction;
-    let assetUrls;
-    let clientEntriesSrc;
-    if (isDev) {
-        const { _viteDevServer: viteDevServer } = globalContext;
-        clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer));
-        assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
-    }
-    else {
-        const { assetsManifest } = globalContext;
-        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, assetsManifest));
-        assetUrls = retrieveAssetsProd(clientDependencies, assetsManifest, resolveIncludeAssetsImportedByServer(pageContext._globalContext.config));
-    }
+    const { assetUrls, clientEntriesSrc } = isDev
+        ? !globalContext._viteDevServer
+            ? await getViteRPC().retrievePageAssetsDevRPC(clientDependencies, clientEntries)
+            : await retrievePageAssetsDev(globalContext._viteDevServer, clientDependencies, clientEntries)
+        : retrievePageAssetsProd(globalContext.assetsManifest, clientDependencies, clientEntries, resolveIncludeAssetsImportedByServer(globalContext.config));
     let pageAssets = [];
     unique([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
         const { mediaType = null, assetType = null } = inferMediaType(src) || {};
@@ -59,6 +52,16 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     await sortPageAssetsForEarlyHintsHeader(pageAssets, isProduction);
     return pageAssets;
 }
+async function retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries) {
+    const clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer));
+    const assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
+    return { clientEntriesSrc, assetUrls };
+}
+function retrievePageAssetsProd(assetsManifest, clientDependencies, clientEntries, includeAssetsImportedByServer) {
+    const clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, assetsManifest));
+    const assetUrls = retrieveAssetsProd(clientDependencies, assetsManifest, resolveIncludeAssetsImportedByServer(includeAssetsImportedByServer));
+    return { clientEntriesSrc, assetUrls };
+}
 function resolveClientEntriesProd(clientEntry, assetsManifest) {
     const { manifestEntry } = getManifestEntry(clientEntry, assetsManifest);
     assert(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });

package/dist/esm/node/runtime/renderPage/loadPageConfigsLazyServerSide.d.ts

@@ -1,11 +1,13 @@
 export { loadPageConfigsLazyServerSideAndExecHook };
 export type { PageContext_loadPageConfigsLazyServerSide };
 export type { PageConfigsLazy };
+import { type VikeConfigPublicPageLazy } from '../../../shared/getPageFiles.js';
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
 import { type PageContextExecHookServer } from './execHookServer.js';
+import type { PassToClient } from '../html/serializeContext.js';
 type PageContextExecuteHook = Omit<PageContextExecHookServer, keyof Awaited<ReturnType<typeof loadPageConfigsLazyServerSide>>>;
 type PageContext_loadPageConfigsLazyServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
     pageId: string;
@@ -13,19 +15,21 @@ type PageContext_loadPageConfigsLazyServerSide = PageContextGetPageAssets & Page
     _globalContext: GlobalContextServerInternal;
 };
 type PageConfigsLazy = PromiseType<ReturnType<typeof loadPageConfigsLazyServerSide>>;
-declare function loadPageConfigsLazyServerSideAndExecHook<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecuteHook>(pageContext: PageContext): Promise<PageContext & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+declare function loadPageConfigsLazyServerSideAndExecHook<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecuteHook>(pageContext: PageContext): Promise<PageContext & VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
-    _passToClient: string[];
+    _passToClient: PassToClient;
     _pageFilePathsLoaded: string[];
+    headersResponse: Headers;
 } & {
     __getPageAssets: () => Promise<PageAsset[]>;
 }>;
-declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
-    _passToClient: string[];
+    _passToClient: PassToClient;
     _pageFilePathsLoaded: string[];
+    headersResponse: Headers;
 } & {
     __getPageAssets: () => Promise<PageAsset[]>;
 }>;

package/dist/esm/node/runtime/renderPage/loadPageConfigsLazyServerSide.js

@@ -2,24 +2,26 @@ export { loadPageConfigsLazyServerSideAndExecHook };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { assert, assertUsage, assertWarning, hasProp, isArrayOfStrings, objectAssign, isArray, } from '../utils.js';
+import { assertUsage, assertWarning, hasProp, objectAssign } from '../utils.js';
 import { getPageAssets } from './getPageAssets.js';
 import { debugPageFiles } from './debugPageFiles.js';
 import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
 import { execHookServer } from './execHookServer.js';
+import { getCacheControl } from './getCacheControl.js';
 async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
     const pageContextAddendum = await loadPageConfigsLazyServerSide(pageContext);
     objectAssign(pageContext, pageContextAddendum);
     await execHookServer('onCreatePageContext', pageContext);
     return pageContext;
 }
+// TODO/now: define new function resolveAfterLoad() ?
 async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
-    const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
-        loadPageUserFiles(pageContext._globalContext._pageFilesAll, pageConfig, globalContext._pageConfigGlobal, pageContext.pageId, !globalContext._isProduction),
+    const [{ pageFilesLoaded, configPublicPageLazy }] = await Promise.all([
+        loadPageConfigFiles(pageContext._globalContext._pageFilesAll, pageConfig, globalContext._pageConfigGlobal, pageContext.pageId, !globalContext._isProduction),
         analyzePageClientSideInit(pageContext._globalContext._pageFilesAll, pageContext.pageId, {
             sharedPageFilesAlreadyLoaded: true,
         }),
@@ -29,28 +31,27 @@ async function loadPageConfigsLazyServerSide(pageContext) {
     const passToClient = [];
     const errMsg = ' should be an array of strings.';
     if (!isV1Design) {
-        pageContextExports.exportsAll.passToClient?.forEach((e) => {
+        configPublicPageLazy.exportsAll.passToClient?.forEach((e) => {
             assertUsage(hasProp(e, 'exportValue', 'string[]'), `${e.exportSource}${errMsg}`);
             passToClient.push(...e.exportValue);
         });
     }
     else {
-        pageContextExports.configEntries.passToClient?.forEach((e) => {
-            const { configValue } = e;
-            assert(isArray(configValue));
-            const vals = configValue.flat(1);
-            // TODO: improve error message by using (upcoming) new data structure instead of configEntries
-            assertUsage(isArrayOfStrings(vals), `${e.configDefinedAt}${errMsg}`);
-            passToClient.push(...vals);
+        configPublicPageLazy.from.configsCumulative.passToClient?.values.forEach((v) => {
+            const { value } = v;
+            // const { definedAt } = v
+            // assertUsage(isArrayOfStrings(value), `+passToClient value defined at ${definedAt}${errMsg}`)
+            passToClient.push(...value);
         });
     }
     const pageContextAddendum = {};
-    objectAssign(pageContextAddendum, pageContextExports);
+    objectAssign(pageContextAddendum, configPublicPageLazy);
     objectAssign(pageContextAddendum, {
-        Page: pageContextExports.exports.Page,
+        Page: configPublicPageLazy.exports.Page,
         _isHtmlOnly: isHtmlOnly,
         _passToClient: passToClient,
         _pageFilePathsLoaded: pageFilesLoaded.map((p) => p.filePath),
+        headersResponse: resolveHeadersResponse(pageContext, pageContextAddendum),
     });
     objectAssign(pageContextAddendum, {
         __getPageAssets: async () => {
@@ -64,7 +65,7 @@ async function loadPageConfigsLazyServerSide(pageContext) {
             }
         },
     });
-    // TODO/v1-release: remove
+    // TO-DO/next-major-release: remove
     Object.assign(pageContextAddendum, {
         _getPageAssets: async () => {
             assertWarning(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preloading', {
@@ -103,13 +104,31 @@ async function loadPageConfigsLazyServerSide(pageContext) {
     });
     return pageContextAddendum;
 }
-async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {
+async function loadPageConfigFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const pageContextExports = resolveVikeConfigPublicPageLazy(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
+    const configPublicPageLazy = resolveVikeConfigPublicPageLazy(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
     return {
-        pageContextExports,
+        configPublicPageLazy,
         pageFilesLoaded: pageFilesServerSide,
     };
 }
+function resolveHeadersResponse(pageContext, pageContextAddendum) {
+    const headersResponse = mergeHeaders(pageContextAddendum.config.headersResponse);
+    if (!headersResponse.get('Cache-Control')) {
+        const cacheControl = getCacheControl(pageContext.pageId, pageContext._globalContext._pageConfigs);
+        if (cacheControl)
+            headersResponse.set('Cache-Control', cacheControl);
+    }
+    return headersResponse;
+}
+function mergeHeaders(headersList = []) {
+    const headersMerged = new Headers();
+    headersList.forEach((headers) => {
+        new Headers(headers).forEach((value, key) => {
+            headersMerged.append(key, value);
+        });
+    });
+    return headersMerged;
+}

package/dist/esm/node/runtime/renderPage/preparePageContextForPublicUsageServer.js

@@ -1,7 +1,7 @@
 export { preparePageContextForPublicUsageServer };
 import { assertPropertyGetters, preparePageContextForPublicUsage, } from '../../../shared/preparePageContextForPublicUsage.js';
 function preparePageContextForPublicUsageServer(pageContext) {
-    // TODO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
+    // TO-DO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
     assertPropertyGetters(pageContext);
     pageContext = preparePageContextForPublicUsage(pageContext);
     return pageContext;

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.d.ts

@@ -56,24 +56,12 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             pages: {
                 [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
             };
-        } & ({
+        } & (({
             _isProduction: false;
             _isPrerendering: false;
             assetsManifest: null;
-            _viteDevServer: import("vite").ViteDevServer;
-            viteConfig: import("vite").ResolvedConfig;
-            viteConfigRuntime: {
-                root: string;
-                build: {
-                    outDir: string;
-                };
-                _baseViteOriginal: string;
-                vitePluginServerEntry: {
-                    inject: boolean | undefined;
-                };
-            };
-            baseServer: string;
-            baseAssets: string;
+            _viteDevServer: import("vite").ViteDevServer | undefined;
+            viteConfig: import("vite").ResolvedConfig | undefined;
             isClientSide: false;
             _pageRoutes: import("../../../__internal/index.js").PageRoutes;
             _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -83,19 +71,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             _isProduction: true;
             assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
             _viteDevServer: null;
-            viteConfigRuntime: {
-                root: string;
-                build: {
-                    outDir: string;
-                };
-                _baseViteOriginal: string;
-                vitePluginServerEntry: {
-                    inject: boolean | undefined;
-                };
-            };
             _usesClientRouter: boolean;
-            baseServer: string;
-            baseAssets: string;
             isClientSide: false;
             _pageRoutes: import("../../../__internal/index.js").PageRoutes;
             _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -105,6 +81,13 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             _isProduction: true;
             assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
             _viteDevServer: null;
+            _usesClientRouter: boolean;
+            isClientSide: false;
+            _pageRoutes: import("../../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        }) & {
+            baseServer: string;
+            baseAssets: string;
             viteConfigRuntime: {
                 root: string;
                 build: {
@@ -115,12 +98,6 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
                     inject: boolean | undefined;
                 };
             };
-            _usesClientRouter: boolean;
-            baseServer: string;
-            baseAssets: string;
-            isClientSide: false;
-            _pageRoutes: import("../../../__internal/index.js").PageRoutes;
-            _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         });
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _baseServer: string;
@@ -143,8 +120,9 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
     } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
         Page: unknown;
         _isHtmlOnly: boolean;
-        _passToClient: string[];
+        _passToClient: import("../html/serializeContext.js").PassToClient;
         _pageFilePathsLoaded: string[];
+        headersResponse: Headers;
     } & {
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
     } & {
@@ -190,24 +168,12 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             pages: {
                 [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
             };
-        } & ({
+        } & (({
             _isProduction: false;
             _isPrerendering: false;
             assetsManifest: null;
-            _viteDevServer: import("vite").ViteDevServer;
-            viteConfig: import("vite").ResolvedConfig;
-            viteConfigRuntime: {
-                root: string;
-                build: {
-                    outDir: string;
-                };
-                _baseViteOriginal: string;
-                vitePluginServerEntry: {
-                    inject: boolean | undefined;
-                };
-            };
-            baseServer: string;
-            baseAssets: string;
+            _viteDevServer: import("vite").ViteDevServer | undefined;
+            viteConfig: import("vite").ResolvedConfig | undefined;
             isClientSide: false;
             _pageRoutes: import("../../../__internal/index.js").PageRoutes;
             _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -217,19 +183,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             _isProduction: true;
             assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
             _viteDevServer: null;
-            viteConfigRuntime: {
-                root: string;
-                build: {
-                    outDir: string;
-                };
-                _baseViteOriginal: string;
-                vitePluginServerEntry: {
-                    inject: boolean | undefined;
-                };
-            };
             _usesClientRouter: boolean;
-            baseServer: string;
-            baseAssets: string;
             isClientSide: false;
             _pageRoutes: import("../../../__internal/index.js").PageRoutes;
             _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -239,6 +193,13 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             _isProduction: true;
             assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
             _viteDevServer: null;
+            _usesClientRouter: boolean;
+            isClientSide: false;
+            _pageRoutes: import("../../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        }) & {
+            baseServer: string;
+            baseAssets: string;
             viteConfigRuntime: {
                 root: string;
                 build: {
@@ -249,12 +210,6 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
                     inject: boolean | undefined;
                 };
             };
-            _usesClientRouter: boolean;
-            baseServer: string;
-            baseAssets: string;
-            isClientSide: false;
-            _pageRoutes: import("../../../__internal/index.js").PageRoutes;
-            _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         });
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _baseServer: string;
@@ -277,8 +232,9 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
     } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
         Page: unknown;
         _isHtmlOnly: boolean;
-        _passToClient: string[];
+        _passToClient: import("../html/serializeContext.js").PassToClient;
         _pageFilePathsLoaded: string[];
+        headersResponse: Headers;
     } & {
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
     } & {

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -14,6 +14,7 @@ import { preparePageContextForPublicUsageServer } from './preparePageContextForP
 import { execHookGuard } from '../../../shared/route/execHookGuard.js';
 import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
+// TODO/now: rename?
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext.pageId can either be the:
     //  - ID of the page matching the routing, or the