vike 0.4.228-commit-d423e4f → 0.4.228-commit-ae4784f

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

@@ -1,12 +1,13 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
-import { getPageContextInitEnhanced, renderPageAlreadyRouted, createPageContext } from './renderPage/renderPageAlreadyRouted.js';
+import { renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
+import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext } from './renderPage/createPageContextServerSide.js';
 import { route } from '../../shared/route/index.js';
 import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContextInternal, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
-import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseBaseIsMissing } from './renderPage/createHttpResponse.js';
+import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseErrorWithoutGlobalContext, createHttpResponseBaseIsMissing } from './renderPage/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
 import { isNewError } from './renderPage/isNewError.js';
 import { assertArguments } from './renderPage/assertArguments.js';
@@ -27,13 +28,13 @@ async function renderPage(pageContextInit) {
     assert(hasProp(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
     assertIsUrl(pageContextInit.urlOriginal);
     onSetupRuntime();
-    const pageContextInvalidRequest = renderInvalidRequest(pageContextInit);
+    const pageContextInvalidRequest = getPageContextInvalidRequest(pageContextInit);
     if (pageContextInvalidRequest)
         return pageContextInvalidRequest;
     const httpRequestId = getRequestId();
     const urlOriginalPretty = getUrlPretty(pageContextInit.urlOriginal);
     logHttpRequest(urlOriginalPretty, httpRequestId);
-    const { pageContextReturn } = await asyncHookWrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
+    const { pageContextReturn } = await asyncHookWrapper(httpRequestId, () => renderPagePrepare(pageContextInit, httpRequestId));
     logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn);
     checkType(pageContextReturn);
     assert(pageContextReturn.httpResponse);
@@ -47,13 +48,12 @@ let asyncHookWrapper = async (_httpRequestId, ret) => ({
 function renderPage_addAsyncHookwrapper(wrapper) {
     asyncHookWrapper = wrapper;
 }
-async function renderPageAndPrepare(pageContextInit, httpRequestId) {
+async function renderPagePrepare(pageContextInit, httpRequestId) {
     // Invalid config
-    if (isVikeConfigInvalid) {
-        if (1 < 2 // Make TS happy
-        ) {
-            return renderInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
-        }
+    if (isVikeConfigInvalid &&
+        true // Make TS happy
+    ) {
+        return getPageContextInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     // Prepare context
     try {
@@ -67,49 +67,52 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext_renderPage() doens't call any user hook => err isn't thrown from user code.
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
-        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
+        const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
         return pageContextWithError;
     }
     if (isVikeConfigInvalid) {
-        return renderInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
+        return getPageContextInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     else {
         // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
     }
     const globalContext = await getGlobalContextInternal();
+    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, httpRequestId);
     // Check Base URL
     {
-        const pageContextHttpResponse = await checkBaseUrl(pageContextInit, globalContext);
+        const pageContextHttpResponse = await checkBaseUrl(pageContextBegin, globalContext);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
     // Normalize URL
     {
-        const pageContextHttpResponse = await normalizeUrl(pageContextInit, globalContext, httpRequestId);
+        const pageContextHttpResponse = await normalizeUrl(pageContextBegin, globalContext, httpRequestId);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
     // Permanent redirects (HTTP status code `301`)
     {
-        const pageContextHttpResponse = await getPermanentRedirect(pageContextInit, globalContext, httpRequestId);
+        const pageContextHttpResponse = await getPermanentRedirect(pageContextBegin, globalContext, httpRequestId);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
-    return await renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, []);
+    return await renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRequestId, []);
 }
-async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, pageContextsFromRewrite) {
+async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
+    const pageContextNominalPageBegin = forkPageContext(pageContextBegin);
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, 
     // There doesn't seem to be a way to count the number of HTTP redirects (vike don't have access to the HTTP request headers/cookies)
     // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
     0);
     let pageContextNominalPageSuccess;
     const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
-    const pageContextNominalPageInit = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextFromAllRewrites._urlRewrite, httpRequestId);
-    objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites);
+    // This is where pageContext._urlRewrite is set
+    assert(pageContextFromAllRewrites._urlRewrite === null || typeof pageContextFromAllRewrites._urlRewrite === 'string');
+    objectAssign(pageContextNominalPageBegin, pageContextFromAllRewrites);
     let errNominalPage;
     {
         try {
-            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageInit);
+            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageBegin);
         }
         catch (err) {
             errNominalPage = err;
@@ -117,7 +120,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             logRuntimeError(errNominalPage, httpRequestId);
         }
         if (!errNominalPage) {
-            assert(pageContextNominalPageSuccess === pageContextNominalPageInit);
+            assert(pageContextNominalPageSuccess === pageContextNominalPageBegin);
         }
     }
     // Log upon 404
@@ -133,12 +136,12 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
     else {
         assert(errNominalPage);
         assert(pageContextNominalPageSuccess === undefined);
-        assert(pageContextNominalPageInit);
-        assert(hasProp(pageContextNominalPageInit, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPageInit, httpRequestId);
+        assert(pageContextNominalPageBegin);
+        assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
         // Handle `throw redirect()` and `throw render()` while rendering nominal page
         if (isAbortError(errNominalPage)) {
-            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext);
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
             if (handled.pageContextReturn) {
                 // - throw redirect()
                 // - throw render(url)
@@ -167,12 +170,12 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
         catch (errErrorPage) {
             // Handle `throw redirect()` and `throw render()` while rendering error page
             if (isAbortError(errErrorPage)) {
-                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext);
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
                 // throw render(abortStatusCode)
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
                     assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
+                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
                     return pageContextHttpWithError;
                 }
                 // `throw redirect()` / `throw render(url)`
@@ -181,7 +184,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             if (isNewError(errErrorPage, errNominalPage)) {
                 logRuntimeError(errErrorPage, httpRequestId);
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
             return pageContextWithError;
         }
         return pageContextErrorPage;
@@ -233,11 +236,26 @@ function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
     logRuntimeInfo?.(msg, httpRequestId, isNominal ? 'info' : 'error');
 }
 function prettyUrl(url) {
-    return pc.bold(decodeURI(url));
+    try {
+        url = decodeURI(url);
+    }
+    catch {
+        // https://github.com/vikejs/vike/pull/2367#issuecomment-2800967564
+    }
+    return pc.bold(url);
 }
-function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
-    const pageContextWithError = createPageContext(pageContextInit, false);
-    const httpResponse = createHttpResponseError(pageContext);
+function getPageContextHttpResponseError(err, pageContextBegin) {
+    const pageContextWithError = forkPageContext(pageContextBegin);
+    const httpResponse = createHttpResponseError(pageContextBegin);
+    objectAssign(pageContextWithError, {
+        httpResponse,
+        errorWhileRendering: err
+    });
+    return pageContextWithError;
+}
+function getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit) {
+    const pageContextWithError = createPageContextServerSideWithoutGlobalContext(pageContextInit);
+    const httpResponse = createHttpResponseErrorWithoutGlobalContext();
     objectAssign(pageContextWithError, {
         httpResponse,
         errorWhileRendering: err
@@ -267,8 +285,8 @@ async function renderPageNominal(pageContext) {
     assert(pageContext === pageContextAfterRender);
     return pageContextAfterRender;
 }
-async function getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
-    const pageContext = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
+async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPagePartial) {
+    const pageContext = forkPageContext(pageContextBegin);
     assert(errNominalPage);
     objectAssign(pageContext, {
         is404: false,
@@ -281,17 +299,17 @@ async function getPageContextErrorPageInit(pageContextInit, globalContext, errNo
     assert(pageContext.errorWhileRendering);
     return pageContext;
 }
-async function getPageContextInitEnhancedSSR(pageContextInit, globalContext, urlRewrite, httpRequestId) {
+async function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext, false, {
+    const pageContextBegin = await createPageContextServerSide(pageContextInit, globalContext, {
+        isPrerendering: false,
         ssr: {
-            urlRewrite,
             urlHandler: _urlHandler,
             isClientSideNavigation
         }
     });
-    objectAssign(pageContextInitEnhanced, { _httpRequestId: httpRequestId });
-    return pageContextInitEnhanced;
+    objectAssign(pageContextBegin, { _httpRequestId: httpRequestId });
+    return pageContextBegin;
 }
 function handlePageContextUrl(urlOriginal) {
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
@@ -314,11 +332,12 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
         return;
     assertUsage(false, `${pc.code('renderPage(pageContextInit)')} called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${pc.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${pc.cyan('createDevMiddleware()')} middleware is executed *before* the ${pc.cyan('renderPage()')} middleware, see ${pc.underline('https://vike.dev/renderPage')}`);
 }
-async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
+async function normalizeUrl(pageContextBegin, globalContext, httpRequestId) {
+    const pageContext = forkPageContext(pageContextBegin);
     const { trailingSlash, disableUrlNormalization } = globalContext.config;
     if (disableUrlNormalization)
         return null;
-    const { urlOriginal } = pageContextInit;
+    const { urlOriginal } = pageContext;
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
     if (isPageContextRequest)
         return null;
@@ -326,13 +345,13 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = createPageContext(pageContextInit, false);
-    objectAssign(pageContextHttpResponse, { httpResponse });
-    return pageContextHttpResponse;
+    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContext);
+    objectAssign(pageContext, { httpResponse });
+    return pageContext;
 }
-async function getPermanentRedirect(pageContextInit, globalContext, httpRequestId) {
-    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, globalContext.baseServer);
+async function getPermanentRedirect(pageContextBegin, globalContext, httpRequestId) {
+    const pageContext = forkPageContext(pageContextBegin);
+    const urlWithoutBase = removeBaseServer(pageContext.urlOriginal, globalContext.baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
@@ -365,32 +384,29 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
             return null;
         if (!originChanged)
             urlTarget = prependBase(urlTarget, globalContext.baseServer);
-        assert(urlTarget !== pageContextInit.urlOriginal);
+        assert(urlTarget !== pageContext.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = createPageContext(pageContextInit, false);
-    objectAssign(pageContextHttpResponse, { httpResponse });
-    return pageContextHttpResponse;
+    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, pageContext);
+    objectAssign(pageContext, { httpResponse });
+    return pageContext;
 }
 function normalize(url) {
     return url || '/';
 }
-async function handleAbortError(errAbort, pageContextsFromRewrite, 
-// The original `pageContextInit` object passed to `renderPage(pageContextInit)`
-pageContextInit, 
-// handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
-pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext) {
-    logAbortErrorHandled(errAbort, globalContext.isProduction, pageContextNominalPageInit);
+async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextBegin, 
+// handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageBegin to it: we only use some pageContextNominalPageBegin information.
+pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext) {
+    logAbortErrorHandled(errAbort, globalContext.isProduction, pageContextNominalPageBegin);
     const pageContextAbort = errAbort._pageContextAbort;
     let pageContextSerialized;
-    if (pageContextNominalPageInit.isClientSideNavigation) {
+    if (pageContextNominalPageBegin.isClientSideNavigation) {
         if (pageContextAbort.abortStatusCode) {
             const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
             const abortCall = pageContextAbort._abortCall;
             assert(abortCall);
             assertUsage(errorPageId, `You called ${pc.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
-            const pageContext = createPageContext({}, false);
+            const pageContext = forkPageContext(pageContextBegin);
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
@@ -406,7 +422,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRewrite) {
-        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, [
+        const pageContextReturn = await renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRequestId, [
             ...pageContextsFromRewrite,
             pageContextAbort
         ]);
@@ -414,22 +430,22 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = createPageContext(pageContextInit, false);
+        const pageContextReturn = forkPageContext(pageContextBegin);
         objectAssign(pageContextReturn, pageContextAbort);
-        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, pageContextInit);
+        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, pageContextBegin);
         objectAssign(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }
     assert(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
-async function checkBaseUrl(pageContextInit, globalContext) {
+async function checkBaseUrl(pageContextBegin, globalContext) {
+    const pageContext = forkPageContext(pageContextBegin);
     const { baseServer } = globalContext;
-    const { urlOriginal } = pageContextInit;
+    const { urlOriginal } = pageContext;
     const { isBaseMissing } = parseUrl(urlOriginal, baseServer);
     if (!isBaseMissing)
         return;
-    const pageContext = createPageContext(pageContextInit, false);
     const httpResponse = createHttpResponseBaseIsMissing(urlOriginal, baseServer);
     objectAssign(pageContext, {
         httpResponse,
@@ -438,20 +454,25 @@ async function checkBaseUrl(pageContextInit, globalContext) {
     checkType(pageContext);
     return pageContext;
 }
-function renderInvalidRequest(pageContextInit) {
+function getPageContextInvalidRequest(pageContextInit) {
     const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
-    if (urlPathnameWithBase.endsWith('/favicon.ico')) {
-        const pageContext = createPageContext(pageContextInit, false);
-        const httpResponse = createHttpResponseFavicon404();
-        objectAssign(pageContext, { httpResponse });
-        checkType(pageContext);
-        return pageContext;
-    }
-    return null;
+    if (!urlPathnameWithBase.endsWith('/favicon.ico'))
+        return;
+    const pageContext = createPageContextServerSideWithoutGlobalContext(pageContextInit);
+    const httpResponse = createHttpResponseFavicon404();
+    objectAssign(pageContext, { httpResponse });
+    checkType(pageContext);
+    return pageContext;
 }
-function renderInvalidVikeConfig(err, pageContextInit, httpRequestId) {
+function getPageContextInvalidVikeConfig(err, pageContextInit, httpRequestId) {
     logRuntimeInfo?.(pc.bold(pc.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
-    const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
+    const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
     return pageContextWithError;
 }
+// Create pageContext forks to avoid leaks: upon an error (bug or abort) a brand new pageContext object is created, in order to avoid previous pageContext modifications that are now obsolete to leak to the new pageContext object.
+function forkPageContext(pageContextBegin) {
+    const pageContext = {};
+    objectAssign(pageContext, pageContextBegin, true);
+    return pageContext;
+}

package/dist/esm/shared/hooks/getHook.d.ts

@@ -1,6 +1,7 @@
-export { getHook };
+export { getHookFromPageContext };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
+export { getHookFromPageConfigGlobalCumulative };
 export { assertHook };
 export { getHook_setIsPrerenderering };
 export type { Hook };
@@ -26,9 +27,10 @@ type HookTimeout = {
     warning: number | false;
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
-declare function getHook(pageContext: PageConfigUserFriendlyOld, hookName: HookName): null | Hook;
+declare function getHookFromPageContext(pageContext: PageConfigUserFriendlyOld, hookName: HookName): null | Hook;
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
+declare function getHookFromPageConfigGlobalCumulative(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook[];
 declare function assertHook<TPageContext extends PageConfigUserFriendlyOld, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
     exports: Record<THookName, Function | undefined>;
 };

package/dist/esm/shared/hooks/getHook.js

@@ -1,70 +1,88 @@
-export { getHook };
+export { getHookFromPageContext };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
+export { getHookFromPageConfigGlobalCumulative };
 export { assertHook };
 export { getHook_setIsPrerenderering };
 // TODO/v1-release: remove
-// We export for old V0.4 design which doesn't support configooksTimeout
+// We export for old V0.4 design which doesn't support config.hooksTimeout
 export { getHookTimeoutDefault };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
-import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
+import { assert, assertUsage, checkType, isArray, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('hooks/getHook.ts', {});
-function getHook(pageContext, hookName) {
+function getHookFromPageContext(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;
     }
     const { hooksTimeout } = pageContext.config;
     const hookTimeout = getHookTimeout(hooksTimeout, hookName);
     const hookFn = pageContext.exports[hookName];
-    const file = pageContext.exportsAll[hookName][0];
-    assert(file.exportValue === hookFn);
     if (hookFn === null)
         return null;
+    const file = pageContext.exportsAll[hookName][0];
+    assert(file.exportValue === hookFn);
     const hookFilePath = file.filePath;
     assert(hookFilePath);
-    assert(!hookFilePath.endsWith(' '));
-    assertHookFn(hookFn, { hookName, hookFilePath });
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
 function getHookFromPageConfig(pageConfig, hookName) {
     const configValue = getConfigValueRuntime(pageConfig, hookName);
-    const hooksTimeout = getConfigValueRuntime(pageConfig, 'hooksTimeout')?.value;
-    if (!configValue)
+    if (!configValue?.value)
         return null;
-    const hookFn = configValue.value;
-    if (!hookFn)
-        return null;
-    const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
-    // hook isn't a computed nor a cumulative config => hookFilePath should always be defined
-    assert(hookFilePath);
-    assertHookFn(hookFn, { hookName, hookFilePath });
+    const { hookFn, hookFilePath } = getHookFromConfigValue(configValue);
+    const hooksTimeout = getConfigValueRuntime(pageConfig, 'hooksTimeout')?.value;
     const hookTimeout = getHookTimeout(hooksTimeout, hookName);
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
 function getHookFromPageConfigGlobal(pageConfigGlobal, hookName) {
     const configValue = pageConfigGlobal.configValues[hookName];
-    if (!configValue)
-        return null;
-    const hookFn = configValue.value;
-    if (!hookFn)
+    if (!configValue?.value)
         return null;
-    const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
-    // hook isn't a computed nor a cumulative config => hookFilePath should always be defined
+    const { hookFn, hookFilePath } = getHookFromConfigValue(configValue);
+    const hookTimeout = getHookTimeoutGlobal(hookName);
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
+}
+function getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName) {
+    const configValue = pageConfigGlobal.configValues[hookName];
+    if (!configValue?.value)
+        return [];
+    const val = configValue.value;
+    assert(isArray(val));
+    return val.map((v, i) => {
+        const hookFn = v;
+        const hookTimeout = getHookTimeoutGlobal(hookName);
+        assert(isArray(configValue.definedAtData));
+        const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData[i]);
+        return getHook(hookFn, hookName, hookFilePath, hookTimeout);
+    });
+}
+function getHookTimeoutGlobal(hookName) {
+    // TO-DO/perfection: we could use the global value of configooksTimeout but it requires some non-trivial refactoring
+    const hookTimeout = getHookTimeoutDefault(hookName);
+    return hookTimeout;
+}
+function getHook(hookFn, hookName, hookFilePath, hookTimeout) {
     assert(hookFilePath);
     assertHookFn(hookFn, { hookName, hookFilePath });
-    // We could use the global value of configooksTimeout but it requires some non-trivial refactoring
-    const hookTimeout = getHookTimeoutDefault(hookName);
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    const hook = { hookFn, hookName, hookFilePath, hookTimeout };
+    return hook;
+}
+function getHookFromConfigValue(configValue) {
+    const hookFn = configValue.value;
+    assert(hookFn);
+    const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
+    return { hookFn, hookFilePath };
 }
 function assertHook(pageContext, hookName) {
-    getHook(pageContext, hookName);
+    getHookFromPageContext(pageContext, hookName);
 }
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     assert(hookName && hookFilePath);
     assert(!hookName.endsWith(')'));
+    assert(!hookFilePath.endsWith(' '));
     assertUsage(isCallable(hookFn), `Hook ${hookName}() defined by ${hookFilePath} should be a function`);
     checkType(hookFn);
 }

package/dist/esm/shared/page-configs/Config.d.ts

@@ -45,7 +45,7 @@ import type { PageContextClient, PageContextServer } from '../types.js';
 import type { InlineConfig } from 'vite';
 type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
-type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
+type HookNameGlobal = 'onCreatePageContext' | 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
 type HookNameOldDesign = 'render' | 'prerender';
 type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
@@ -330,6 +330,11 @@ type ConfigBuiltIn = {
      *  https://vike.dev/onBeforeRender
      */
     onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportString | null;
+    /** Hook called when a page starts rendering.
+     *
+     *  https://vike.dev/onCreatePageContext TODO/now
+     */
+    onCreatePageContext?: (pageContext: PageContextServer) => void | ImportString | null;
     /** Hook for fetching data.
      *
      *  https://vike.dev/data

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

@@ -1,5 +1,5 @@
 export { executeGuardHook };
-import { getHook, getHookTimeoutDefault } from '../hooks/getHook.js';
+import { getHookFromPageContext, getHookTimeoutDefault } from '../hooks/getHook.js';
 import { assert, assertUsage, isCallable } from './utils.js';
 import { executeHook } from '../hooks/executeHook.js';
 const errIntro = 'The guard() hook defined by';
@@ -12,7 +12,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     }
     else {
         // V1 design
-        hook = getHook(pageContext, 'guard');
+        hook = getHookFromPageContext(pageContext, 'guard');
     }
     if (!hook)
         return;

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

@@ -45,6 +45,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         assert(isCallable(route));
+                        // TODO/next-major: remove
                         if (getConfigValueRuntime(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             warnDeprecatedAllowKey();
                         pageRoute = {

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

@@ -13,6 +13,7 @@ import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';
 import type { GlobalContextPublic } from '../node/runtime/globalContext.js';
+import type { GlobalContextPublicClientSide } from '../client/client-routing-runtime/globalContextClientSide.js';
 type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & Vike.PageContext;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
 type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & Vike.PageContext;
@@ -119,12 +120,6 @@ type PageContextBuiltInCommon<Data> = {
     source: Source;
     /** @experimental https://github.com/vikejs/vike/issues/1268 */
     sources: Sources;
-    /**
-     * Runtime information about your app.
-     *
-     * https://vike.dev/getGlobalContext
-     */
-    globalContext: GlobalContextPublic;
     /** @deprecated */
     url: string;
     /** @deprecated */
@@ -152,6 +147,12 @@ type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageConte
      * https://vike.dev/pageContext
      */
     isPrerendering: boolean;
+    /**
+     * Runtime information about your app.
+     *
+     * https://vike.dev/getGlobalContext
+     */
+    globalContext: GlobalContextPublic;
     isHydration?: undefined;
     isBackwardNavigation?: undefined;
     previousPageContext?: undefined;
@@ -202,6 +203,7 @@ type PageContextClientCommon = {
      * https://vike.dev/pageContext
      */
     isPrerendering: false;
+    globalContext: GlobalContextPublicClientSide;
 };
 /** For Vike internal use */
 type PageContextBuiltInServerInternal = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data'>;

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.228-commit-d423e4f";
+export declare const PROJECT_VERSION: "0.4.228-commit-ae4784f";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.228-commit-d423e4f';
+export const PROJECT_VERSION = '0.4.228-commit-ae4784f';

package/dist/esm/utils/objectAssign.js

@@ -2,15 +2,11 @@ export { objectAssign };
 import { assert } from './assert.js';
 // Same as Object.assign() but:
 //  - With type inference
-//  - Preserves property descriptors, which we need for preserving the getters added by getPageContextUrlComputed()
+//  - Preserves property descriptors, which we need for preserving the getters of getPageContextUrlComputed()
 function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
     if (objAddendum) {
-        if (!objAddendumCanBePageContextObject) {
-            // We only need this assert() in the rare case when the user is expected to mutate `pageContext` after the Vike hook was executed (and its promise resolved).
-            // - The only use case I can think of is the user mutating `pageContext` after the onRenderClient() promise resolved (which can happen when client-side rendering finishes after onRenderClient() resolves). In that case, having Vike await async Vike hooks isn't enough.
-            // - IIRC this assert() was mostly needed for preserving the getters added by getPageContextUrlComputed() but we don't need this anymore.
+        if (!objAddendumCanBePageContextObject)
             assert(!('_isPageContextObject' in objAddendum));
-        }
         Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
     }
 }