vike 0.4.232 → 0.4.233-commit-e534fd6

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/html/injectAssets/getHtmlTags.js

@@ -160,9 +160,26 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
 }
 function mergeScriptEntries(pageAssets, viteDevScript) {
     const scriptEntries = pageAssets.filter((pageAsset) => pageAsset.isEntry && pageAsset.assetType === 'script');
-    const scriptTagsHtml = `${viteDevScript}${scriptEntries.map((asset) => inferAssetTag(asset)).join('')}`;
-    const scriptTag = mergeScriptTags(scriptTagsHtml);
-    return scriptTag;
+    let scriptEntry = `${viteDevScript}${scriptEntries.map((asset) => inferAssetTag(asset)).join('')}`;
+    // We merge scripts to avoid the infamous HMR preamble error.
+    // - Infamous HMR preamble error:
+    //   ```browser-console
+    //   usePageContext.tsx:10 Uncaught (in promise) Error: @vitejs/plugin-react can't detect preamble. Something is wrong.
+    //       at usePageContext.tsx:10:10
+    //   ```
+    // - Note the following race condition. Maybe making the second script non-async ensures execution order?
+    //   ```html
+    //   <script type="module">console.log("I can be printed *after* the other log")</script>
+    //   <script src="entry.js" type="module" async></script>
+    //   ```
+    //   ```js
+    //   // entry.js
+    //   console.log("I can be printed *before* the other log")
+    //   ```
+    // - Maybe an alternative would be to make Vike's client runtime entry <script> tag non-async. Would that work? Would it be a performance issue?
+    //   - The entry <script> shouldn't be `<script defer>` upon HTML streaming, otherwise progressive hydration while SSR streaming won't work.
+    scriptEntry = mergeScriptTags(scriptEntry);
+    return scriptEntry;
 }
 function getPageContextJsonScriptTag(pageContext) {
     const pageContextClientSerialized = sanitizeJson(getPageContextClientSerialized(pageContext));

package/dist/esm/node/runtime/html/injectAssets/mergeScriptTags.js

@@ -19,7 +19,13 @@ function mergeScriptTags(scriptTagsHtml) {
                 const hasInnerHtml = !!innerHtml.trim();
                 if (src) {
                     assert(!hasInnerHtml);
-                    contents.push(`import ${JSON.stringify(src)};`);
+                    // - We don't use a static import because static imports are hoisted => React's HMR preamble can be executed after user land code => triggering this error:
+                    //   ```
+                    //   [22:28:57.885][/test-dev.test.ts][pnpm run dev][Browser Error] Error: @vitejs/plugin-react-swc can't detect preamble. Something is wrong.
+                    //       at http://localhost:3000/@fs/home/rom/code/docpress/src/renderer/usePageContext.tsx:9:11
+                    //   ```
+                    // - We don't use `await` the dynamic import() to avoid waterfall
+                    contents.push(`import(${JSON.stringify(src)});`);
                 }
                 else if (hasInnerHtml) {
                     innerHtml = innerHtml.split('\n').filter(Boolean).join('\n');

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;