vike 0.4.235-commit-8f42b16 → 0.4.235-commit-d2ac38a

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

@@ -13,7 +13,7 @@ export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
 export { setGlobalContext_isPrerendering };
 export { setGlobalContext_isProduction };
-export { setGlobalContext_buildEntry };
+export { setGlobalContext_buildEntry }; // production entry
 export { clearGlobalContext };
 export { assertBuildInfo };
 export { updateUserFiles };
@@ -30,7 +30,7 @@ import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, obje
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdEntryServer } from '../shared/virtualFiles/virtualFileEntry.js';
 import pc from '@brillout/picocolors';
-import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
+import { loadPageRoutes, loadPageRoutesSync } from '../../shared/route/loadPageRoutes.js';
 import { assertV1Design } from '../shared/assertV1Design.js';
 import { resolveBase } from '../shared/resolveBase.js';
 import { createGlobalContextShared, getGlobalContextSyncErrMsg, } from '../../shared/createGlobalContextShared.js';
@@ -39,7 +39,7 @@ import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
 import { getVikeConfigErrorBuild, setVikeConfigError } from '../shared/getVikeConfigError.js';
 import { hasAlreadyLogged } from './renderPage/isNewError.js';
 const debug = createDebugger('vike:globalContext');
-const globalObject = getGlobalObject('runtime/globalContext.ts', getInitialGlobalContext());
+const globalObject = getGlobalObject('runtime/globalContext.ts', getInitialGlobalObject());
 // Trick to break down TypeScript circular dependency
 // https://chat.deepseek.com/a/chat/s/d7e9f90a-c7f3-4108-9cd5-4ad6caed3539
 const globalObjectTyped = globalObject;
@@ -232,6 +232,7 @@ function assertViteManifest(manifest) {
 async function loadBuildEntry(outDir) {
     debug('loadBuildEntry()');
     if (globalObject.globalContext) {
+        debug('loadBuildEntry() - already done');
         return;
     }
     if (!globalObject.buildEntry) {
@@ -257,6 +258,8 @@ async function loadBuildEntry(outDir) {
     globalObject.buildInfo = buildEntry.buildInfo;
     await setGlobalContext(buildEntry.virtualFileExports);
 }
+// This is the production entry, see:
+// https://github.com/vikejs/vike/blob/798e5465dc3e3e6723b38b601a50350c0a006fb8/packages/vike/node/vite/plugins/pluginBuild/pluginBuildEntry.ts#L47
 async function setGlobalContext_buildEntry(buildEntry) {
     debug('setGlobalContext_buildEntry()');
     setIsProduction(true);
@@ -266,6 +269,7 @@ async function setGlobalContext_buildEntry(buildEntry) {
     assert(globalObject.buildEntry); // ensure no infinite loop
     await loadBuildEntry();
     assertGlobalContextIsDefined();
+    debug('setGlobalContext_buildEntry() - done');
 }
 function assertBuildEntry(buildEntry) {
     assert(isObject(buildEntry));
@@ -362,18 +366,29 @@ async function updateUserFiles() {
     return onSuccess();
 }
 async function setGlobalContext(virtualFileExports) {
+    debug('setGlobalContext()');
     assert(!getVikeConfigErrorBuild());
-    const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext);
+    const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, addGlobalContextAsync, addGlobalContextSync);
     assertV1Design(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);
     assertGlobalContextIsDefined();
     onSetupRuntime();
+    debug('setGlobalContext() - done');
     // Never actually used, only used for TypeScript `ReturnType<typeof setGlobalContext>`
     return globalContext;
 }
-async function addGlobalContext(globalContext) {
+async function addGlobalContextAsync(globalContext) {
+    debug('addGlobalContextAsync()');
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
+    return addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook);
+}
+function addGlobalContextSync(globalContext) {
+    debug('addGlobalContextSync()');
+    const { pageRoutes, onBeforeRouteHook } = loadPageRoutesSync(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
+    return addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook);
+}
+function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
     const globalContextBase = {
         isClientSide: false,
         _pageRoutes: pageRoutes,
@@ -432,10 +447,10 @@ async function addGlobalContext(globalContext) {
 }
 function clearGlobalContext() {
     debug('clearGlobalContext()');
-    objectReplace(globalObject, getInitialGlobalContext(), ['buildEntryPrevious']);
+    objectReplace(globalObject, getInitialGlobalObject(), ['buildEntryPrevious']);
 }
-function getInitialGlobalContext() {
-    debug('getInitialGlobalContext()');
+function getInitialGlobalObject() {
+    debug('getInitialGlobalObject()');
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
     return {
         viteDevServerPromise,

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);
@@ -163,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/renderPage/createHttpResponse/getCacheControl.d.ts

@@ -1,5 +1,5 @@
 export { getCacheControl };
+export { cacheControlDisable };
 import type { PageConfigRuntime } from '../../../../types/PageConfig.js';
-import type { HttpResponse } from '../createHttpResponse.js';
-type StatusCode = HttpResponse['statusCode'];
-declare function getCacheControl(pageId: string | null, pageConfigs: PageConfigRuntime[], statusCode: StatusCode): string;
+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

@@ -1,13 +1,13 @@
+// TODO/now: move
 export { getCacheControl };
+export { cacheControlDisable };
 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) {
-    // TO-DO/next-major-release: remove
+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 +18,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/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 './createHttpResponse/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) {

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,19 +2,22 @@ export { loadPageConfigsLazyServerSideAndExecHook };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { assertUsage, assertWarning, hasProp, objectAssign, isArrayOfStrings } 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 './createHttpResponse/getCacheControl.js';
+// TODO/now: rename?
 async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
     const pageContextAddendum = await loadPageConfigsLazyServerSide(pageContext);
     objectAssign(pageContext, pageContextAddendum);
     await execHookServer('onCreatePageContext', pageContext);
     return pageContext;
 }
+// TODO/now: rename?
 async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
@@ -36,8 +39,9 @@ async function loadPageConfigsLazyServerSide(pageContext) {
     }
     else {
         configPublicPageLazy.from.configsCumulative.passToClient?.values.forEach((v) => {
-            const { value, definedAt } = v;
-            assertUsage(isArrayOfStrings(value), `+passToClient value defined at ${definedAt}${errMsg}`);
+            const { value } = v;
+            // const { definedAt } = v
+            // assertUsage(isArrayOfStrings(value), `+passToClient value defined at ${definedAt}${errMsg}`)
             passToClient.push(...value);
         });
     }
@@ -48,6 +52,7 @@ async function loadPageConfigsLazyServerSide(pageContext) {
         _isHtmlOnly: isHtmlOnly,
         _passToClient: passToClient,
         _pageFilePathsLoaded: pageFilesLoaded.map((p) => p.filePath),
+        headersResponse: resolveHeadersResponse(pageContext, pageContextAddendum),
     });
     objectAssign(pageContextAddendum, {
         __getPageAssets: async () => {
@@ -100,6 +105,7 @@ async function loadPageConfigsLazyServerSide(pageContext) {
     });
     return pageContextAddendum;
 }
+// TODO/now: rename?
 async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
@@ -110,3 +116,23 @@ async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pag
         pageFilesLoaded: pageFilesServerSide,
     };
 }
+function resolveHeadersResponse(
+// TODO/now: merge pageContextAddendum with pageContext
+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/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.js

@@ -170,6 +170,7 @@ async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNo
             return handleErrorWithoutErrorPage(pageContextErrorPageInit);
         }
         else {
+            // TODO/now: minor refactor
             objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
         }
     }

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

@@ -210,6 +210,10 @@ const configDefinitionsBuiltIn = {
         env: { server: true },
         global: true,
     },
+    headersResponse: {
+        env: { server: true },
+        cumulative: true,
+    },
 };
 function getConfigEnv(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);

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

@@ -32,12 +32,10 @@ function getFilesystemRouteString(locationId) {
 function getInheritanceRoot(locationId) {
     return getLogicalPath(locationId, [
         'renderer',
-        // - Enable hooks defined by vike-{react,vue,solid} such as +onBeforeRenderClient to be defined at the root directory. In other words, avoid following error:
-        //   ```bash
-        //   [11:09:43.072][/test-preview.test.ts][npm run preview][stderr] Error: [vike][Wrong Usage] /+onBeforeRenderClient.ts sets the value of the config onBeforeRenderClient which is a custom config that is defined with https://vike.dev/meta at a path that doesn't apply to / — see https://vike.dev/config#inheritance
-        //   ```
-        // - Not sure if it's a good idea? Could it make config inheritance confusing? Let's try for now and see how it goes.
-        // - TO-DO/eventually: update docs https://github.com/vikejs/vike/blob/5fcdc4d5094f1a4dcbefc0b481cdd30a205aef2d/docs/pages/filesystem-routing/%2BPage.mdx?plain=1#L98
+        // Enable hooks defined by vike-{react,vue,solid} such as +onBeforeRenderClient to be defined at the root directory. In other words, avoid following error:
+        // ```bash
+        // [11:09:43.072][/test-preview.test.ts][npm run preview][stderr] Error: [vike][Wrong Usage] /+onBeforeRenderClient.ts sets the value of the config onBeforeRenderClient which is a custom config that is defined with https://vike.dev/meta at a path that doesn't apply to / — see https://vike.dev/config#inheritance
+        // ```
         'pages',
     ]);
 }

package/dist/esm/shared/createGlobalContextShared.d.ts

@@ -9,10 +9,10 @@ import type { GlobalContextServerInternal } from '../node/runtime/globalContext.
 import type { GlobalContextClientInternal } from '../client/runtime-client-routing/globalContext.js';
 import { type Hook } from './hooks/getHook.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
-declare function createGlobalContextShared<GlobalContextAddendum extends object>(virtualFileExports: unknown, globalObject: {
+declare function createGlobalContextShared<GlobalContextAddendum extends Record<string, any>>(virtualFileExports: unknown, globalObject: {
     globalContext?: Record<string, unknown>;
     onCreateGlobalContextHooks?: Hook[];
-}, addGlobalContext?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>): Promise<{
+}, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>, addGlobalContextSync?: (globalContext: GlobalContextBase) => GlobalContextAddendum): Promise<{
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -35,7 +35,7 @@ declare function createGlobalContextShared<GlobalContextAddendum extends object>
     pages: {
         [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
-} & Awaited<GlobalContextAddendum>>;
+} & GlobalContextAddendum>;
 type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
 type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
 declare function createGlobalContextBase(virtualFileExports: unknown): {

package/dist/esm/shared/createGlobalContextShared.js

@@ -7,10 +7,26 @@ import { execHookGlobal } from './hooks/execHook.js';
 import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
 import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
-async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
+async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContextAsync, addGlobalContextSync) {
     const globalContext = createGlobalContextBase(virtualFileExports);
-    const globalContextAddendum = await addGlobalContext?.(globalContext);
-    objectAssign(globalContext, globalContextAddendum);
+    let isNewGlobalContext;
+    if (!globalObject.globalContext) {
+        globalObject.globalContext = globalContext;
+        isNewGlobalContext = false;
+    }
+    else {
+        isNewGlobalContext = true;
+    }
+    if (addGlobalContextSync &&
+        // TODO/next-major-release: remove
+        globalContext._pageConfigs.length > 0) {
+        const globalContextAddendum = addGlobalContextSync?.(globalContext);
+        objectAssign(globalContext, globalContextAddendum);
+    }
+    else {
+        const globalContextAddendum = await addGlobalContextAsync?.(globalContext);
+        objectAssign(globalContext, globalContextAddendum);
+    }
     const onCreateGlobalContextHooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
     let hooksCalled = false;
     if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {
@@ -18,10 +34,7 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
         await execHookGlobal('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage);
         hooksCalled = true;
     }
-    if (!globalObject.globalContext) {
-        globalObject.globalContext = globalContext;
-    }
-    else {
+    if (isNewGlobalContext) {
         // Singleton: ensure all `globalContext` user-land references are preserved & updated.
         if (hooksCalled) {
             objectReplace(globalObject.globalContext, globalContext);

package/dist/esm/shared/route/loadPageRoutes.d.ts

@@ -1,4 +1,5 @@
 export { loadPageRoutes };
+export { loadPageRoutesSync };
 export type { PageRoutes };
 export type { RouteType };
 import type { PageFile } from '../getPageFiles.js';
@@ -28,3 +29,7 @@ declare function loadPageRoutes(pageFilesAll: PageFile[], pageConfigs: PageConfi
     pageRoutes: PageRoutes;
     onBeforeRouteHook: null | Hook;
 }>;
+declare function loadPageRoutesSync(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime, allPageIds: string[]): {
+    pageRoutes: PageRoutes;
+    onBeforeRouteHook: null | Hook;
+};

package/dist/esm/shared/route/loadPageRoutes.js

@@ -1,4 +1,5 @@
 export { loadPageRoutes };
+export { loadPageRoutesSync };
 import { isErrorPageId } from '../error-page.js';
 import { assert, assertUsage, hasProp, slice } from './utils.js';
 import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
@@ -10,8 +11,13 @@ import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/get
 async function loadPageRoutes(
 // Remove all arguments and use GlobalContextServerInternal instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
-    // TO-DO/next-major-release: remove & make this function sync
+    // TO-DO/next-major-release: remove this line, remove this function, rename loadPageRoutesSync() to loadPageRoutes()
     await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));
+    return loadPageRoutesSync(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
+}
+function loadPageRoutesSync(
+// Remove all arguments and use GlobalContextServerInternal instead?
+pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
     const { onBeforeRouteHook, filesystemRoots } = getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal);
     const pageRoutes = getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds);
     return { pageRoutes, onBeforeRouteHook };

package/dist/esm/types/Config.d.ts

@@ -44,6 +44,7 @@ import type { Vike, VikePackages } from './VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../shared/hooks/getHook.js';
 import type { GlobalContext, PageContextClient, PageContextServer } from './PageContext.js';
 import type { InlineConfig } from 'vite';
+import type { PassToClient } from '../node/runtime/html/serializeContext.js';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
@@ -362,7 +363,7 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/passToClient
      */
-    passToClient?: string[] | ImportString;
+    passToClient?: PassToClient | ImportString;
     /** Hook called when page is rendered on the client-side.
      *
      * https://vike.dev/onRenderClient
@@ -508,6 +509,12 @@ type ConfigBuiltIn = {
      * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
      */
     cacheControl?: string;
+    /**
+     * Add HTTP headers to the HTTP response.
+     *
+     * https://vike.dev/headers#response
+     */
+    headersResponse?: HeadersInit;
     /**
      * Make development/preview server available over LAN and public addresses.
      *
@@ -561,6 +568,7 @@ type ConfigBuiltInResolved = {
     redirects?: Record<string, string>[];
     prerender?: Exclude<Config['prerender'], ImportString | undefined>[];
     middleware?: Function[];
+    headersResponse?: HeadersInit[];
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;