vike 0.4.232-commit-1690f53 → 0.4.232

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("../runtime/utils.js").UrlPublic;
+    urlParsed: import("../shared/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("../runtime/utils.js").UrlPublic;
+    urlParsed: import("../shared/utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 } & {
@@ -310,259 +310,13 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     pageId: string;
     _debugRouteMatches: never[];
     routeParams: {};
-})) & (((({
-    _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) & {
+})) & 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,18 +18,17 @@ 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 { loadPageConfigsLazyServerSideAndExecHook } from '../runtime/renderPage/loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSide } 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 { execHookDirectWithoutPageContext, isUserHookError } from '../../shared/hooks/execHook.js';
+import { execHookWithoutPageContext, 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);
@@ -216,7 +215,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
         const { hookName, hookFilePath } = hook;
-        const prerenderResult = await execHookDirectWithoutPageContext(() => hook.hookFn(), hook);
+        const prerenderResult = await execHookWithoutPageContext(() => hook.hookFn(), hook);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
@@ -323,7 +322,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {},
         });
     }
-    augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
+    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -444,7 +443,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         preservePropertyGetters(pageContext);
     });
     const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
-    let result = await execHookDirectWithoutPageContext(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
+    let result = await execHookWithoutPageContext(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;
@@ -726,13 +725,9 @@ 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>setTimeout(()=>{document.body.style.opacity=1},2000)</script>
+  <script>document.body.style.opacity=0; setTimeout(()=>{document.body.style.opacity=1},1000);</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 './execHookOnRenderHtml.js';
+import type { RenderHook } from './executeOnRenderHtmlHook.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/execHookServer.d.ts

@@ -1,10 +1,10 @@
 export { execHookServer };
-export type { PageContextExecHookServer };
+export type { PageContextExecuteHookServer };
 import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
 import type { VikeConfigPublicPageLazy } from '../../../shared/getPageFiles.js';
 import type { HookName } from '../../../types/Config.js';
-type PageContextExecHookServer = VikeConfigPublicPageLazy & PageContextForPublicUsageServer;
-declare function execHookServer(hookName: HookName, pageContext: PageContextExecHookServer): Promise<(import("../../../shared/hooks/getHook.js").HookLoc & {
+type PageContextExecuteHookServer = VikeConfigPublicPageLazy & PageContextForPublicUsageServer;
+declare function execHookServer(hookName: HookName, pageContext: PageContextExecuteHookServer): 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,5 +2,8 @@ export { execHookServer };
 import { execHook } from '../../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
 async function execHookServer(hookName, pageContext) {
-    return await execHook(hookName, pageContext, preparePageContextForPublicUsageServer);
+    return await execHook(hookName, pageContext, (p) => {
+        preparePageContextForPublicUsageServer(p);
+        return p;
+    });
 }

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

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

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

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

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

@@ -1,4 +1,4 @@
-export { execHookOnRenderHtml };
+export { executeOnRenderHtmlHook };
 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 execHookOnRenderHtml(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
+declare function executeOnRenderHtmlHook(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
     pageId: string;
     _globalContext: GlobalContextServerInternal;
     __getPageAssets: GetPageAssets;

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

@@ -1,4 +1,4 @@
-export { execHookOnRenderHtml };
+export { executeOnRenderHtmlHook };
 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 { execHookDirectSingleWithReturn } from '../../../shared/hooks/execHook.js';
-async function execHookOnRenderHtml(pageContext) {
+import { execHookSingleWithReturn } from '../../../shared/hooks/execHook.js';
+async function executeOnRenderHtmlHook(pageContext) {
     const hook = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: hook });
-    const { hookReturn } = await execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsageServer);
+    const { hookReturn } = await execHookSingleWithReturn(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/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 './execHookOnRenderHtml.js';
+import type { RenderHook } from './executeOnRenderHtmlHook.js';
 type HttpResponseBody = {
     body: string;
     pipe: (writable: StreamWritableWeb | StreamWritableNode) => void;

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

@@ -1,27 +1,18 @@
-export { loadPageConfigsLazyServerSideAndExecHook };
+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 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 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 & {
+type PageFiles = PromiseType<ReturnType<typeof loadPageConfigsLazyServerSide>>;
+declare function loadPageConfigsLazyServerSide(pageContext: {
+    pageId: string;
+} & 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 { loadPageConfigsLazyServerSideAndExecHook };
+export { loadPageConfigsLazyServerSide };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
@@ -8,13 +8,6 @@ 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;
@@ -91,16 +84,18 @@ 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 PageConfigsLazy } from './loadPageConfigsLazyServerSide.js';
+import { PageContext_loadPageConfigsLazyServerSide, type PageFiles } 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 & PageConfigsLazy & {
+declare function prerenderPage(pageContext: PageContextCreated & PageFiles & {
     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, augmentType, hasProp, objectAssign } from '../utils.js';
+import { assert, assertUsage, hasProp, objectAssign } from '../utils.js';
 import { getPageContextClientSerialized } from '../html/serializeContext.js';
 import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
-import { loadPageConfigsLazyServerSideAndExecHook, } from './loadPageConfigsLazyServerSide.js';
-import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
-import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
+import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
+import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
+import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
 import { logRuntimeError } from '../loggerRuntime.js';
 import { isNewError } from './isNewError.js';
 import { preparePageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
-import { execHookGuard } from '../../../shared/route/execHookGuard.js';
+import { executeGuardHook } from '../../../shared/route/executeGuardHook.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)));
-    augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
+    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     if (!isError) {
-        await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
+        await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
     }
     if (!isError) {
-        await execHookDataAndOnBeforeRender(pageContext);
+        await executeOnBeforeRenderAndDataHooks(pageContext);
     }
     else {
         try {
-            await execHookDataAndOnBeforeRender(pageContext);
+            await executeOnBeforeRenderAndDataHooks(pageContext);
         }
         catch (err) {
             if (isNewError(err, pageContext.errorWhileRendering)) {
@@ -49,7 +49,7 @@ async function renderPageAlreadyRouted(pageContext) {
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }
-    const renderHookResult = await execHookOnRenderHtml(pageContext);
+    const renderHookResult = await executeOnRenderHtmlHook(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 execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
+    await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
     */
-    await execHookDataAndOnBeforeRender(pageContext);
-    const { htmlRender, renderHook } = await execHookOnRenderHtml(pageContext);
+    await executeOnBeforeRenderAndDataHooks(pageContext);
+    const { htmlRender, renderHook } = await executeOnRenderHtmlHook(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);