vike 0.4.250-commit-193dea3 → 0.4.250-commit-6161324

package/dist/server/runtime/renderPageServer/createPageContextServerSide.d.ts

@@ -1,10 +1,10 @@
 export { createPageContextServerSide };
 export { createPageContextServerSideWithoutGlobalContext };
 export type { PageContextCreatedServer };
-export type { PageContextCreatedServerMinimum };
+export type { PageContextCreatedServerBase };
 import type { GlobalContextServerInternal } from '../globalContext.js';
 import type { PageContextInit } from '../renderPageServer.js';
-type PageContextCreatedServerMinimum = ReturnType<typeof createPageContextServerSideWithoutGlobalContext>;
+type PageContextCreatedServerBase = ReturnType<typeof createPageContextBase>;
 type PageContextCreatedServer = Awaited<ReturnType<typeof createPageContextServerSide>>;
 declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, args: {
     requestId: number;
@@ -21,10 +21,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
     isClientSide: false;
     isPrerendering: boolean;
     _requestId: number;
-} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-    url?: string;
-    headers?: Record<string, string>;
-} & {
+} & PageContextInit & {
     _globalContext: ({
         _globalConfigPublic: {
             pages: {
@@ -156,7 +153,12 @@ declare function createPageContextServerSideWithoutGlobalContext(pageContextInit
     isClientSide: false;
     isPrerendering: boolean;
     _requestId: number;
-} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-    url?: string;
-    headers?: Record<string, string>;
-};
+} & PageContextInit;
+declare function createPageContextBase(pageContextInit: PageContextInit | null, isPrerendering: boolean, requestId: number): {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+    _requestId: number;
+} & PageContextInit;

package/dist/server/runtime/renderPageServer/createPageContextServerSide.js

@@ -5,8 +5,8 @@ import { getPageContextUrlComputed } from '../../../shared-server-client/getPage
 import { createPageContextObject, createPageContextShared, } from '../../../shared-server-client/createPageContextShared.js';
 function createPageContextServerSide(pageContextInit, globalContext, args) {
     assert(pageContextInit.urlOriginal);
-    const pageContextCreated = createPageContext(pageContextInit, args.isPrerendering, args.requestId);
-    objectAssign(pageContextCreated, {
+    const pageContext = createPageContextBase(pageContextInit, args.isPrerendering, args.requestId);
+    objectAssign(pageContext, {
         _globalContext: globalContext,
         _pageFilesAll: globalContext._pageFilesAll, // TO-DO/next-major-release: remove
         // We use pageContext._baseServer and pageContext._baseAssets instead of pageContext._globalContext.baseServer and pageContext._globalContext.baseAssets because the Base URLs can (eventually one day if needed) be made non-global
@@ -16,10 +16,10 @@ function createPageContextServerSide(pageContextInit, globalContext, args) {
         _urlHandler: args.isPrerendering ? null : args.urlHandler,
         isClientSideNavigation: args.isPrerendering ? false : args.isClientSideNavigation,
     });
-    objectAssign(pageContextCreated, globalContext._globalConfigPublic);
+    objectAssign(pageContext, globalContext._globalConfigPublic);
     // pageContext.urlParsed
-    const pageContextUrlComputed = getPageContextUrlComputed(pageContextCreated);
-    objectAssign(pageContextCreated, pageContextUrlComputed);
+    const pageContextUrlComputed = getPageContextUrlComputed(pageContext);
+    objectAssign(pageContext, pageContextUrlComputed);
     // pageContext.headers
     {
         let headers;
@@ -35,18 +35,18 @@ function createPageContextServerSide(pageContextInit, globalContext, args) {
         else {
             headers = null;
         }
-        objectAssign(pageContextCreated, { headers });
+        objectAssign(pageContext, { headers });
     }
-    const pageContextAugmented = createPageContextShared(pageContextCreated, globalContext._globalConfigPublic);
-    updateType(pageContextCreated, pageContextAugmented);
-    return pageContextCreated;
+    const pageContextAugmented = createPageContextShared(pageContext, globalContext._globalConfigPublic);
+    updateType(pageContext, pageContextAugmented);
+    return pageContext;
 }
 /** Use this as last resort — prefer passing richer `pageContext` objects to the runtime logger */
 function createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId) {
-    const pageContext = createPageContext(pageContextInit, false, requestId);
+    const pageContext = createPageContextBase(pageContextInit, false, requestId);
     return pageContext;
 }
-function createPageContext(pageContextInit, isPrerendering, requestId) {
+function createPageContextBase(pageContextInit, isPrerendering, requestId) {
     const pageContext = createPageContextObject();
     objectAssign(pageContext, {
         isClientSide: false,

package/dist/server/runtime/renderPageServer/execHookOnError.d.ts

@@ -1,3 +1,3 @@
 export { execHookOnError };
-import type { PageContextCreatedServerMinimum } from './createPageContextServerSide.js';
-declare function execHookOnError(err: unknown, pageContext: PageContextCreatedServerMinimum | null): void;
+import type { PageContextCreatedServerBase } from './createPageContextServerSide.js';
+declare function execHookOnError(err: unknown, pageContext: PageContextCreatedServerBase | null): void;

package/dist/server/runtime/renderPageServer/execHookOnError.js

@@ -1,5 +1,6 @@
 export { execHookOnError };
 import { isObject, getGlobalObject } from '../../utils.js';
+import { execHookBase } from '../../../shared-server-client/hooks/execHook.js';
 import { getGlobalContextServerInternalOptional } from '../globalContext.js';
 import { getHookFromPageConfigGlobalCumulative } from '../../../shared-server-client/hooks/getHook.js';
 const globalObject = getGlobalObject('renderPageServer/execHookOnError.ts', {
@@ -17,7 +18,8 @@ function execHookOnError(err, pageContext) {
     const hooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onError');
     for (const hook of hooks) {
         try {
-            hook.hookFn(err, pageContext);
+            // TODO/refactor: stop using any
+            execHookBase(() => hook.hookFn(err, pageContext), hook, globalContext, pageContext);
         }
         catch (hookErr) {
             console.error(hookErr);

package/dist/server/runtime/renderPageServer/loadPageConfigsLazyServerSide.d.ts

@@ -21,10 +21,7 @@ declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPage
     isClientSide: false;
     isPrerendering: boolean;
     _requestId: number;
-} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-    url?: string;
-    headers?: Record<string, string>;
-} & {
+} & import("../renderPageServer.js").PageContextInit & {
     _globalContext: ({
         _globalConfigPublic: {
             pages: {

package/dist/server/runtime/renderPageServer/renderPageServerAfterRoute.d.ts

@@ -29,10 +29,7 @@ declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry
         isClientSide: false;
         isPrerendering: boolean;
         _requestId: number;
-    } & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-        url?: string;
-        headers?: Record<string, string>;
-    } & {
+    } & import("../renderPageServer.js").PageContextInit & {
         _globalContext: ({
             _globalConfigPublic: {
                 pages: {
@@ -193,10 +190,7 @@ declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry
         isClientSide: false;
         isPrerendering: boolean;
         _requestId: number;
-    } & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-        url?: string;
-        headers?: Record<string, string>;
-    } & {
+    } & import("../renderPageServer.js").PageContextInit & {
         _globalContext: ({
             _globalConfigPublic: {
                 pages: {
@@ -365,10 +359,7 @@ declare function prerenderPageEntry(pageContext: PageContextCreatedServer & Page
         isClientSide: false;
         isPrerendering: boolean;
         _requestId: number;
-    } & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-        url?: string;
-        headers?: Record<string, string>;
-    } & {
+    } & import("../renderPageServer.js").PageContextInit & {
         _globalContext: ({
             _globalConfigPublic: {
                 pages: {
@@ -529,10 +520,7 @@ declare function prerenderPageEntry(pageContext: PageContextCreatedServer & Page
         isClientSide: false;
         isPrerendering: boolean;
         _requestId: number;
-    } & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-        url?: string;
-        headers?: Record<string, string>;
-    } & {
+    } & import("../renderPageServer.js").PageContextInit & {
         _globalContext: ({
             _globalConfigPublic: {
                 pages: {

package/dist/server/runtime/renderPageServer.d.ts

@@ -5,12 +5,8 @@ import { type PageContextAborted } from '../../shared-server-client/route/abort.
 import { type GlobalContextServerInternal } from './globalContext.js';
 import { type HttpResponse } from './renderPageServer/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
-import type { PageContextInternalServer } from '../../types/PageContext.js';
+import type { PageContextInit } from '../../types/PageContext.js';
 import { type AsyncStore } from './asyncHook.js';
-type PageContextInit = Pick<PageContextInternalServer, 'urlOriginal' | 'headersOriginal'> & {
-    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
-    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
-};
 type PageContextBegin = ReturnType<typeof getPageContextBegin>;
 declare function renderPageServer<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInit>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
     httpResponse: HttpResponse;
@@ -22,10 +18,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
     isClientSide: false;
     isPrerendering: boolean;
     _requestId: number;
-} & Pick<PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
-    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
-} & {
+} & PageContextInit & {
     _globalContext: ({
         _globalConfigPublic: {
             pages: {

package/dist/shared-server-client/createGlobalContextShared.js

@@ -54,7 +54,7 @@ addGlobalContextTmp, addGlobalContextAsync) {
         let hooksCalled = false;
         if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {
             globalObject.onCreateGlobalContextHooks = onCreateGlobalContextHooks;
-            await execHookGlobal('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage);
+            await execHookGlobal('onCreateGlobalContext', globalContext, null, globalContext, prepareGlobalContextForPublicUsage);
             hooksCalled = true;
         }
         if (isNewGlobalContext) {

package/dist/shared-server-client/createPageContextShared.d.ts

@@ -1,8 +1,18 @@
 export { createPageContextShared };
 export { createPageContextObject };
+export type { PageContextCreated };
+export type { PageContextCreatedBase };
 import type { GlobalConfigPublic } from './page-configs/resolveVikeConfigPublic.js';
-import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
-declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, globalConfigPublic: GlobalConfigPublic): T & GlobalConfigPublic;
+import type { PageContextCreatedClient } from '../client/runtime-client-routing/createPageContextClientSide.js';
+import type { PageContextCreatedServer } from '../server/runtime/renderPageServer/createPageContextServerSide.js';
+import type { PageContextCreatedClient_ServerRouting } from '../client/runtime-server-routing/createPageContextClientSide.js';
+type PageContextCreated = PageContextCreatedServer | PageContextCreatedClient | PageContextCreatedClient_ServerRouting;
+type PageContextCreatedBase = {
+    _isOriginalObject: true;
+    isPageContext: true;
+    isClientSide: boolean;
+};
+declare function createPageContextShared<T extends Record<string, unknown>>(pageContextCreated: T, globalConfigPublic: GlobalConfigPublic): T & GlobalConfigPublic;
 declare function createPageContextObject(): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/shared-server-client/createPageContextShared.js

@@ -1,6 +1,7 @@
 export { createPageContextShared };
 export { createPageContextObject };
 import { changeEnumerable, objectAssign } from './utils.js';
+//*/
 function createPageContextShared(pageContextCreated, globalConfigPublic) {
     objectAssign(pageContextCreated, globalConfigPublic);
     return pageContextCreated;

package/dist/shared-server-client/getPageContextUrlComputed.d.ts

@@ -3,8 +3,9 @@ export type { PageContextUrlInternal };
 export type { PageContextUrlClient };
 export type { PageContextUrlServer };
 export type { PageContextUrlSource };
-import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
 import { type UrlPublic } from './utils.js';
+import type { GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+import type { PageContextCreatedBase } from './createPageContextShared.js';
 type PageContextUrlComputed = {
     /** Parsed information about the current URL */
     urlParsed: UrlPublic;
@@ -17,8 +18,10 @@ type PageContextUrl = {
     /** The URL of the HTTP request */
     urlOriginal: string;
 } & PageContextUrlComputed;
-type PageContextUrlInternal = PageContextPrepareMinimum & PageContextUrl & {
+type PageContextUrlInternal = PageContextUrl & {
     _urlRewrite?: string;
+} & PageContextCreatedBase & {
+    _globalContext: GlobalContextPrepareMinimum;
 };
 type PageContextUrlClient = PageContextUrl;
 type PageContextUrlServer = PageContextUrl & {

package/dist/shared-server-client/hooks/execHook.d.ts

@@ -5,6 +5,7 @@ export { execHookDirectSingle };
 export { execHookDirectSingleWithReturn };
 export { execHookDirectWithoutPageContext };
 export { execHookDirectSync };
+export { execHookBase };
 export { getPageContext_sync };
 export { providePageContext };
 export { isUserHookError };
@@ -13,32 +14,29 @@ import type { PageContextClient, PageContextServer } from '../../types/PageConte
 import type { Hook, HookLoc } from './getHook.js';
 import type { PageContextConfig } from '../getPageFiles.js';
 import type { HookName, HookNameGlobal } from '../../types/Config.js';
-import type { PageConfigGlobalRuntime } from '../../types/PageConfig.js';
+import type { PageContextCreated } from '../createPageContextShared.js';
 import type { PageContextForPublicUsageServer } from '../../server/runtime/renderPageServer/preparePageContextForPublicUsageServer.js';
 import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
 import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-import type { PageContextCreatedClient } from '../../client/runtime-client-routing/createPageContextClientSide.js';
-import type { PageContextCreatedServer } from '../../server/runtime/renderPageServer/createPageContextServerSide.js';
-import type { PageContextCreatedClient_ServerRouting } from '../../client/runtime-server-routing/createPageContextClientSide.js';
 type PageContextExecHook = PageContextCreated & PageContextConfig & PageContextForPublicUsage;
-type PageContextCreated = PageContextCreatedServer | PageContextCreatedClient | PageContextCreatedClient_ServerRouting;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;
 };
 declare function execHook<PageContext extends PageContextExecHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
-declare function execHookGlobal<HookArg extends GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
+declare function execHookGlobal<HookArg extends GlobalContextPrepareMinimum>(hookName: HookNameGlobal, globalContext: GlobalContextPrepareMinimum, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
 declare function execHookDirect<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
 declare function execHookDirectSingle<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
 declare function execHookDirectSingleWithReturn<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
     hookReturn: unknown;
 }>;
 declare function isUserHookError(err: unknown): false | HookLoc;
-declare function execHookDirectWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>): Promise<HookReturn>;
+declare function execHookDirectWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>, globalContext: GlobalContextPrepareMinimum): Promise<HookReturn>;
 declare function execHookDirectSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
     hookReturn: unknown;
 };
+declare function execHookBase<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookTimeout' | 'hookFn'>, globalContext: GlobalContextPrepareMinimum, pageContext: PageContextPrepareMinimum | null): HookReturn | Promise<HookReturn>;
 declare function getPageContext_sync<PageContext = PageContextClient | PageContextServer>(): null | PageContext;
 /**
  * Provide `pageContext` for universal hooks.

package/dist/shared-server-client/hooks/execHook.js

@@ -1,3 +1,4 @@
+// TODO: rename all exports
 export { execHook };
 export { execHookGlobal };
 export { execHookDirect };
@@ -5,10 +6,12 @@ export { execHookDirectSingle };
 export { execHookDirectSingleWithReturn };
 export { execHookDirectWithoutPageContext };
 export { execHookDirectSync };
+export { execHookBase };
 export { getPageContext_sync };
 export { providePageContext };
 export { isUserHookError };
-import { getProjectError, assertWarning, assertUsage } from '../../utils/assert.js';
+// TODO: minor refactor — maybe completely remove (some) utils.js files?
+import { assert, getProjectError, assertWarning, assertUsage } from '../../utils/assert.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { humanizeTime } from '../../utils/humanizeTime.js';
 import { isObject } from '../../utils/isObject.js';
@@ -18,15 +21,16 @@ const globalObject = getGlobalObject('utils/execHook.ts', {
     userHookErrors: new WeakMap(),
     pageContext: null,
 });
+// TODO/refactor: export new type PageContextExecHookMinimum instead of PageContextPrepareMinimum ?
 async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
     const hooks = getHookFromPageContextNew(hookName, pageContext);
     return await execHookDirect(hooks, pageContext, preparePageContextForPublicUsage);
 }
-async function execHookGlobal(hookName, pageConfigGlobal, pageContext, hookArg, prepareForPublicUsage) {
-    const hooks = getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName);
+async function execHookGlobal(hookName, globalContext, pageContext, hookArg, prepareForPublicUsage) {
+    const hooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, hookName);
     const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
     await Promise.all(hooks.map(async (hook) => {
-        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, globalContext, pageContext);
     }));
 }
 async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsage) {
@@ -34,7 +38,7 @@ async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsa
         return [];
     const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
     const hooksWithResult = await Promise.all(hooks.map(async (hook) => {
-        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
+        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContext._globalContext, pageContextForPublicUsage);
         return { ...hook, hookReturn };
     }));
     return hooksWithResult;
@@ -54,12 +58,12 @@ function isUserHookError(err) {
         return false;
     return globalObject.userHookErrors.get(err) ?? false;
 }
-async function execHookDirectWithoutPageContext(hookFnCaller, hook) {
+async function execHookDirectWithoutPageContext(hookFnCaller, hook, globalContext) {
     const { hookName, hookFilePath, hookTimeout } = hook;
-    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, globalContext, null);
     return hookReturn;
 }
-function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
+function execHookDirectAsync(hookFnCaller, hook, globalContext, pageContextForPublicUsage) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn }, } = hook;
     let resolve;
     let reject;
@@ -90,8 +94,7 @@ function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
         }, timeoutErr);
     (async () => {
         try {
-            providePageContextInternal(pageContextForPublicUsage);
-            const ret = await hookFnCaller();
+            const ret = await execHookBase(hookFnCaller, hook, globalContext, pageContextForPublicUsage);
             resolve(ret);
         }
         catch (err) {
@@ -105,10 +108,72 @@ function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
 }
 function execHookDirectSync(hook, pageContext, preparePageContextForPublicUsage) {
     const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
-    providePageContextInternal(pageContextForPublicUsage);
-    const hookReturn = hook.hookFn(pageContextForPublicUsage);
+    const hookReturn = execHookBase(() => hook.hookFn(pageContextForPublicUsage), hook, pageContext._globalContext, pageContextForPublicUsage);
     return { hookReturn };
 }
+// Every execHook* variant should call this
+function execHookBase(hookFnCaller, hook, globalContext, pageContext) {
+    const { hookName, hookFilePath } = hook;
+    assert(hookName !== 'onHookCall'); // ensure no infinite loop
+    const configValue = globalContext._pageConfigGlobal.configValues['onHookCall'];
+    const callOriginal = () => {
+        providePageContextInternal(pageContext);
+        return hookFnCaller();
+    };
+    // +onHookCall doesn't exist
+    if (!configValue?.value)
+        return callOriginal();
+    // +onHookCall wrapping
+    let originalCalled = false;
+    let originalReturn;
+    let originalError;
+    let call = () => {
+        originalCalled = true;
+        try {
+            originalReturn = callOriginal();
+        }
+        catch (err) {
+            originalError = err;
+        }
+        return originalReturn;
+    };
+    for (const onHookCall of configValue.value) {
+        const hookPublic = { name: hookName, filePath: hookFilePath, call };
+        // Recursively wrap callOriginal() so +onHookCall can use async hooks. (E.g. vike-react-sentry integrates Sentry's `Tracer.startActiveSpan()`.)
+        call = () => {
+            ;
+            (async () => {
+                try {
+                    await onHookCall(hookPublic, pageContext);
+                }
+                catch (err) {
+                    console.error(err);
+                    /* TO-DO/eventually: use dependency injection to be able to use logErrorServer() when this function runs on the server-side.
+                    if (
+                      !globalThis.__VIKE__IS_CLIENT &&
+                      pageContext &&
+                      // Avoid infinite loop
+                      hookName !== 'onError'
+                    ) {
+                      assert(!pageContext.isClientSide)
+                      logErrorServer(err, pageContext)
+                    } else {
+                      logErrorClient(err)
+                    }
+                    //*/
+                }
+            })();
+            // +onHookCall must run hook.call() before any `await` — https://github.com/vikejs/vike/pull/2978#discussion_r2645232953
+            assertUsage(originalCalled, 'onHookCall() must run hook.call()');
+            return originalReturn;
+        };
+    }
+    // Start the call() chain
+    call();
+    if (originalError)
+        throw originalError;
+    return originalReturn;
+}
 function isNotDisabled(timeout) {
     return !!timeout && timeout !== Infinity;
 }

package/dist/shared-server-client/prepareGlobalContextForPublicUsage.d.ts

@@ -1,8 +1,10 @@
 export { prepareGlobalContextForPublicUsage };
 export type { GlobalContextPrepareMinimum };
+import type { PageConfigGlobalRuntime } from '../types/PageConfig.js';
 type GlobalContextPrepareMinimum = {
     _isOriginalObject: true;
     isGlobalContext: true;
+    _pageConfigGlobal: PageConfigGlobalRuntime;
 };
 declare function prepareGlobalContextForPublicUsage<GlobalContext extends GlobalContextPrepareMinimum>(globalContext: GlobalContext): GlobalContext & {
     _isProxyObject: true;

package/dist/shared-server-client/preparePageContextForPublicUsage.d.ts

@@ -2,11 +2,10 @@ export { preparePageContextForPublicUsage };
 export { assertPropertyGetters };
 export type { PageContextPrepareMinimum };
 import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+import type { PageContextCreatedBase } from './createPageContextShared.js';
 type PageContextPrepareMinimum = {
-    _isOriginalObject: true;
-    isPageContext: true;
     _globalContext: GlobalContextPrepareMinimum;
-};
+} & PageContextCreatedBase;
 declare function preparePageContextForPublicUsage<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext & {
     _isProxyObject: true;
     _originalObject: PageContext;

package/dist/types/Config.d.ts

@@ -51,7 +51,7 @@ import type { ImportStringList } from '../node/vite/shared/importString.js';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
-type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext' | 'onError';
+type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext' | 'onError' | 'onHookCall';
 type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
 type ConfigNameBuiltIn = Exclude<keyof ConfigBuiltIn, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'hasServerOnlyHook' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'guardEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
@@ -361,6 +361,15 @@ type ConfigBuiltIn = {
      *  https://vike.dev/onCreateGlobalContext
      */
     onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportStringList | null;
+    /** Called whenever a hook is called.
+     *
+     *  https://vike.dev/onHookCall
+     */
+    onHookCall?: ((hook: {
+        name: HookName;
+        filePath: string;
+        call: () => void | Promise<void>;
+    }, pageContext: PageContextClient | PageContextServer | null) => void | Promise<void>) | ImportStringList;
     /** Hook for fetching data.
      *
      *  https://vike.dev/data

package/dist/types/Config.js

@@ -1 +1,2 @@
+// TODO: rename 'Hook called' Called
 export {};

package/dist/types/PageContext.d.ts

@@ -7,6 +7,7 @@ export type { PageContextInternalServer };
 export type { PageContextInternalClient };
 export type { PageContextInternalClient_ServerRouting };
 export type { PageContextInternalClient_ClientRouting };
+export type { PageContextInit };
 export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
@@ -56,29 +57,6 @@ type PageContextBuiltInCommon<Data> = PageContextConfig & {
      * https://vike.dev/pageContext#data
      */
     data: Data;
-    /** The URL you provided to Vike when calling `renderPage({ urlOriginal })` in your server middleware.
-     *
-     * https://vike.dev/renderPage
-     */
-    urlOriginal: string;
-    /**
-     * The HTTP request headers.
-     *
-     * As a string object normalized by Vike.
-     *
-     * https://vike.dev/headers
-     * https://vike.dev/pageContext#headers
-     */
-    headers: Record<string, string> | null;
-    /**
-     * The HTTP request headers.
-     *
-     * The original object provided by the server.
-     *
-     * https://vike.dev/headers
-     * https://vike.dev/pageContext#headersOriginal
-     */
-    headersOriginal?: unknown;
     /**
      * The HTTP response headers.
      *
@@ -128,8 +106,6 @@ type PageContextBuiltInCommon<Data> = PageContextConfig & {
     /** @experimental https://github.com/vikejs/vike/issues/1268 */
     sources: Sources;
     /** @deprecated */
-    url: string;
-    /** @deprecated */
     pageExports: Record<string, unknown>;
     /**
      * Whether the Base URL is missing in the URL of the HTTP request made to the SSR server.
@@ -139,7 +115,34 @@ type PageContextBuiltInCommon<Data> = PageContextConfig & {
      */
     isBaseMissing?: true;
 };
-type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer & {
+type PageContextInit = {
+    /** The URL provided when `renderPage({ urlOriginal })` is called.
+     *
+     * https://vike.dev/renderPage
+     */
+    urlOriginal: string;
+    /**
+     * The HTTP request headers.
+     *
+     * The original object provided by the server.
+     *
+     * https://vike.dev/headers
+     * https://vike.dev/pageContext#headersOriginal
+     */
+    headersOriginal?: unknown;
+    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
+    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
+};
+type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextInit & PageContextUrlServer & {
+    /**
+     * The HTTP request headers.
+     *
+     * As a string object normalized by Vike.
+     *
+     * https://vike.dev/headers
+     * https://vike.dev/pageContext#headers
+     */
+    headers: Record<string, string> | null;
     /**
      * Whether the environment is the client-side:
      * - In the browser, the value is `true`.
@@ -182,6 +185,10 @@ type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageConte
     previousPageContext?: undefined;
 };
 type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'pageId' | 'source' | 'sources' | 'from'> & PageContextClientCommon & {
+    /**
+     * The current URL unprocessed (e.g. with the Base URL).
+     */
+    urlOriginal: string;
     /**
      * Whether the page is the first page rendered.
      *

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.250-commit-193dea3";
+export declare const PROJECT_VERSION: "0.4.250-commit-6161324";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.250-commit-193dea3';
+export const PROJECT_VERSION = '0.4.250-commit-6161324';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.250-commit-193dea3",
+  "version": "0.4.250-commit-6161324",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {