vike 0.4.235 → 0.4.236

package/dist/esm/node/runtime/html/serializeContext.d.ts

@@ -2,19 +2,25 @@ export { getPageContextClientSerialized };
 export { getPageContextClientSerializedAbort };
 export { getGlobalContextClientSerialized };
 export type { PageContextSerialization };
+export type { PassToClient };
 import type { UrlRedirect } from '../../../shared/route/abort.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
 type PageContextSerialization = {
     pageId: string;
     routeParams: Record<string, string>;
-    _passToClient: string[];
+    _passToClient: PassToClient;
     is404: null | boolean;
     pageProps?: Record<string, unknown>;
     _pageContextInit: Record<string, unknown>;
     _globalContext: GlobalContextServerInternal;
+    isClientSideNavigation: boolean;
 };
 declare function getPageContextClientSerialized(pageContext: PageContextSerialization): string;
 declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization): string;
+type PassToClient = (string | {
+    prop: string;
+    once?: boolean;
+})[];
 declare function getPageContextClientSerializedAbort(pageContext: Record<string, unknown> & ({
     _urlRedirect: UrlRedirect;
 } | {

package/dist/esm/node/runtime/html/serializeContext.js

@@ -27,20 +27,41 @@ const passToClientBuiltInPageContext = [
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError];
 function getPageContextClientSerialized(pageContext) {
     const passToClientPageContext = getPassToClientPageContext(pageContext);
-    const pageContextClient = applyPassToClient(passToClientPageContext, pageContext);
-    if (passToClientPageContext.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
+    const getObj = (passToClientEntry) => {
+        if (passToClientEntry.once)
+            return undefined; // pass it to client-side globalContext
+        return { obj: pageContext, objName: 'pageContext' };
+    };
+    const res = applyPassToClient(passToClientPageContext, getObj);
+    const pageContextClient = res.objClient;
+    const pageContextClientProps = res.objClientProps;
+    if (pageContextClientProps.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient] = true;
     }
-    const pageContextClientSerialized = serializeObject(pageContextClient, 'pageContext', passToClientPageContext);
+    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, getObj);
     return pageContextClientSerialized;
 }
 function getGlobalContextClientSerialized(pageContext) {
     const passToClient = pageContext._passToClient;
-    const globalContextClient = applyPassToClient(passToClient, pageContext._globalContext);
-    const globalContextClientSerialized = serializeObject(globalContextClient, 'globalContext', passToClient);
+    const globalContext = pageContext._globalContext;
+    const getObj = ({ prop, once }) => {
+        if (once && getPropVal(pageContext, prop)) {
+            assert(typeof pageContext.isClientSideNavigation === 'boolean');
+            if (!pageContext.isClientSideNavigation) {
+                return { obj: pageContext, objName: 'pageContext' }; // pass it to client-side globalContext
+            }
+            else {
+                return undefined; // already passed to client-side
+            }
+        }
+        return { obj: globalContext, objName: 'globalContext' };
+    };
+    const res = applyPassToClient(passToClient, getObj);
+    const globalContextClient = res.objClient;
+    const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, getObj);
     return globalContextClientSerialized;
 }
-function serializeObject(obj, objName, passToClient) {
+function serializeObject(obj, passToClient, getObj) {
     let serialized;
     try {
         serialized = serializeValue(obj);
@@ -49,11 +70,15 @@ function serializeObject(obj, objName, passToClient) {
         const h = (s) => pc.cyan(s);
         let hasWarned = false;
         const propsNonSerializable = [];
-        passToClient.forEach((prop) => {
+        passToClient.forEach((entry) => {
+            const entryNormalized = normalizePassToClientEntry(entry);
+            const { prop } = entryNormalized;
             const res = getPropVal(obj, prop);
             if (!res)
                 return;
             const { value } = res;
+            const { objName } = getObj(entryNormalized) ?? {};
+            assert(objName);
             const varName = `${objName}${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
             try {
                 serializeValue(value, varName);
@@ -103,7 +128,20 @@ function serializeObject(obj, objName, passToClient) {
     return serialized;
 }
 function serializeValue(value, varName) {
-    return stringify(value, { forbidReactElements: true, valueName: varName });
+    return stringify(value, {
+        forbidReactElements: true,
+        valueName: varName,
+        // Prevent Google from crawling URLs in JSON:
+        //  - https://github.com/vikejs/vike/discussions/2541#discussioncomment-13660198
+        //  - https://github.com/vikejs/vike/discussions/2277
+        //  - https://github.com/vikejs/vike/pull/2542
+        replacer(_key, value) {
+            if (typeof value === 'string' && value.startsWith('/')) {
+                // No need to use a reviver: https://github.com/brillout/json-serializer/blob/70fc8ed3741306391b51655b05df24e6963d1fdb/test/main.spec.ts#L74-L80
+                return { replacement: (value = '!' + value) };
+            }
+        },
+    });
 }
 function getPassToClientPageContext(pageContext) {
     let passToClient = [...pageContext._passToClient, ...passToClientBuiltInPageContext];
@@ -139,7 +177,7 @@ function getPageContextClientSerializedAbort(pageContext) {
         assert(unknownProps.length === 0);
     }
     else {
-        // TODO/v1-release: remove
+        // TO-DO/next-major-release: remove
         assertWarning(unknownProps.length === 0, [
             "The following pageContext values won't be available on the client-side:",
             unknownProps.map((p) => `  pageContext[${JSON.stringify(p)}]`),
@@ -150,16 +188,36 @@ function getPageContextClientSerializedAbort(pageContext) {
     }
     return serializeValue(pageContext);
 }
-function applyPassToClient(passToClient, pageContext) {
-    const pageContextClient = {};
-    passToClient.forEach((prop) => {
+function applyPassToClient(passToClient, getObj) {
+    const objClient = {};
+    const objClientProps = [];
+    passToClient.forEach((entry) => {
+        const entryNormalized = normalizePassToClientEntry(entry);
+        const { prop } = entryNormalized;
+        const { obj } = getObj(entryNormalized) ?? {};
+        if (!obj)
+            return;
         // Get value from pageContext
-        const res = getPropVal(pageContext, prop);
+        const res = getPropVal(obj, prop);
         if (!res)
             return;
         const { value } = res;
         // Set value to pageContextClient
-        setPropVal(pageContextClient, prop, value);
+        setPropVal(objClient, prop, value);
+        objClientProps.push(prop);
     });
-    return pageContextClient;
+    return { objClient, objClientProps };
+}
+function normalizePassToClientEntry(entry) {
+    let once;
+    let prop;
+    if (typeof entry === 'string') {
+        prop = entry;
+        once = false;
+    }
+    else {
+        prop = entry.prop;
+        once = entry.once ?? false;
+    }
+    return { prop, once };
 }

package/dist/esm/node/runtime/index-deprecated.js

@@ -1,4 +1,4 @@
-// TO-DO/soon: point package.json#exports['./server'] to this file.
+// TO-DO/eventually: point package.json#exports['./server'] to this file.
 // - Write migration guide, see comment below.
 export * from './index.js';
 import { assertWarning } from './utils.js';

package/dist/esm/node/runtime/index.js

@@ -7,7 +7,7 @@ export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/str
 export { PROJECT_VERSION as version } from './utils.js';
 export { getGlobalContext, getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
 export { createDevMiddleware } from '../runtime-dev/index.js';
-// TODO/v1-release: remove
+// TO-DO/next-major-release: remove
 // Deprecated exports
 export * from '../../types/index-dreprecated.js';
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';

package/dist/esm/node/runtime/page-files/setup.js

@@ -1,3 +1,3 @@
 export {};
-// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
+// TO-DO/next-major-release: remove https://github.com/vikejs/vike/issues/2122
 // This doesn't do anything anymore. (It's kept to avoid introducing a breaking change.)

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

@@ -10,7 +10,7 @@ function assertArguments(...args) {
         showStackTrace: true,
     });
     assertUsage(isObject(pageContextInit), `${prefix} called with ${pc.code(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)} but ${pc.code('pageContextInit')} should be an object.`, { showStackTrace: true });
-    // TODO/v1-release: remove
+    // TO-DO/next-major-release: remove
     if ('url' in pageContextInit) {
         assertWarning(false, '`pageContextInit.url` has been renamed to `pageContextInit.urlOriginal`: replace `renderPage({ url })` with `renderPage({ urlOriginal })`. (See https://vike.dev/migration/0.4.23 for more information.)', { showStackTrace: true, onlyOnce: true });
         pageContextInit.urlOriginal = pageContextInit.url;

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

@@ -28,6 +28,7 @@ declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null
     __getPageAssets: GetPageAssets;
     _globalContext: GlobalContextServerInternal;
     abortStatusCode?: AbortStatusCode;
+    headersResponse?: Headers;
 }): Promise<HttpResponse>;
 declare function createHttpResponse404(errMsg404: string): HttpResponse;
 declare function createHttpResponseBaseIsMissing(urlOriginal: string, baseServer: string): HttpResponse;

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

@@ -9,8 +9,8 @@ import { assert, assertWarning, escapeHtml } from '../utils.js';
 import { getErrorPageId, isErrorPage } from '../../../shared/error-page.js';
 import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
 import { getEarlyHints } from './getEarlyHints.js';
-import { getCacheControl } from './createHttpResponse/getCacheControl.js';
 import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfiniteHttpRedirect.js';
+import { cacheControlDisable } from './getCacheControl.js';
 async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
@@ -29,10 +29,13 @@ async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     }
     const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
     const headers = [];
-    const cacheControl = getCacheControl(pageContext.pageId, pageContext._globalContext._pageConfigs, statusCode);
-    if (cacheControl) {
-        headers.push(['Cache-Control', cacheControl]);
-    }
+    const headersResponse = pageContext.headersResponse || new Headers();
+    headersResponse.forEach((value, key) => {
+        headers.push([key, value]);
+    });
+    // An 5xx error page shouldn't be cached (it should be temporary)
+    if (statusCode >= 500)
+        headersResponse.set('Cache-Control', cacheControlDisable);
     return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
 }
 function createHttpResponse404(errMsg404) {
@@ -102,7 +105,7 @@ function createHttpResponse(statusCode, contentType, headers, htmlRender, earlyH
     return {
         statusCode,
         headers,
-        // TODO/v1-release: remove
+        // TO-DO/next-major-release: remove
         get contentType() {
             assertWarning(false, 'pageContext.httpResponse.contentType is deprecated and will be removed in the next major release. Use pageContext.httpResponse.headers instead, see https://vike.dev/migration/0.4.134', { onlyOnce: true });
             return contentType;

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;
 } & {
@@ -125,7 +125,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/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,13 +2,14 @@ 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);
@@ -18,8 +19,8 @@ async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
 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 +30,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 +64,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 +103,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

@@ -143,8 +143,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[]>;
     } & {
@@ -277,8 +278,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

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

@@ -10,7 +10,7 @@ type PageContextInit = Pick<PageContextInternalServer, 'urlOriginal' | 'headersO
     /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
     /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
 };
-type PageContextBegin = Awaited<ReturnType<typeof getPageContextBegin>>;
+type PageContextBegin = ReturnType<typeof getPageContextBegin>;
 declare function renderPage<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInit>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
     httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;
@@ -18,7 +18,7 @@ declare let asyncHookWrapper: <PageContext>(_httpRequestId: number, ret: () => P
     pageContextReturn: Awaited<PageContext>;
 }>;
 declare function renderPage_addAsyncHookwrapper(wrapper: typeof asyncHookWrapper): void;
-declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, httpRequestId: number): Promise<{
+declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, httpRequestId: number): {
     _isOriginalObject: true;
     isPageContext: true;
 } & {
@@ -132,4 +132,4 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
     headers: Record<string, string> | null;
 } & {
     _httpRequestId: number;
-}>;
+};