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

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

@@ -42,7 +42,7 @@ const loggerRuntime_js_1 = require("./loggerRuntime.js");
 const getVikeConfigError_js_1 = require("../shared/getVikeConfigError.js");
 const isNewError_js_1 = require("./renderPage/isNewError.js");
 const debug = (0, utils_js_1.createDebugger)('vike:globalContext');
-const globalObject = (0, utils_js_1.getGlobalObject)('runtime/globalContext.ts', getInitialGlobalContext());
+const globalObject = (0, utils_js_1.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;
@@ -236,6 +236,7 @@ function assertViteManifest(manifest) {
 async function loadBuildEntry(outDir) {
     debug('loadBuildEntry()');
     if (globalObject.globalContext) {
+        debug('loadBuildEntry() - already done');
         return;
     }
     if (!globalObject.buildEntry) {
@@ -261,6 +262,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);
@@ -270,6 +273,7 @@ async function setGlobalContext_buildEntry(buildEntry) {
     (0, utils_js_1.assert)(globalObject.buildEntry); // ensure no infinite loop
     await loadBuildEntry();
     assertGlobalContextIsDefined();
+    debug('setGlobalContext_buildEntry() - done');
 }
 function assertBuildEntry(buildEntry) {
     (0, utils_js_1.assert)((0, utils_js_1.isObject)(buildEntry));
@@ -366,18 +370,29 @@ async function updateUserFiles() {
     return onSuccess();
 }
 async function setGlobalContext(virtualFileExports) {
+    debug('setGlobalContext()');
     (0, utils_js_1.assert)(!(0, getVikeConfigError_js_1.getVikeConfigErrorBuild)());
-    const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, addGlobalContext);
+    const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, addGlobalContextAsync, addGlobalContextSync);
     (0, assertV1Design_js_1.assertV1Design)(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);
     assertGlobalContextIsDefined();
     (0, utils_js_1.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 (0, loadPageRoutes_js_1.loadPageRoutes)(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
+    return addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook);
+}
+function addGlobalContextSync(globalContext) {
+    debug('addGlobalContextSync()');
+    const { pageRoutes, onBeforeRouteHook } = (0, loadPageRoutes_js_1.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,
@@ -436,10 +451,10 @@ async function addGlobalContext(globalContext) {
 }
 function clearGlobalContext() {
     debug('clearGlobalContext()');
-    (0, utils_js_1.objectReplace)(globalObject, getInitialGlobalContext(), ['buildEntryPrevious']);
+    (0, utils_js_1.objectReplace)(globalObject, getInitialGlobalObject(), ['buildEntryPrevious']);
 }
-function getInitialGlobalContext() {
-    debug('getInitialGlobalContext()');
+function getInitialGlobalObject() {
+    debug('getInitialGlobalObject()');
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = (0, utils_js_1.genPromise)();
     return {
         viteDevServerPromise,

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

@@ -32,20 +32,41 @@ const passToClientBuiltInPageContext = [
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
 function getPageContextClientSerialized(pageContext) {
     const passToClientPageContext = getPassToClientPageContext(pageContext);
-    const pageContextClient = applyPassToClient(passToClientPageContext, pageContext);
-    if (passToClientPageContext.some((prop) => (0, propKeys_js_1.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) => (0, propKeys_js_1.getPropVal)(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient_js_1.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 && (0, propKeys_js_1.getPropVal)(pageContext, prop)) {
+            (0, utils_js_1.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);
@@ -54,11 +75,15 @@ function serializeObject(obj, objName, passToClient) {
         const h = (s) => picocolors_1.default.cyan(s);
         let hasWarned = false;
         const propsNonSerializable = [];
-        passToClient.forEach((prop) => {
+        passToClient.forEach((entry) => {
+            const entryNormalized = normalizePassToClientEntry(entry);
+            const { prop } = entryNormalized;
             const res = (0, propKeys_js_1.getPropVal)(obj, prop);
             if (!res)
                 return;
             const { value } = res;
+            const { objName } = getObj(entryNormalized) ?? {};
+            (0, utils_js_1.assert)(objName);
             const varName = `${objName}${(0, propKeys_js_1.getPropKeys)(prop).map(utils_js_1.getPropAccessNotation).join('')}`;
             try {
                 serializeValue(value, varName);
@@ -168,16 +193,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 = (0, propKeys_js_1.getPropVal)(pageContext, prop);
+        const res = (0, propKeys_js_1.getPropVal)(obj, prop);
         if (!res)
             return;
         const { value } = res;
         // Set value to pageContextClient
-        (0, propKeys_js_1.setPropVal)(pageContextClient, prop, value);
+        (0, propKeys_js_1.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/cjs/node/runtime/renderPage/createHttpResponse/getCacheControl.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheControlDisable = void 0;
 exports.getCacheControl = getCacheControl;
 const helpers_js_1 = require("../../../../shared/page-configs/helpers.js");
 const getConfigValueRuntime_js_1 = require("../../../../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';
+exports.cacheControlDisable = cacheControlDisable;
+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 = (0, helpers_js_1.getPageConfig)(pageId, pageConfigs);
         const configValue = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'cacheControl', 'string');
@@ -20,5 +20,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/cjs/node/runtime/renderPage/createHttpResponse.js

@@ -11,8 +11,8 @@ const utils_js_1 = require("../utils.js");
 const error_page_js_1 = require("../../../shared/error-page.js");
 const getHttpResponseBody_js_1 = require("./getHttpResponseBody.js");
 const getEarlyHints_js_1 = require("./getEarlyHints.js");
-const getCacheControl_js_1 = require("./createHttpResponse/getCacheControl.js");
 const assertNoInfiniteHttpRedirect_js_1 = require("./createHttpResponse/assertNoInfiniteHttpRedirect.js");
+const getCacheControl_js_1 = require("./createHttpResponse/getCacheControl.js");
 async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
@@ -31,10 +31,13 @@ async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     }
     const earlyHints = (0, getEarlyHints_js_1.getEarlyHints)(await pageContext.__getPageAssets());
     const headers = [];
-    const cacheControl = (0, getCacheControl_js_1.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', getCacheControl_js_1.cacheControlDisable);
     return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
 }
 function createHttpResponse404(errMsg404) {

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

@@ -11,12 +11,15 @@ const findPageConfig_js_1 = require("../../../shared/page-configs/findPageConfig
 const analyzePage_js_1 = require("./analyzePage.js");
 const loadConfigValues_js_1 = require("../../../shared/page-configs/loadConfigValues.js");
 const execHookServer_js_1 = require("./execHookServer.js");
+const getCacheControl_js_1 = require("./createHttpResponse/getCacheControl.js");
+// TODO/now: rename?
 async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
     const pageContextAddendum = await loadPageConfigsLazyServerSide(pageContext);
     (0, utils_js_1.objectAssign)(pageContext, pageContextAddendum);
     await (0, execHookServer_js_1.execHookServer)('onCreatePageContext', pageContext);
     return pageContext;
 }
+// TODO/now: rename?
 async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
@@ -38,8 +41,9 @@ async function loadPageConfigsLazyServerSide(pageContext) {
     }
     else {
         configPublicPageLazy.from.configsCumulative.passToClient?.values.forEach((v) => {
-            const { value, definedAt } = v;
-            (0, utils_js_1.assertUsage)((0, utils_js_1.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);
         });
     }
@@ -50,6 +54,7 @@ async function loadPageConfigsLazyServerSide(pageContext) {
         _isHtmlOnly: isHtmlOnly,
         _passToClient: passToClient,
         _pageFilePathsLoaded: pageFilesLoaded.map((p) => p.filePath),
+        headersResponse: resolveHeadersResponse(pageContext, pageContextAddendum),
     });
     (0, utils_js_1.objectAssign)(pageContextAddendum, {
         __getPageAssets: async () => {
@@ -102,6 +107,7 @@ async function loadPageConfigsLazyServerSide(pageContext) {
     });
     return pageContextAddendum;
 }
+// TODO/now: rename?
 async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {
     const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, isDev);
@@ -112,3 +118,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 = (0, getCacheControl_js_1.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/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -19,6 +19,7 @@ const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContex
 const execHookGuard_js_1 = require("../../../shared/route/execHookGuard.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isServerSideError_js_1 = require("../../../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/cjs/node/runtime/renderPage.js

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

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

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

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

@@ -36,12 +36,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/cjs/shared/createGlobalContextShared.js

@@ -10,10 +10,26 @@ const prepareGlobalContextForPublicUsage_js_1 = require("./prepareGlobalContextF
 const getHook_js_1 = require("./hooks/getHook.js");
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 exports.getGlobalContextSyncErrMsg = getGlobalContextSyncErrMsg;
-async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
+async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContextAsync, addGlobalContextSync) {
     const globalContext = createGlobalContextBase(virtualFileExports);
-    const globalContextAddendum = await addGlobalContext?.(globalContext);
-    (0, utils_js_1.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);
+        (0, utils_js_1.objectAssign)(globalContext, globalContextAddendum);
+    }
+    else {
+        const globalContextAddendum = await addGlobalContextAsync?.(globalContext);
+        (0, utils_js_1.objectAssign)(globalContext, globalContextAddendum);
+    }
     const onCreateGlobalContextHooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
     let hooksCalled = false;
     if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {
@@ -21,10 +37,7 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
         await (0, execHook_js_1.execHookGlobal)('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage_js_1.prepareGlobalContextForPublicUsage);
         hooksCalled = true;
     }
-    if (!globalObject.globalContext) {
-        globalObject.globalContext = globalContext;
-    }
-    else {
+    if (isNewGlobalContext) {
         // Singleton: ensure all `globalContext` user-land references are preserved & updated.
         if (hooksCalled) {
             (0, utils_js_1.objectReplace)(globalObject.globalContext, globalContext);

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadPageRoutes = loadPageRoutes;
+exports.loadPageRoutesSync = loadPageRoutesSync;
 const error_page_js_1 = require("../error-page.js");
 const utils_js_1 = require("./utils.js");
 const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFromFilesystemPath.js");
@@ -12,8 +13,13 @@ const getHook_js_1 = require("../hooks/getHook.js");
 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/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.235-commit-8f42b16';
+exports.PROJECT_VERSION = '0.4.235-commit-d2ac38a';

package/dist/esm/client/runtime-client-routing/getPageContextFromHooks.d.ts

@@ -85,6 +85,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
         urlOriginal: string;
         headers: Record<string, string> | null;
         headersOriginal?: unknown;
+        headersResponse: Headers;
         is404: boolean | null;
         isClientSideNavigation: boolean;
         abortReason?: unknown;
@@ -109,6 +110,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
         urlOriginal: string;
         headers: Record<string, string> | null;
         headersOriginal?: unknown;
+        headersResponse: Headers;
         is404: boolean | null;
         isClientSideNavigation: boolean;
         abortReason?: unknown;
@@ -156,6 +158,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     urlOriginal: string;
     headers: Record<string, string> | null;
     headersOriginal?: unknown;
+    headersResponse: Headers;
     is404: boolean | null;
     isClientSideNavigation: boolean;
     abortReason?: unknown;
@@ -180,6 +183,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     urlOriginal: string;
     headers: Record<string, string> | null;
     headersOriginal?: unknown;
+    headersResponse: Headers;
     is404: boolean | null;
     isClientSideNavigation: boolean;
     abortReason?: unknown;
@@ -295,6 +299,7 @@ declare function getPageContextFromClientHooks(pageContext: {
         urlOriginal: string;
         headers: Record<string, string> | null;
         headersOriginal?: unknown;
+        headersResponse: Headers;
         is404: boolean | null;
         isClientSideNavigation: boolean;
         abortReason?: unknown;
@@ -319,6 +324,7 @@ declare function getPageContextFromClientHooks(pageContext: {
         urlOriginal: string;
         headers: Record<string, string> | null;
         headersOriginal?: unknown;
+        headersResponse: Headers;
         is404: boolean | null;
         isClientSideNavigation: boolean;
         abortReason?: unknown;
@@ -364,6 +370,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     urlOriginal: string;
     headers: Record<string, string> | null;
     headersOriginal?: unknown;
+    headersResponse: Headers;
     is404: boolean | null;
     isClientSideNavigation: boolean;
     abortReason?: unknown;
@@ -388,6 +395,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     urlOriginal: string;
     headers: Record<string, string> | null;
     headersOriginal?: unknown;
+    headersResponse: Headers;
     is404: boolean | null;
     isClientSideNavigation: boolean;
     abortReason?: unknown;

package/dist/esm/client/runtime-client-routing/renderPageClientSide.d.ts

@@ -95,6 +95,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
         urlOriginal: string;
         headers: Record<string, string> | null;
         headersOriginal?: unknown;
+        headersResponse: Headers;
         is404: boolean | null;
         isClientSideNavigation: boolean;
         abortReason?: unknown;
@@ -119,6 +120,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
         urlOriginal: string;
         headers: Record<string, string> | null;
         headersOriginal?: unknown;
+        headersResponse: Headers;
         is404: boolean | null;
         isClientSideNavigation: boolean;
         abortReason?: unknown;

package/dist/esm/client/shared/createGetGlobalContextClient.d.ts

@@ -23,14 +23,14 @@ declare function createGetGlobalContextClient<GlobalContextAddendum extends obje
     pages: {
         [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
-} & Awaited<{
+} & {
     /**
      * Whether the environment is client-side or server-side / pre-rendering.
      *
      * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
      */
     isClientSide: true;
-} & Awaited<GlobalContextAddendum>>>;
+} & Awaited<GlobalContextAddendum>>;
 type NeverExported = never;
 declare function getGlobalContext(): Promise<NeverExported>;
 declare function getGlobalContextSync(): NeverExported;

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -559,8 +559,9 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
 })) & import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy) & {
     Page: unknown;
     _isHtmlOnly: boolean;
-    _passToClient: string[];
+    _passToClient: import("../runtime/html/serializeContext.js").PassToClient;
     _pageFilePathsLoaded: string[];
+    headersResponse: Headers;
 } & {
     __getPageAssets: () => Promise<import("../runtime/renderPage/getPageAssets.js").PageAsset[]>;
 })) & {

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

@@ -21,8 +21,10 @@ export type { GlobalContextServerInternal as GlobalContextServerInternal };
 export type { GlobalContextServer };
 import type { ViteManifest } from '../../types/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
+import { type PageRoutes } from '../../shared/route/loadPageRoutes.js';
 import type { ViteConfigRuntime } from '../vite/shared/getViteConfigRuntime.js';
 import type { GlobalContext } from '../../types/PageContext.js';
+import type { Hook } from '../../shared/hooks/getHook.js';
 declare const vikeConfigErrorRecoverMsg: "Vike config loaded";
 type GlobalContextServer = Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextServer;
 type GlobalContextServerInternal = Awaited<ReturnType<typeof setGlobalContext>>;
@@ -64,8 +66,8 @@ declare function getGlobalContextServerInternal(): Promise<{
         baseServer: string;
         baseAssets: string;
         isClientSide: false;
-        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _pageRoutes: PageRoutes;
+        _onBeforeRouteHook: Hook | null;
     }) | (Record<string, unknown> & {
         isGlobalContext: true;
         _isOriginalObject: true;
@@ -104,8 +106,8 @@ declare function getGlobalContextServerInternal(): Promise<{
         baseServer: string;
         baseAssets: string;
         isClientSide: false;
-        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _pageRoutes: PageRoutes;
+        _onBeforeRouteHook: Hook | null;
     }) | (Record<string, unknown> & {
         isGlobalContext: true;
         _isOriginalObject: true;
@@ -144,8 +146,8 @@ declare function getGlobalContextServerInternal(): Promise<{
         baseServer: string;
         baseAssets: string;
         isClientSide: false;
-        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _pageRoutes: PageRoutes;
+        _onBeforeRouteHook: Hook | null;
     });
 }>;
 /**
@@ -222,8 +224,8 @@ declare function setGlobalContext(virtualFileExports: unknown): Promise<{
     baseServer: string;
     baseAssets: string;
     isClientSide: false;
-    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _pageRoutes: PageRoutes;
+    _onBeforeRouteHook: Hook | null;
 } | {
     _isPrerendering: true;
     viteConfig: ResolvedConfig;
@@ -244,8 +246,8 @@ declare function setGlobalContext(virtualFileExports: unknown): Promise<{
     baseServer: string;
     baseAssets: string;
     isClientSide: false;
-    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _pageRoutes: PageRoutes;
+    _onBeforeRouteHook: Hook | null;
 } | {
     _isPrerendering: false;
     viteConfig: null;
@@ -266,7 +268,7 @@ declare function setGlobalContext(virtualFileExports: unknown): Promise<{
     baseServer: string;
     baseAssets: string;
     isClientSide: false;
-    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _pageRoutes: PageRoutes;
+    _onBeforeRouteHook: Hook | null;
 })>;
 declare function clearGlobalContext(): void;