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

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderPage = renderPage;
 exports.renderPage_addAsyncHookwrapper = renderPage_addAsyncHookwrapper;
 const renderPageAlreadyRouted_js_1 = require("./renderPage/renderPageAlreadyRouted.js");
+const createPageContextServerSide_js_1 = require("./renderPage/createPageContextServerSide.js");
 const index_js_1 = require("../../shared/route/index.js");
 const utils_js_1 = require("./utils.js");
 const abort_js_1 = require("../../shared/route/abort.js");
@@ -32,13 +33,13 @@ async function renderPage(pageContextInit) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
     assertIsUrl(pageContextInit.urlOriginal);
     (0, utils_js_1.onSetupRuntime)();
-    const pageContextInvalidRequest = renderInvalidRequest(pageContextInit);
+    const pageContextInvalidRequest = getPageContextInvalidRequest(pageContextInit);
     if (pageContextInvalidRequest)
         return pageContextInvalidRequest;
     const httpRequestId = getRequestId();
     const urlOriginalPretty = (0, utils_js_1.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);
     (0, utils_js_1.checkType)(pageContextReturn);
     (0, utils_js_1.assert)(pageContextReturn.httpResponse);
@@ -52,13 +53,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_js_1.isVikeConfigInvalid) {
-        if (1 < 2 // Make TS happy
-        ) {
-            return renderInvalidVikeConfig(isVikeConfigInvalid_js_1.isVikeConfigInvalid.err, pageContextInit, httpRequestId);
-        }
+    if (isVikeConfigInvalid_js_1.isVikeConfigInvalid &&
+        true // Make TS happy
+    ) {
+        return getPageContextInvalidVikeConfig(isVikeConfigInvalid_js_1.isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     // Prepare context
     try {
@@ -72,49 +72,52 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext_renderPage() doens't call any user hook => err isn't thrown from user code.
         (0, utils_js_1.assert)(!(0, abort_js_1.isAbortError)(err));
         (0, loggerRuntime_js_1.logRuntimeError)(err, httpRequestId);
-        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
+        const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
         return pageContextWithError;
     }
     if (isVikeConfigInvalid_js_1.isVikeConfigInvalid) {
-        return renderInvalidVikeConfig(isVikeConfigInvalid_js_1.isVikeConfigInvalid.err, pageContextInit, httpRequestId);
+        return getPageContextInvalidVikeConfig(isVikeConfigInvalid_js_1.isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     else {
         // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
     }
     const globalContext = await (0, globalContext_js_1.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);
     (0, abort_js_1.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 = (0, abort_js_1.getPageContextFromAllRewrites)(pageContextsFromRewrite);
-    const pageContextNominalPageInit = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextFromAllRewrites._urlRewrite, httpRequestId);
-    (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextFromAllRewrites);
+    // This is where pageContext._urlRewrite is set
+    (0, utils_js_1.assert)(pageContextFromAllRewrites._urlRewrite === null || typeof pageContextFromAllRewrites._urlRewrite === 'string');
+    (0, utils_js_1.objectAssign)(pageContextNominalPageBegin, pageContextFromAllRewrites);
     let errNominalPage;
     {
         try {
-            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageInit);
+            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageBegin);
         }
         catch (err) {
             errNominalPage = err;
@@ -122,7 +125,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             (0, loggerRuntime_js_1.logRuntimeError)(errNominalPage, httpRequestId);
         }
         if (!errNominalPage) {
-            (0, utils_js_1.assert)(pageContextNominalPageSuccess === pageContextNominalPageInit);
+            (0, utils_js_1.assert)(pageContextNominalPageSuccess === pageContextNominalPageBegin);
         }
     }
     // Log upon 404
@@ -138,12 +141,12 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
     else {
         (0, utils_js_1.assert)(errNominalPage);
         (0, utils_js_1.assert)(pageContextNominalPageSuccess === undefined);
-        (0, utils_js_1.assert)(pageContextNominalPageInit);
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageInit, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPageInit, httpRequestId);
+        (0, utils_js_1.assert)(pageContextNominalPageBegin);
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
         // Handle `throw redirect()` and `throw render()` while rendering nominal page
         if ((0, abort_js_1.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)
@@ -172,12 +175,12 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
         catch (errErrorPage) {
             // Handle `throw redirect()` and `throw render()` while rendering error page
             if ((0, abort_js_1.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;
                     (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.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)`
@@ -186,7 +189,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
                 (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
             return pageContextWithError;
         }
         return pageContextErrorPage;
@@ -238,11 +241,26 @@ function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(msg, httpRequestId, isNominal ? 'info' : 'error');
 }
 function prettyUrl(url) {
-    return picocolors_1.default.bold(decodeURI(url));
+    try {
+        url = decodeURI(url);
+    }
+    catch {
+        // https://github.com/vikejs/vike/pull/2367#issuecomment-2800967564
+    }
+    return picocolors_1.default.bold(url);
 }
-function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
-    const pageContextWithError = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
-    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContext);
+function getPageContextHttpResponseError(err, pageContextBegin) {
+    const pageContextWithError = forkPageContext(pageContextBegin);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContextBegin);
+    (0, utils_js_1.objectAssign)(pageContextWithError, {
+        httpResponse,
+        errorWhileRendering: err
+    });
+    return pageContextWithError;
+}
+function getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit) {
+    const pageContextWithError = (0, createPageContextServerSide_js_1.createPageContextServerSideWithoutGlobalContext)(pageContextInit);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseErrorWithoutGlobalContext)();
     (0, utils_js_1.objectAssign)(pageContextWithError, {
         httpResponse,
         errorWhileRendering: err
@@ -272,8 +290,8 @@ async function renderPageNominal(pageContext) {
     (0, utils_js_1.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);
     (0, utils_js_1.assert)(errNominalPage);
     (0, utils_js_1.objectAssign)(pageContext, {
         is404: false,
@@ -286,17 +304,17 @@ async function getPageContextErrorPageInit(pageContextInit, globalContext, errNo
     (0, utils_js_1.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 (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, false, {
+    const pageContextBegin = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, {
+        isPrerendering: false,
         ssr: {
-            urlRewrite,
             urlHandler: _urlHandler,
             isClientSideNavigation
         }
     });
-    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, { _httpRequestId: httpRequestId });
-    return pageContextInitEnhanced;
+    (0, utils_js_1.objectAssign)(pageContextBegin, { _httpRequestId: httpRequestId });
+    return pageContextBegin;
 }
 function handlePageContextUrl(urlOriginal) {
     const { isPageContextRequest } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
@@ -319,11 +337,12 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
         return;
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.code('renderPage(pageContextInit)')} called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${picocolors_1.default.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${picocolors_1.default.cyan('createDevMiddleware()')} middleware is executed *before* the ${picocolors_1.default.cyan('renderPage()')} middleware, see ${picocolors_1.default.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 } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
     if (isPageContextRequest)
         return null;
@@ -331,13 +350,13 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
     if (!urlNormalized)
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`URL normalized from ${picocolors_1.default.cyan(urlOriginal)} to ${picocolors_1.default.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
-    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlNormalized, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
-    (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
-    return pageContextHttpResponse;
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlNormalized, statusCode: 301 }, pageContext);
+    (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
+    return pageContext;
 }
-async function getPermanentRedirect(pageContextInit, globalContext, httpRequestId) {
-    const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, globalContext.baseServer);
+async function getPermanentRedirect(pageContextBegin, globalContext, httpRequestId) {
+    const pageContext = forkPageContext(pageContextBegin);
+    const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContext.urlOriginal, globalContext.baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = (0, utils_js_1.modifyUrlPathname)(urlWithoutBase, (urlPathname) => {
@@ -370,32 +389,29 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
             return null;
         if (!originChanged)
             urlTarget = (0, utils_js_1.prependBase)(urlTarget, globalContext.baseServer);
-        (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
+        (0, utils_js_1.assert)(urlTarget !== pageContext.urlOriginal);
     }
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
-    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlTarget, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
-    (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
-    return pageContextHttpResponse;
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlTarget, statusCode: 301 }, pageContext);
+    (0, utils_js_1.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) {
-    (0, abort_js_1.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) {
+    (0, abort_js_1.logAbortErrorHandled)(errAbort, globalContext.isProduction, pageContextNominalPageBegin);
     const pageContextAbort = errAbort._pageContextAbort;
     let pageContextSerialized;
-    if (pageContextNominalPageInit.isClientSideNavigation) {
+    if (pageContextNominalPageBegin.isClientSideNavigation) {
         if (pageContextAbort.abortStatusCode) {
             const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
             const abortCall = pageContextAbort._abortCall;
             (0, utils_js_1.assert)(abortCall);
             (0, utils_js_1.assertUsage)(errorPageId, `You called ${picocolors_1.default.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
-            const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)({}, false);
+            const pageContext = forkPageContext(pageContextBegin);
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit, true);
@@ -411,7 +427,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
         ]);
@@ -419,22 +435,22 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
+        const pageContextReturn = forkPageContext(pageContextBegin);
         (0, utils_js_1.objectAssign)(pageContextReturn, pageContextAbort);
-        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)(pageContextAbort._urlRedirect, pageContextInit);
+        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)(pageContextAbort._urlRedirect, pageContextBegin);
         (0, utils_js_1.objectAssign)(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }
     (0, utils_js_1.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 } = (0, utils_js_1.parseUrl)(urlOriginal, baseServer);
     if (!isBaseMissing)
         return;
-    const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
     const httpResponse = (0, createHttpResponse_js_1.createHttpResponseBaseIsMissing)(urlOriginal, baseServer);
     (0, utils_js_1.objectAssign)(pageContext, {
         httpResponse,
@@ -443,20 +459,25 @@ async function checkBaseUrl(pageContextInit, globalContext) {
     (0, utils_js_1.checkType)(pageContext);
     return pageContext;
 }
-function renderInvalidRequest(pageContextInit) {
+function getPageContextInvalidRequest(pageContextInit) {
     const urlPathnameWithBase = (0, utils_js_1.parseUrl)(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
-    if (urlPathnameWithBase.endsWith('/favicon.ico')) {
-        const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
-        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseFavicon404)();
-        (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
-        (0, utils_js_1.checkType)(pageContext);
-        return pageContext;
-    }
-    return null;
+    if (!urlPathnameWithBase.endsWith('/favicon.ico'))
+        return;
+    const pageContext = (0, createPageContextServerSide_js_1.createPageContextServerSideWithoutGlobalContext)(pageContextInit);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseFavicon404)();
+    (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
+    (0, utils_js_1.checkType)(pageContext);
+    return pageContext;
 }
-function renderInvalidVikeConfig(err, pageContextInit, httpRequestId) {
+function getPageContextInvalidVikeConfig(err, pageContextInit, httpRequestId) {
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(picocolors_1.default.bold(picocolors_1.default.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 = {};
+    (0, utils_js_1.objectAssign)(pageContext, pageContextBegin, true);
+    return pageContext;
+}

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

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHook = getHook;
+exports.getHookFromPageContext = getHookFromPageContext;
 exports.getHookFromPageConfig = getHookFromPageConfig;
 exports.getHookFromPageConfigGlobal = getHookFromPageConfigGlobal;
+exports.getHookFromPageConfigGlobalCumulative = getHookFromPageConfigGlobalCumulative;
 exports.assertHook = assertHook;
 exports.getHook_setIsPrerenderering = getHook_setIsPrerenderering;
 exports.getHookTimeoutDefault = getHookTimeoutDefault;
@@ -15,59 +16,76 @@ const getConfigValueRuntime_js_1 = require("../page-configs/getConfigValueRuntim
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const globalObject = (0, getGlobalObject_js_1.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];
-    (0, utils_js_1.assert)(file.exportValue === hookFn);
     if (hookFn === null)
         return null;
+    const file = pageContext.exportsAll[hookName][0];
+    (0, utils_js_1.assert)(file.exportValue === hookFn);
     const hookFilePath = file.filePath;
     (0, utils_js_1.assert)(hookFilePath);
-    (0, utils_js_1.assert)(!hookFilePath.endsWith(' '));
-    assertHookFn(hookFn, { hookName, hookFilePath });
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
 function getHookFromPageConfig(pageConfig, hookName) {
     const configValue = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, hookName);
-    const hooksTimeout = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'hooksTimeout')?.value;
-    if (!configValue)
+    if (!configValue?.value)
         return null;
-    const hookFn = configValue.value;
-    if (!hookFn)
-        return null;
-    const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue.definedAtData);
-    // hook isn't a computed nor a cumulative config => hookFilePath should always be defined
-    (0, utils_js_1.assert)(hookFilePath);
-    assertHookFn(hookFn, { hookName, hookFilePath });
+    const { hookFn, hookFilePath } = getHookFromConfigValue(configValue);
+    const hooksTimeout = (0, getConfigValueRuntime_js_1.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 = (0, helpers_js_1.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;
+    (0, utils_js_1.assert)((0, utils_js_1.isArray)(val));
+    return val.map((v, i) => {
+        const hookFn = v;
+        const hookTimeout = getHookTimeoutGlobal(hookName);
+        (0, utils_js_1.assert)((0, utils_js_1.isArray)(configValue.definedAtData));
+        const hookFilePath = (0, helpers_js_1.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) {
     (0, utils_js_1.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;
+    (0, utils_js_1.assert)(hookFn);
+    const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue.definedAtData);
+    return { hookFn, hookFilePath };
 }
 function assertHook(pageContext, hookName) {
-    getHook(pageContext, hookName);
+    getHookFromPageContext(pageContext, hookName);
 }
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     (0, utils_js_1.assert)(hookName && hookFilePath);
     (0, utils_js_1.assert)(!hookName.endsWith(')'));
+    (0, utils_js_1.assert)(!hookFilePath.endsWith(' '));
     (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `Hook ${hookName}() defined by ${hookFilePath} should be a function`);
     (0, utils_js_1.checkType)(hookFn);
 }

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

@@ -14,7 +14,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     }
     else {
         // V1 design
-        hook = (0, getHook_js_1.getHook)(pageContext, 'guard');
+        hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'guard');
     }
     if (!hook)
         return;

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

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

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.228-commit-d423e4f';
+exports.PROJECT_VERSION = '0.4.228-commit-ae4784f';

package/dist/cjs/utils/objectAssign.js

@@ -4,15 +4,11 @@ exports.objectAssign = objectAssign;
 const assert_js_1 = require("./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)
             (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
-        }
         Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
     }
 }

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

@@ -4,6 +4,9 @@ declare function createPageContext(urlOriginal: string): Promise<{
     isClientSide: boolean;
     isPrerendering: boolean;
     urlOriginal: string;
+    globalContext: {
+        [x: string]: unknown;
+    };
     _objectCreatedByVike: boolean;
     _urlHandler: null;
     _urlRewrite: null;

package/dist/esm/client/client-routing-runtime/createPageContext.js

@@ -3,6 +3,7 @@ import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
+import { getGlobalContext } from './globalContextClientSide.js';
 import { assert, isBaseServer, objectAssign } from './utils.js';
 // @ts-ignore
 import * as virtualFileExports from 'virtual:vike:importUserCode:client:client-routing';
@@ -16,6 +17,7 @@ async function createPageContext(urlOriginal) {
         isClientSide: true,
         isPrerendering: false,
         urlOriginal,
+        globalContext: getGlobalContext(),
         _objectCreatedByVike: true,
         _urlHandler: null,
         _urlRewrite: null,

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -3,11 +3,11 @@ export { getPageContextFromHooks_serialized };
 export { getPageContextFromServerHooks };
 export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
-import { assert, assertUsage, hasProp, objectAssign, getProjectError, redirectHard, executeHook, isObject, getGlobalObject } from './utils.js';
+import { assert, assertUsage, hasProp, objectAssign, getProjectError, redirectHard, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
 import { analyzePageServerSide } from '../../shared/getPageFiles/analyzePageServerSide.js';
-import { getHook } from '../../shared/hooks/getHook.js';
+import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionClientSide } from '../shared/preparePageContextForUserConsumptionClientSide.js';
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
@@ -18,6 +18,7 @@ import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
 import { pageContextInitIsPassedToClient } from '../../shared/misc/pageContextInitIsPassedToClient.js';
 import { isServerSideError } from '../../shared/misc/isServerSideError.js';
+import { executeHook } from '../../shared/hooks/executeHook.js';
 const globalObject = getGlobalObject('client-routing-runtime/getPageContextFromHooks.ts', {});
 // TODO/eventually: rename
 function getPageContextFromHooks_serialized() {
@@ -101,7 +102,7 @@ async function getPageContextFromClientHooks(pageContext, isErrorPage) {
     return pageContextFromClientHooks;
 }
 async function executeHookClientSide(hookName, pageContext) {
-    const hook = getHook(pageContext, hookName);
+    const hook = getHookFromPageContext(pageContext, hookName);
     if (!hook) {
         // No hook defined or hook's env.client is false
         return {};

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

@@ -0,0 +1,5 @@
+export { getGlobalContext };
+export type { GlobalContextPublicClientSide };
+type GlobalContex = Record<string, unknown>;
+type GlobalContextPublicClientSide = GlobalContex;
+declare function getGlobalContext(): GlobalContextPublicClientSide;

package/dist/esm/client/client-routing-runtime/globalContextClientSide.js

@@ -0,0 +1,8 @@
+export { getGlobalContext };
+import { getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('client-routing-runtime/globalContextClientSide.ts', {});
+function getGlobalContext() {
+    if (!globalObject.globalContext)
+        globalObject.globalContext = {};
+    return globalObject.globalContext;
+}