vike 0.4.232 → 0.4.233

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

@@ -18,17 +18,18 @@ import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueR
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { getErrorPageId, isErrorPage } from '../../shared/error-page.js';
 import { isAbortError } from '../../shared/route/abort.js';
-import { loadPageConfigsLazyServerSide } from '../runtime/renderPage/loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSideAndExecHook } from '../runtime/renderPage/loadPageConfigsLazyServerSide.js';
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, getHook_setIsPrerenderering, } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
-import { execHookWithoutPageContext, isUserHookError } from '../../shared/hooks/execHook.js';
+import { execHookDirectWithoutPageContext, isUserHookError } from '../../shared/hooks/execHook.js';
 import { setWasPrerenderRun } from './context.js';
 import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal } from './resolvePrerenderConfig.js';
 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);
@@ -215,7 +216,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
         const { hookName, hookFilePath } = hook;
-        const prerenderResult = await execHookWithoutPageContext(() => hook.hookFn(), hook);
+        const prerenderResult = await execHookDirectWithoutPageContext(() => hook.hookFn(), hook);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
@@ -322,7 +323,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {},
         });
     }
-    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -443,7 +444,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         preservePropertyGetters(pageContext);
     });
     const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
-    let result = await execHookWithoutPageContext(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
+    let result = await execHookDirectWithoutPageContext(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;
@@ -725,9 +726,13 @@ function getRedirectHtml(urlTarget) {
   <meta charset="UTF-8">
   <meta http-equiv="refresh" content="0;url=${urlTargetSafe}">
   <title>Redirect ${urlTargetSafe}</title>
+  <style>body{opacity:0}</style>
+  <noscript>
+  <style>body{opacity:1}</style>
+  </noscript>
 </head>
 <body style="min-height: 100vh; margin: 0; font-family: sans-serif; display: flex; justify-content: center; align-items: center; transition: opacity 0.3s;">
-  <script>document.body.style.opacity=0; setTimeout(()=>{document.body.style.opacity=1},1000);</script>
+  <script>setTimeout(()=>{document.body.style.opacity=1},2000)</script>
   <div>
     <h1>Redirect <a href="${urlTargetSafe}"><code style="background-color: #eaeaea; padding: 3px 5px; border-radius: 4px;">${urlTargetSafe}</code></a></h1>
     <p>If you aren't redirected, click the link above.</p>

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

@@ -8,7 +8,7 @@ export { createHttpResponseBaseIsMissing };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from '../html/renderHtml.js';
-import type { RenderHook } from './executeOnRenderHtmlHook.js';
+import type { RenderHook } from './execHookOnRenderHtml.js';
 import type { RedirectStatusCode, AbortStatusCode, UrlRedirect } from '../../../shared/route/abort.js';
 import { HttpResponseBody } from './getHttpResponseBody.js';
 import { type EarlyHint } from './getEarlyHints.js';

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

@@ -0,0 +1,6 @@
+export { execHookDataAndOnBeforeRender };
+import { type PageContextExecHookServer } from './execHookServer.js';
+declare function execHookDataAndOnBeforeRender(pageContext: {
+    pageId: string;
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+} & PageContextExecHookServer): Promise<void>;

package/dist/esm/node/runtime/renderPage/{executeOnBeforeRenderAndDataHooks.js → execHookDataAndOnBeforeRender.js}

@@ -1,7 +1,7 @@
-export { executeOnBeforeRenderAndDataHooks };
+export { execHookDataAndOnBeforeRender };
 import { assertOnBeforeRenderHookReturn } from '../../../shared/assertOnBeforeRenderHookReturn.js';
 import { execHookServer } from './execHookServer.js';
-async function executeOnBeforeRenderAndDataHooks(pageContext) {
+async function execHookDataAndOnBeforeRender(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;
     }

package/dist/esm/node/runtime/renderPage/{executeOnRenderHtmlHook.d.ts → execHookOnRenderHtml.d.ts}

@@ -1,4 +1,4 @@
-export { executeOnRenderHtmlHook };
+export { execHookOnRenderHtml };
 export type { RenderHook };
 import { type HtmlRender } from '../html/renderHtml.js';
 import { type Hook } from '../../../shared/hooks/getHook.js';
@@ -11,7 +11,7 @@ type RenderHook = Hook & {
     hookName: HookName;
 };
 type HookName = 'onRenderHtml' | 'render';
-declare function executeOnRenderHtmlHook(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
+declare function execHookOnRenderHtml(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
     pageId: string;
     _globalContext: GlobalContextServerInternal;
     __getPageAssets: GetPageAssets;

package/dist/esm/node/runtime/renderPage/{executeOnRenderHtmlHook.js → execHookOnRenderHtml.js}

@@ -1,4 +1,4 @@
-export { executeOnRenderHtmlHook };
+export { execHookOnRenderHtml };
 import { isDocumentHtml, renderDocumentHtml, dangerouslySkipEscape, } from '../html/renderHtml.js';
 import { getHookFromPageContext } from '../../../shared/hooks/getHook.js';
 import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, isCallable } from '../utils.js';
@@ -8,11 +8,11 @@ import { preparePageContextForPublicUsageServer, } from './preparePageContextFor
 import { assertHookReturnedObject } from '../../../shared/assertHookReturnedObject.js';
 import { logRuntimeError } from '../loggerRuntime.js';
 import pc from '@brillout/picocolors';
-import { execHookSingleWithReturn } from '../../../shared/hooks/execHook.js';
-async function executeOnRenderHtmlHook(pageContext) {
+import { execHookDirectSingleWithReturn } from '../../../shared/hooks/execHook.js';
+async function execHookOnRenderHtml(pageContext) {
     const hook = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: hook });
-    const { hookReturn } = await execHookSingleWithReturn(hook, pageContext, preparePageContextForPublicUsageServer);
+    const { hookReturn } = await execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsageServer);
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     objectAssign(pageContext, { _pageContextPromise: pageContextPromise });

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

@@ -1,10 +1,10 @@
 export { execHookServer };
-export type { PageContextExecuteHookServer };
+export type { PageContextExecHookServer };
 import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
 import type { VikeConfigPublicPageLazy } from '../../../shared/getPageFiles.js';
 import type { HookName } from '../../../types/Config.js';
-type PageContextExecuteHookServer = VikeConfigPublicPageLazy & PageContextForPublicUsageServer;
-declare function execHookServer(hookName: HookName, pageContext: PageContextExecuteHookServer): Promise<(import("../../../shared/hooks/getHook.js").HookLoc & {
+type PageContextExecHookServer = VikeConfigPublicPageLazy & PageContextForPublicUsageServer;
+declare function execHookServer(hookName: HookName, pageContext: PageContextExecHookServer): Promise<(import("../../../shared/hooks/getHook.js").HookLoc & {
     hookFn: (arg: import("../../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum | import("../../../shared/prepareGlobalContextForPublicUsage.js").GlobalContextPrepareMinimum) => unknown;
     hookTimeout: import("../../../shared/hooks/getHook.js").HookTimeout;
 } & {

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

@@ -2,8 +2,5 @@ export { execHookServer };
 import { execHook } from '../../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
 async function execHookServer(hookName, pageContext) {
-    return await execHook(hookName, pageContext, (p) => {
-        preparePageContextForPublicUsageServer(p);
-        return p;
-    });
+    return await execHook(hookName, pageContext, preparePageContextForPublicUsageServer);
 }

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

@@ -3,7 +3,7 @@ export { getHttpResponseBodyStreamHandlers };
 export type { HttpResponseBody };
 import { StreamPipeNode, StreamPipeWeb, StreamReadableNode, StreamReadableWeb, StreamWritableNode, StreamWritableWeb } from '../html/stream.js';
 import { type HtmlRender } from '../html/renderHtml.js';
-import type { RenderHook } from './executeOnRenderHtmlHook.js';
+import type { RenderHook } from './execHookOnRenderHtml.js';
 type HttpResponseBody = {
     body: string;
     pipe: (writable: StreamWritableWeb | StreamWritableNode) => void;

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

@@ -1,18 +1,27 @@
-export { loadPageConfigsLazyServerSide };
-export type { PageFiles };
+export { loadPageConfigsLazyServerSideAndExecHook };
 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 PageContextExecHookServer } from './execHookServer.js';
+type PageContextExecuteHook = Omit<PageContextExecHookServer, keyof Awaited<ReturnType<typeof loadPageConfigsLazyServerSide>>>;
 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 loadPageConfigsLazyServerSide>>;
+declare function loadPageConfigsLazyServerSideAndExecHook<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecuteHook>(pageContext: PageContext): Promise<PageContext & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+    Page: unknown;
+    _isHtmlOnly: boolean;
+    _passToClient: string[];
+    _pageFilePathsLoaded: string[];
+} & {
+    __getPageAssets: () => Promise<PageAsset[]>;
+}>;
+declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];

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

@@ -1,4 +1,4 @@
-export { loadPageConfigsLazyServerSide };
+export { loadPageConfigsLazyServerSideAndExecHook };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
@@ -8,6 +8,13 @@ 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 loadPageConfigsLazyServerSideAndExecHook(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazyServerSide(pageContext);
+    objectAssign(pageContext, pageContextAddendum);
+    await execHookServer('onCreatePageContext', pageContext);
+    return pageContext;
+}
 async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
@@ -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,16 +2,16 @@ 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';
-import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
-import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
+import { loadPageConfigsLazyServerSideAndExecHook, } from './loadPageConfigsLazyServerSide.js';
+import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
+import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
 import { logRuntimeError } from '../loggerRuntime.js';
 import { isNewError } from './isNewError.js';
 import { preparePageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
-import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
+import { execHookGuard } from '../../../shared/route/execHookGuard.js';
 import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 async function renderPageAlreadyRouted(pageContext) {
@@ -23,16 +23,16 @@ async function renderPageAlreadyRouted(pageContext) {
     assert(isError ===
         (pageContext.pageId ===
             getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
     if (!isError) {
-        await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
+        await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
     }
     if (!isError) {
-        await executeOnBeforeRenderAndDataHooks(pageContext);
+        await execHookDataAndOnBeforeRender(pageContext);
     }
     else {
         try {
-            await executeOnBeforeRenderAndDataHooks(pageContext);
+            await execHookDataAndOnBeforeRender(pageContext);
         }
         catch (err) {
             if (isNewError(err, pageContext.errorWhileRendering)) {
@@ -49,7 +49,7 @@ async function renderPageAlreadyRouted(pageContext) {
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }
-    const renderHookResult = await executeOnRenderHtmlHook(pageContext);
+    const renderHookResult = await execHookOnRenderHtml(pageContext);
     const { htmlRender, renderHook } = renderHookResult;
     const httpResponse = await createHttpResponsePage(htmlRender, renderHook, pageContext);
     objectAssign(pageContext, { httpResponse });
@@ -62,10 +62,10 @@ async function prerenderPage(pageContext) {
     });
     /* Should we execute the guard() hook upon pre-rendering? Is there a use case for this?
      *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling
-    await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
+    await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
     */
-    await executeOnBeforeRenderAndDataHooks(pageContext);
-    const { htmlRender, renderHook } = await executeOnRenderHtmlHook(pageContext);
+    await execHookDataAndOnBeforeRender(pageContext);
+    const { htmlRender, renderHook } = await execHookOnRenderHtml(pageContext);
     assertUsage(htmlRender !== null, `Cannot pre-render ${pc.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
     assert(pageContext.isClientSideNavigation === false);
     const documentHtml = await getHtmlString(htmlRender);