vike 0.4.232-commit-134207d → 0.4.232-commit-ec54a7e

package/dist/cjs/node/prerender/runPrerender.js

@@ -67,6 +67,7 @@ const getOutDirs_js_1 = require("../vite/shared/getOutDirs.js");
 const node_fs_1 = __importDefault(require("node:fs"));
 const getProxyForPublicUsage_js_1 = require("../../shared/getProxyForPublicUsage.js");
 const resolveRedirects_js_1 = require("../runtime/renderPage/resolveRedirects.js");
+const utils_js_2 = require("../runtime/utils.js");
 const docLink = 'https://vike.dev/i18n#pre-rendering';
 async function runPrerender(options = {}, trigger) {
     (0, context_js_1.setWasPrerenderRun)(trigger);
@@ -360,7 +361,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {},
         });
     }
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+    (0, utils_js_2.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;

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

@@ -10,7 +10,14 @@ const debugPageFiles_js_1 = require("./debugPageFiles.js");
 const findPageConfig_js_1 = require("../../../shared/page-configs/findPageConfig.js");
 const analyzePage_js_1 = require("./analyzePage.js");
 const loadConfigValues_js_1 = require("../../../shared/page-configs/loadConfigValues.js");
+const execHookServer_js_1 = require("./execHookServer.js");
 async function loadPageConfigsLazyServerSide(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazy(pageContext);
+    (0, utils_js_1.objectAssign)(pageContext, pageContextAddendum);
+    await (0, execHookServer_js_1.execHookServer)('onCreatePageContext', pageContext);
+    return pageContext;
+}
+async function loadPageConfigsLazy(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
@@ -86,18 +93,16 @@ async function loadPageConfigsLazyServerSide(pageContext) {
             return pageAssetsOldFormat;
         },
     });
-    {
-        (0, debugPageFiles_js_1.debugPageFiles)({
-            pageContext,
-            isHtmlOnly,
-            isClientRouting,
-            pageFilesLoaded,
-            pageFilesClientSide,
-            pageFilesServerSide,
-            clientEntries,
-            clientDependencies,
-        });
-    }
+    (0, debugPageFiles_js_1.debugPageFiles)({
+        pageContext,
+        isHtmlOnly,
+        isClientRouting,
+        pageFilesLoaded,
+        pageFilesClientSide,
+        pageFilesServerSide,
+        clientEntries,
+        clientDependencies,
+    });
     return pageContextAddendum;
 }
 async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {

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

@@ -28,7 +28,7 @@ async function renderPageAlreadyRouted(pageContext) {
     (0, utils_js_1.assert)(isError ===
         (pageContext.pageId ===
             (0, error_page_js_1.getErrorPageId)(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+    (0, utils_js_1.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
     if (!isError) {
         await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(pageContext));
     }

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

@@ -143,59 +143,66 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
     else {
         (0, utils_js_1.assert)(errNominalPage);
         (0, utils_js_1.assert)(pageContextNominalPageSuccess === undefined);
-        (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, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-            if (handled.pageContextReturn) {
-                // - throw redirect()
-                // - throw render(url)
-                // - throw render(abortStatusCode) if .pageContext.json request
-                return handled.pageContextReturn;
-            }
-            else {
-                // - throw render(abortStatusCode) if not .pageContext.json request
-            }
-            Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+        return await renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite);
+    }
+}
+// When the normal page threw an error
+// - Can be a URL rewrite upon `throw render('/some-url')`
+// - Can be rendering the error page
+// - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
+async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
+    (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, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+        if (handled.pageContextReturn) {
+            // - throw redirect()
+            // - throw render(url)
+            // - throw render(abortStatusCode) if .pageContext.json request
+            return handled.pageContextReturn;
         }
-        {
-            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
-            if (!errorPageId) {
-                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
-                return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
-            }
-            else {
-                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: errorPageId });
-            }
+        else {
+            // - throw render(abortStatusCode) if not .pageContext.json request
         }
-        let pageContextErrorPage;
-        try {
-            pageContextErrorPage = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContextErrorPageInit);
+        Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+    }
+    {
+        const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
+        if (!errorPageId) {
+            (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
+            return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
         }
-        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, 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, pageContextBegin);
-                    return pageContextHttpWithError;
-                }
-                // `throw redirect()` / `throw render(url)`
-                return handled.pageContextReturn;
-            }
-            if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
-                (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
+        else {
+            (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: errorPageId });
+        }
+    }
+    let pageContextErrorPage;
+    try {
+        pageContextErrorPage = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContextErrorPageInit);
+    }
+    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, 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, pageContextBegin);
+                return pageContextHttpWithError;
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-            return pageContextWithError;
+            // `throw redirect()` / `throw render(url)`
+            return handled.pageContextReturn;
         }
-        return pageContextErrorPage;
+        if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
+            (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
+        }
+        const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+        return pageContextWithError;
     }
+    return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
@@ -417,7 +424,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit, true);
-            (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+            (0, utils_js_1.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         }

package/dist/cjs/shared/createPageContextShared.js

@@ -2,12 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPageContextShared = createPageContextShared;
 exports.createPageContextObject = createPageContextObject;
-const execHook_js_1 = require("./hooks/execHook.js");
-const preparePageContextForPublicUsage_js_1 = require("./preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
+// TODO/now: make this and parents sync
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
     (0, utils_js_1.objectAssign)(pageContextCreated, vikeConfigPublicGlobal);
-    await (0, execHook_js_1.execHookGlobal)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     return pageContextCreated;
 }
 function createPageContextObject() {

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

@@ -17,6 +17,7 @@ const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const executeOnBeforeRouteHook_js_1 = require("./executeOnBeforeRouteHook.js");
 const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+// TODO/next-major-release: make it sync
 async function route(pageContext, skipOnBeforeRouteHook) {
     (0, debug_js_1.debug)('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};

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.232-commit-134207d';
+exports.PROJECT_VERSION = '0.4.232-commit-ec54a7e';

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

@@ -6,7 +6,7 @@ export { addLinkPrefetchHandlers };
 export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
 import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, hasProp, objectAssign, } from './utils.js';
-import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
+import { isErrorFetchingStaticAssets, loadPageConfigsLazy } from '../shared/loadPageConfigsLazyClientSide.js';
 import { skipLink } from './skipLink.js';
 import { disableClientRouting } from './renderPageClientSide.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
@@ -45,7 +45,7 @@ function getPageContextPrefetched(pageContext) {
 }
 async function prefetchAssets(pageContextLink) {
     try {
-        await loadPageConfigsLazyClientSide(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._globalContext._pageConfigs, pageContextLink._globalContext._pageConfigGlobal);
+        await loadPageConfigsLazy(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._globalContext._pageConfigs, pageContextLink._globalContext._pageConfigGlobal);
     }
     catch (err) {
         if (isErrorFetchingStaticAssets(err)) {

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

@@ -9,7 +9,7 @@ import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
-import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
+import { isErrorFetchingStaticAssets, loadPageConfigsLazy, } from '../shared/loadPageConfigsLazyClientSide.js';
 import { pushHistoryState } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { route } from '../../shared/route/index.js';
@@ -20,7 +20,7 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { setPageContextCurrent } from './getPageContextCurrent.js';
 import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-import { execHooksErrorHandling, execHookErrorHandling, } from '../../shared/hooks/execHook.js';
+import { execHooksErrorHandling, execHookErrorHandling, execHook, } from '../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
 import { getHookFromPageContextNew } from '../../shared/hooks/getHook.js';
 import { preparePageContextForPublicUsageClientMinimal } from '../shared/preparePageContextForPublicUsageClientShared.js';
@@ -60,7 +60,7 @@ async function renderPageClientSide(renderArgs) {
     return;
     async function renderPageNominal() {
         const onError = async (err) => {
-            await renderErrorPage({ err });
+            await renderPageOnError({ err });
         };
         const pageContext = await getPageContextBegin(false, pageContextBeginArgs);
         if (isRenderOutdated())
@@ -134,8 +134,9 @@ async function renderPageClientSide(renderArgs) {
             assert(!('urlOriginal' in pageContextFromRoute));
             objectAssign(pageContext, pageContextFromRoute);
         }
+        let pageContextAugmented;
         try {
-            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal));
+            pageContextAugmented = await loadPageConfigsLazyClientSide(pageContext);
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -147,6 +148,7 @@ async function renderPageClientSide(renderArgs) {
                 return;
             }
         }
+        augmentType(pageContext, pageContextAugmented);
         if (isRenderOutdated())
             return;
         setPageContextCurrent(pageContext);
@@ -218,7 +220,11 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
     }
-    async function renderErrorPage(args) {
+    // When the normal page threw an error
+    // - Can be a URL rewrite upon `throw render('/some-url')`
+    // - Can be rendering the error page
+    // - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
+    async function renderPageOnError(args) {
         const onError = (err) => {
             if (!isSameErrorMessage(err, args.err)) {
                 /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
@@ -247,8 +253,6 @@ async function renderPageClientSide(renderArgs) {
         if (isRenderOutdated())
             return;
         objectAssign(pageContext, { routeParams: {} });
-        if (args.is404)
-            objectAssign(pageContext, { is404: true });
         if (args.pageContextError)
             objectAssign(pageContext, args.pageContextError);
         if ('err' in args) {
@@ -313,8 +317,9 @@ async function renderPageClientSide(renderArgs) {
             redirectHard(urlOriginal);
             return;
         }
+        let pageContextAugmented;
         try {
-            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal));
+            pageContextAugmented = await loadPageConfigsLazyClientSide(pageContext);
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -326,6 +331,7 @@ async function renderPageClientSide(renderArgs) {
                 return;
             }
         }
+        augmentType(pageContext, pageContextAugmented);
         if (isRenderOutdated())
             return;
         setPageContextCurrent(pageContext);
@@ -361,7 +367,7 @@ async function renderPageClientSide(renderArgs) {
     async function renderPageView(pageContext, isErrorPage) {
         const onError = async (err) => {
             if (!isErrorPage) {
-                await renderErrorPage({ err });
+                await renderPageOnError({ err });
             }
             else {
                 if (!isSameErrorMessage(err, isErrorPage.err)) {
@@ -596,3 +602,9 @@ function areKeysEqual(key1, key2) {
 function getPageContextClient() {
     return globalObject.renderedPageContext ?? null;
 }
+async function loadPageConfigsLazyClientSide(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazy(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
+    objectAssign(pageContext, pageContextAddendum);
+    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
+    return pageContext;
+}

package/dist/esm/client/runtime-server-routing/createPageContextClientSide.js

@@ -1,10 +1,12 @@
 export { createPageContextClientSide };
 import { assertUsage, augmentType, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
-import { loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
+import { loadPageConfigsLazy, } from '../shared/loadPageConfigsLazyClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { createPageContextObject, createPageContextShared } from '../../shared/createPageContextShared.js';
 import { getGlobalContextClientInternal } from './globalContext.js';
+import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
+import { execHook } from '../../shared/hooks/execHook.js';
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function createPageContextClientSide() {
     const globalContext = await getGlobalContextClientInternal();
@@ -20,10 +22,9 @@ async function createPageContextClientSide() {
     });
     objectAssign(pageContextCreated, getPageContextSerializedInHtml());
     // Sets pageContext.config to global configs
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal);
-    augmentType(pageContextCreated, pageContextAugmented);
+    augmentType(pageContextCreated, await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal));
     // Sets pageContext.config to local configs (overrides the pageContext.config set above)
-    objectAssign(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated.pageId, globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal));
+    augmentType(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated));
     assertPristineUrl();
     return pageContextCreated;
 }
@@ -31,3 +32,9 @@ function assertPristineUrl() {
     const urlCurrent = getCurrentUrl({ withoutHash: true });
     assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
 }
+async function loadPageConfigsLazyClientSide(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazy(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
+    objectAssign(pageContext, pageContextAddendum);
+    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
+    return pageContext;
+}

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

@@ -1,9 +1,19 @@
-export { loadPageConfigsLazyClientSide };
+export { loadPageConfigsLazy };
+export type { PageContext_loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 import { type PageFile, type VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
+import { PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
+type PageContext_loadPageConfigsLazyClientSide = {
+    pageId: string;
+    _pageFilesAll: PageFile[];
+    _globalContext: {
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: PageConfigGlobalRuntime;
+    };
+} & PageContextPrepareMinimum;
 type PageContextUserFilesLoaded = VikeConfigPublicPageLazy & {
     _pageFilesLoaded: PageFile[];
 };
-declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
+declare function loadPageConfigsLazy(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

package/dist/esm/client/shared/loadPageConfigsLazyClientSide.js

@@ -1,4 +1,4 @@
-export { loadPageConfigsLazyClientSide };
+export { loadPageConfigsLazy };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } from '../../shared/page-configs/resolveVikeConfigPublic.js';
@@ -6,7 +6,7 @@ import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { objectAssign } from '../runtime-server-routing/utils.js';
 const stamp = '__whileFetchingAssets';
-async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
+async function loadPageConfigsLazy(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
     const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;

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

@@ -171,7 +171,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
     _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
 } & {
-    urlParsed: import("../shared/utils.js").UrlPublic;
+    urlParsed: import("../runtime/utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 } & {
@@ -292,7 +292,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
     _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
 } & {
-    urlParsed: import("../shared/utils.js").UrlPublic;
+    urlParsed: import("../runtime/utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 } & {
@@ -310,13 +310,259 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     pageId: string;
     _debugRouteMatches: never[];
     routeParams: {};
-})) & import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+})) & (((({
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+} & Pick<import("../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    _globalContext: {
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        _vikeConfigPublicGlobal: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        pages: {
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+        };
+    } & ({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer;
+        viteConfig: ResolvedConfig;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: true;
+        viteConfig: ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    });
+    _pageFilesAll: PageFile[];
+    _baseServer: string;
+    _baseAssets: string;
+    _pageContextInit: import("../runtime/renderPage.js").PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+} & {
+    urlParsed: import("../runtime/utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    _urlHandler: null;
+    _httpRequestId: null;
+    _urlRewrite: null;
+    _noExtraDir: boolean | null;
+    _prerenderContext: PrerenderContext;
+    _providedByHook: ProvidedByHook;
+    _urlOriginalModifiedByHook: ProvidedByHookTransformer;
+    is404: boolean;
+} & import("../../shared/route/index.js").PageContextFromRoute & Record<"pageId", string>) | ({
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+} & Pick<import("../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    _globalContext: {
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        _vikeConfigPublicGlobal: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        pages: {
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+        };
+    } & ({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer;
+        viteConfig: ResolvedConfig;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: true;
+        viteConfig: ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    });
+    _pageFilesAll: PageFile[];
+    _baseServer: string;
+    _baseAssets: string;
+    _pageContextInit: import("../runtime/renderPage.js").PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+} & {
+    urlParsed: import("../runtime/utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    _urlHandler: null;
+    _httpRequestId: null;
+    _urlRewrite: null;
+    _noExtraDir: boolean | null;
+    _prerenderContext: PrerenderContext;
+    _providedByHook: ProvidedByHook;
+    _urlOriginalModifiedByHook: ProvidedByHookTransformer;
+    is404: boolean;
+} & {
+    pageId: string;
+    _debugRouteMatches: never[];
+    routeParams: {};
+})) & import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy) & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];
     _pageFilePathsLoaded: string[];
 } & {
     __getPageAssets: () => Promise<import("../runtime/renderPage/getPageAssets.js").PageAsset[]>;
-}) & {
+})) & {
     _usesClientRouter: boolean;
 }>;

package/dist/esm/node/prerender/runPrerender.js

@@ -29,6 +29,7 @@ import { getOutDirs } from '../vite/shared/getOutDirs.js';
 import fs from 'node:fs';
 import { getProxyForPublicUsage } from '../../shared/getProxyForPublicUsage.js';
 import { getStaticRedirectsForPrerender } from '../runtime/renderPage/resolveRedirects.js';
+import { augmentType } from '../runtime/utils.js';
 const docLink = 'https://vike.dev/i18n#pre-rendering';
 async function runPrerender(options = {}, trigger) {
     setWasPrerenderRun(trigger);
@@ -322,7 +323,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {},
         });
     }
-    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;

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

@@ -1,18 +1,27 @@
 export { loadPageConfigsLazyServerSide };
-export type { PageFiles };
 export type { PageContext_loadPageConfigsLazyServerSide };
+export type { PageConfigsLazy };
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
+import { type PageContextExecuteHookServer } from './execHookServer.js';
+type PageContextExecute = Omit<PageContextExecuteHookServer, keyof Awaited<ReturnType<typeof loadPageConfigsLazy>>>;
 type PageContext_loadPageConfigsLazyServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
+    pageId: string;
     urlOriginal: string;
     _globalContext: GlobalContextServerInternal;
 };
-type PageFiles = PromiseType<ReturnType<typeof loadPageConfigsLazyServerSide>>;
-declare function loadPageConfigsLazyServerSide(pageContext: {
-    pageId: string;
-} & PageContext_loadPageConfigsLazyServerSide): Promise<import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+type PageConfigsLazy = PromiseType<ReturnType<typeof loadPageConfigsLazy>>;
+declare function loadPageConfigsLazyServerSide<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecute>(pageContext: PageContext): Promise<PageContext & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+    Page: unknown;
+    _isHtmlOnly: boolean;
+    _passToClient: string[];
+    _pageFilePathsLoaded: string[];
+} & {
+    __getPageAssets: () => Promise<PageAsset[]>;
+}>;
+declare function loadPageConfigsLazy(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];

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

@@ -8,7 +8,14 @@ import { debugPageFiles } from './debugPageFiles.js';
 import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
+import { execHookServer } from './execHookServer.js';
 async function loadPageConfigsLazyServerSide(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazy(pageContext);
+    objectAssign(pageContext, pageContextAddendum);
+    await execHookServer('onCreatePageContext', pageContext);
+    return pageContext;
+}
+async function loadPageConfigsLazy(pageContext) {
     const pageConfig = findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
@@ -84,18 +91,16 @@ async function loadPageConfigsLazyServerSide(pageContext) {
             return pageAssetsOldFormat;
         },
     });
-    {
-        debugPageFiles({
-            pageContext,
-            isHtmlOnly,
-            isClientRouting,
-            pageFilesLoaded,
-            pageFilesClientSide,
-            pageFilesServerSide,
-            clientEntries,
-            clientDependencies,
-        });
-    }
+    debugPageFiles({
+        pageContext,
+        isHtmlOnly,
+        isClientRouting,
+        pageFilesLoaded,
+        pageFilesClientSide,
+        pageFilesServerSide,
+        clientEntries,
+        clientDependencies,
+    });
     return pageContextAddendum;
 }
 async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {

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

@@ -3,7 +3,7 @@ export { prerenderPage };
 export type { PageContextAfterRender };
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
 import { HttpResponse } from './createHttpResponse.js';
-import { PageContext_loadPageConfigsLazyServerSide, type PageFiles } from './loadPageConfigsLazyServerSide.js';
+import { PageContext_loadPageConfigsLazyServerSide, type PageConfigsLazy } from './loadPageConfigsLazyServerSide.js';
 import type { PageContextCreated } from './createPageContextServerSide.js';
 type PageContextAfterRender = {
     httpResponse: HttpResponse;
@@ -17,7 +17,7 @@ declare function renderPageAlreadyRouted<PageContext extends {
     errorWhileRendering: null | Error;
     _httpRequestId: number;
 } & PageContextCreated & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
-declare function prerenderPage(pageContext: PageContextCreated & PageFiles & {
+declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy & {
     routeParams: Record<string, string>;
     pageId: string;
     _urlRewrite: null;

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

@@ -2,7 +2,7 @@ export { renderPageAlreadyRouted };
 export { prerenderPage };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
-import { assert, assertUsage, hasProp, objectAssign } from '../utils.js';
+import { assert, assertUsage, augmentType, hasProp, objectAssign } from '../utils.js';
 import { getPageContextClientSerialized } from '../html/serializeContext.js';
 import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
 import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
@@ -23,7 +23,7 @@ async function renderPageAlreadyRouted(pageContext) {
     assert(isError ===
         (pageContext.pageId ===
             getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     if (!isError) {
         await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
     }

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

@@ -3,7 +3,7 @@ export { renderPage_addAsyncHookwrapper };
 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 { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, augmentType, } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -138,59 +138,66 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
     else {
         assert(errNominalPage);
         assert(pageContextNominalPageSuccess === undefined);
-        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, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-            if (handled.pageContextReturn) {
-                // - throw redirect()
-                // - throw render(url)
-                // - throw render(abortStatusCode) if .pageContext.json request
-                return handled.pageContextReturn;
-            }
-            else {
-                // - throw render(abortStatusCode) if not .pageContext.json request
-            }
-            Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+        return await renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite);
+    }
+}
+// When the normal page threw an error
+// - Can be a URL rewrite upon `throw render('/some-url')`
+// - Can be rendering the error page
+// - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
+async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
+    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, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+        if (handled.pageContextReturn) {
+            // - throw redirect()
+            // - throw render(url)
+            // - throw render(abortStatusCode) if .pageContext.json request
+            return handled.pageContextReturn;
         }
-        {
-            const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
-            if (!errorPageId) {
-                objectAssign(pageContextErrorPageInit, { pageId: null });
-                return handleErrorWithoutErrorPage(pageContextErrorPageInit);
-            }
-            else {
-                objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
-            }
+        else {
+            // - throw render(abortStatusCode) if not .pageContext.json request
         }
-        let pageContextErrorPage;
-        try {
-            pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
+        Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+    }
+    {
+        const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
+        if (!errorPageId) {
+            objectAssign(pageContextErrorPageInit, { pageId: null });
+            return handleErrorWithoutErrorPage(pageContextErrorPageInit);
         }
-        catch (errErrorPage) {
-            // Handle `throw redirect()` and `throw render()` while rendering error page
-            if (isAbortError(errErrorPage)) {
-                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, pageContextBegin);
-                    return pageContextHttpWithError;
-                }
-                // `throw redirect()` / `throw render(url)`
-                return handled.pageContextReturn;
-            }
-            if (isNewError(errErrorPage, errNominalPage)) {
-                logRuntimeError(errErrorPage, httpRequestId);
+        else {
+            objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
+        }
+    }
+    let pageContextErrorPage;
+    try {
+        pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
+    }
+    catch (errErrorPage) {
+        // Handle `throw redirect()` and `throw render()` while rendering error page
+        if (isAbortError(errErrorPage)) {
+            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, pageContextBegin);
+                return pageContextHttpWithError;
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-            return pageContextWithError;
+            // `throw redirect()` / `throw render(url)`
+            return handled.pageContextReturn;
         }
-        return pageContextErrorPage;
+        if (isNewError(errErrorPage, errNominalPage)) {
+            logRuntimeError(errErrorPage, httpRequestId);
+        }
+        const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+        return pageContextWithError;
     }
+    return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
@@ -412,7 +419,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
-            objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+            augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = getPageContextClientSerialized(pageContext);
         }

package/dist/esm/shared/createPageContextShared.js

@@ -1,11 +1,9 @@
 export { createPageContextShared };
 export { createPageContextObject };
-import { execHookGlobal } from './hooks/execHook.js';
-import { preparePageContextForPublicUsage } from './preparePageContextForPublicUsage.js';
 import { changeEnumerable, objectAssign } from './utils.js';
+// TODO/now: make this and parents sync
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
     objectAssign(pageContextCreated, vikeConfigPublicGlobal);
-    await execHookGlobal('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage);
     return pageContextCreated;
 }
 function createPageContextObject() {

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

@@ -19,6 +19,7 @@ import type { PageContextForPublicUsageServer } from '../../node/runtime/renderP
 import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
 import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
+type PageContextPrepareMinimum2 = PageContextPrepareMinimum & VikeConfigPublicPageLazy;
 type PageContextExecuteHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
@@ -28,8 +29,8 @@ declare function execHookSingle<PageContext extends PageContextExecuteHook>(hook
 declare function execHookSingleWithReturn<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
     hookReturn: unknown;
 }>;
-declare function execHook<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
-declare function execHookErrorHandling<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+declare function execHook<PageContext extends PageContextPrepareMinimum2>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookErrorHandling<PageContext extends PageContextPrepareMinimum2>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
     hooks: HookWithResult[];
     err?: undefined;
 } | {

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

@@ -12,6 +12,7 @@ import { resolveRouteFunction } from './resolveRouteFunction.js';
 import { executeOnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
+// TODO/next-major-release: make it sync
 async function route(pageContext, skipOnBeforeRouteHook) {
     debug('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.232-commit-134207d";
+export declare const PROJECT_VERSION: "0.4.232-commit-ec54a7e";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.232-commit-134207d';
+export const PROJECT_VERSION = '0.4.232-commit-ec54a7e';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.232-commit-134207d",
+  "version": "0.4.232-commit-ec54a7e",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {