vike 0.4.250-commit-2686732 → 0.4.250-commit-0d50da9

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

@@ -1,16 +1,13 @@
 export { createPageContextShared };
 export { createPageContextObject };
 export type { PageContextCreated };
-export type { PageContextCreatedBase };
 import type { GlobalConfigPublic } from './page-configs/resolveVikeConfigPublic.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 PageContextCreated = PageContextCreatedServer | PageContextCreatedClient | PageContextCreatedClient_ServerRouting;
-type PageContextCreatedBase = {
+import type { GlobalContextPublicMinimum } from './getGlobalContextPublicShared.js';
+type PageContextCreated = {
     _isOriginalObject: true;
     isPageContext: true;
     isClientSide: boolean;
+    _globalContext: GlobalContextPublicMinimum;
 };
 declare function createPageContextShared<T extends Record<string, unknown>>(pageContextCreated: T, globalConfigPublic: GlobalConfigPublic): T & GlobalConfigPublic;
 declare function createPageContextObject(): {

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

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

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

@@ -1,5 +1,6 @@
 export { determinePageIdOld };
-import { slice, assert } from './utils.js';
+import { assert } from '../utils/assert.js';
+import { slice } from '../utils/slice.js';
 // TO-DO/next-major-release: remove
 function determinePageIdOld(filePath) {
     const pageSuffix = '.page.';

package/dist/shared-server-client/error-page.js

@@ -2,7 +2,8 @@ export { getErrorPageId };
 export { isErrorPageId };
 export { isErrorPage };
 // TO-DO/next-major-release: consider loading this file only for Client Routing
-import { assert, assertUsage, unique } from './utils.js';
+import { assert, assertUsage } from '../utils/assert.js';
+import { unique } from '../utils/unique.js';
 function getErrorPageId(pageFilesAll, pageConfigs) {
     if (pageConfigs.length > 0) {
         const errorPageConfigs = pageConfigs.filter((p) => p.isErrorPage);

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

@@ -1,5 +1,5 @@
 export { forkPageContext };
-import { objectAssign } from './utils.js';
+import { objectAssign } from '../utils/objectAssign.js';
 // Create pageContext forks to avoid leaks: upon an error (bug or abort) a brand new pageContext object is created, in order to avoid previous pageContext modifications that are now obsolete to leak to the new pageContext object.
 function forkPageContext(pageContext) {
     const pageContextNew = {};

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

@@ -0,0 +1,14 @@
+export { getGlobalContextPublicShared };
+export type { GlobalContextPublicMinimum };
+import type { PageConfigGlobalRuntime } from '../types/PageConfig.js';
+type GlobalContextPublicMinimum = {
+    _isOriginalObject: true;
+    isGlobalContext: true;
+    _pageConfigGlobal: PageConfigGlobalRuntime;
+};
+declare function getGlobalContextPublicShared<GlobalContext extends GlobalContextPublicMinimum>(globalContext: GlobalContext): GlobalContext & {
+    _isProxyObject: true;
+    _originalObject: GlobalContext;
+} & {
+    dangerouslyUseInternals: import("./getPublicProxy.js").DangerouslyUseInternals<GlobalContext>;
+};

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

@@ -0,0 +1,8 @@
+export { getGlobalContextPublicShared };
+import { getPublicProxy } from './getPublicProxy.js';
+import { assert } from '../utils/assert.js';
+function getGlobalContextPublicShared(globalContext) {
+    assert(globalContext._isOriginalObject); // ensure we preserve the original object reference
+    const globalContextPublic = getPublicProxy(globalContext, 'globalContext');
+    return globalContextPublic;
+}

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

@@ -0,0 +1,12 @@
+export { getPageContextPublicShared };
+export { assertPropertyGetters };
+export type { PageContextPublicMinimum };
+import type { PageContextCreated } from './createPageContextShared.js';
+type PageContextPublicMinimum = PageContextCreated;
+declare function getPageContextPublicShared<PageContext extends PageContextPublicMinimum>(pageContext: PageContext): PageContext & {
+    _isProxyObject: true;
+    _originalObject: PageContext;
+} & {
+    dangerouslyUseInternals: import("./getPublicProxy.js").DangerouslyUseInternals<PageContext>;
+};
+declare function assertPropertyGetters(pageContext: Record<string, unknown>): void;

package/dist/shared-server-client/{preparePageContextForPublicUsage.js → getPageContextPublicShared.js}

@@ -1,10 +1,12 @@
-export { preparePageContextForPublicUsage };
+export { getPageContextPublicShared };
 export { assertPropertyGetters };
-import { assert, assertWarning, compareString, isPropertyGetter } from './utils.js';
+import { assert, assertWarning } from '../utils/assert.js';
+import { compareString } from '../utils/compareString.js';
+import { isPropertyGetter } from '../utils/isPropertyGetter.js';
 import { addIs404ToPageProps } from './addIs404ToPageProps.js';
-import { prepareGlobalContextForPublicUsage, } from './prepareGlobalContextForPublicUsage.js';
-import { getProxyForPublicUsage } from './getProxyForPublicUsage.js';
-function preparePageContextForPublicUsage(pageContext) {
+import { getGlobalContextPublicShared } from './getGlobalContextPublicShared.js';
+import { getPublicProxy } from './getPublicProxy.js';
+function getPageContextPublicShared(pageContext) {
     assert(!pageContext._isProxyObject);
     assert(!pageContext.globalContext); // pageContext.globalContext should only be available to users — Vike itself should use pageContext._globalContext instead
     assert(pageContext._isOriginalObject); // ensure we preserve the original object reference
@@ -24,8 +26,8 @@ function preparePageContextForPublicUsage(pageContext) {
     }
     // For a more readable `console.log(pageContext)` output
     sortPageContext(pageContext);
-    const globalContextPublic = prepareGlobalContextForPublicUsage(pageContext._globalContext);
-    const pageContextPublic = getProxyForPublicUsage(pageContext, 'pageContext', 
+    const globalContextPublic = getGlobalContextPublicShared(pageContext._globalContext);
+    const pageContextPublic = getPublicProxy(pageContext, 'pageContext', 
     // We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
     // - TO-DO/soon/proxy: double check whether that's true
     true, (prop) => {

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

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

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

@@ -4,8 +4,11 @@ export { getPageContextUrlComputed };
 // URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
 // =====================
 import { objectDefineProperty } from '../utils/objectDefineProperty.js';
-import { assertPropertyGetters } from './preparePageContextForPublicUsage.js';
-import { assert, parseUrl, assertWarning, isBrowser, changeEnumerable } from './utils.js';
+import { assertPropertyGetters } from './getPageContextPublicShared.js';
+import { assert, assertWarning } from '../utils/assert.js';
+import { changeEnumerable } from '../utils/changeEnumerable.js';
+import { isBrowser } from '../utils/isBrowser.js';
+import { parseUrl } from '../utils/parseUrl.js';
 function getPageContextUrlComputed(pageContext) {
     assert(typeof pageContext.urlOriginal === 'string');
     assertPropertyGetters(pageContext);

package/dist/shared-server-client/getPageFiles/analyzePageClientSide/analyzeExports.js

@@ -1,6 +1,6 @@
 export { analyzeExports };
 import { getExportNames } from './getExportNames.js';
-import { assertUsage } from '../../utils.js';
+import { assertUsage } from '../../../utils/assert.js';
 // TO-DO/next-major-release: remove
 function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId, }) {
     return { isHtmlOnly: isHtmlOnly(), isClientRouting: isClientRouting() };

package/dist/shared-server-client/getPageFiles/analyzePageClientSide/getExportNames.js

@@ -1,5 +1,5 @@
 export { getExportNames };
-import { assert } from '../../utils.js';
+import { assert } from '../../../utils/assert.js';
 function getExportNames(p) {
     if (p.fileType === '.css') {
         return [];

package/dist/shared-server-client/getPageFiles/analyzePageClientSide.js

@@ -4,7 +4,7 @@ import { analyzeExports } from './analyzePageClientSide/analyzeExports.js';
 import { determineClientEntry } from './analyzePageClientSide/determineClientEntry.js';
 import { getPageFilesClientSide } from './getAllPageIdFiles.js';
 import { getPageFilesServerSide } from './getAllPageIdFiles.js';
-import { assert } from '../utils.js';
+import { assert } from '../../utils/assert.js';
 import { getExportNames } from './analyzePageClientSide/getExportNames.js';
 // TO-DO/next-major-release: remove analyzePageClientSide(), use analyzeClientSide() instead
 function analyzePageClientSide(pageFilesAll, pageId) {

package/dist/shared-server-client/getPageFiles/analyzePageServerSide.js

@@ -1,5 +1,5 @@
 export { analyzePageServerSide };
-import { assert } from '../utils.js';
+import { assert } from '../../utils/assert.js';
 import { getPageFilesServerSide } from './getAllPageIdFiles.js';
 async function analyzePageServerSide(pageFilesAll, pageId) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);

package/dist/shared-server-client/getPageFiles/assert_exports_old_design.js

@@ -2,7 +2,7 @@
 export { assertDefaultExports };
 export { assertExportValues };
 export { forbiddenDefaultExports };
-import { assert, assertUsage } from '../utils.js';
+import { assert, assertUsage } from '../../utils/assert.js';
 const enforceTrue = ['clientRouting'];
 function assertExportValues(pageFile) {
     enforceTrue.forEach((exportName) => {

package/dist/shared-server-client/getPageFiles/fileTypes.js

@@ -2,7 +2,7 @@
 export { fileTypes };
 export { isValidFileType };
 export { determineFileType };
-import { assert } from '../utils.js';
+import { assert } from '../../utils/assert.js';
 import { isScriptFile } from '../../utils/isScriptFile.js';
 const fileTypes = [
     '.page',

package/dist/shared-server-client/getPageFiles/getAllPageIdFiles.js

@@ -1,7 +1,8 @@
 // TO-DO/next-major-release: remove this file
 export { getPageFilesClientSide };
 export { getPageFilesServerSide };
-import { assert, assertUsage, isNotNullish } from '../utils.js';
+import { assert, assertUsage } from '../../utils/assert.js';
+import { isNotNullish } from '../../utils/isNullish.js';
 function getPageFilesClientSide(pageFilesAll, pageId) {
     return determine(pageFilesAll, pageId, true);
 }

package/dist/shared-server-client/getPageFiles/getPageFileObject.js

@@ -2,7 +2,8 @@
 export { getPageFileObject };
 import { determinePageIdOld } from '../determinePageIdOld.js';
 import { isErrorPageId } from '../error-page.js';
-import { assert, slice } from '../utils.js';
+import { assert } from '../../utils/assert.js';
+import { slice } from '../../utils/slice.js';
 import { determineFileType } from './fileTypes.js';
 function getPageFileObject(filePath) {
     const isRelevant = (pageId) => pageFile.pageId === pageId ||

package/dist/shared-server-client/getPageFiles/parseVirtualFileExportsGlobalEntry.js

@@ -1,6 +1,11 @@
 export { parseVirtualFileExportsGlobalEntry };
 // TO-DO/next-major-release: remove old design code, and remove all assertions.
-import { assert, hasProp, isCallable, isObject, cast, isArray } from '../utils.js';
+import { assert } from '../../utils/assert.js';
+import { cast } from '../../utils/cast.js';
+import { hasProp } from '../../utils/hasProp.js';
+import { isArray } from '../../utils/isArray.js';
+import { isCallable } from '../../utils/isCallable.js';
+import { isObject } from '../../utils/isObject.js';
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';

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

@@ -0,0 +1,12 @@
+export { getPublicProxy };
+export type { DangerouslyUseInternals };
+type ObjProxy<Obj> = {
+    _isProxyObject: true;
+    _originalObject: Obj;
+};
+declare function getPublicProxy<Obj extends Record<string | symbol, unknown>>(obj: Obj, objName: 'pageContext' | 'globalContext' | 'prerenderContext' | 'vikeConfig', skipOnInternalProp?: boolean, fallback?: (prop: string | symbol) => unknown): Obj & ObjProxy<Obj> & {
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: DangerouslyUseInternals<Obj>;
+};
+/** https://vike.dev/warning/internals */
+type DangerouslyUseInternals<Obj> = ObjProxy<Obj>;

package/dist/shared-server-client/{getProxyForPublicUsage.js → getPublicProxy.js}

@@ -1,4 +1,4 @@
-export { getProxyForPublicUsage };
+export { getPublicProxy };
 // We use a proxy instead of property getters.
 // - The issue with property getters is that they can't be `writable: true` but we do want the user to be able to modify the value of internal properties.
 //   ```console
@@ -7,8 +7,10 @@ export { getProxyForPublicUsage };
 // - Previous implementation using property getters: https://github.com/vikejs/vike/blob/4dbb354b0bcec04e862041fc9183fc4691bb8711/vike/utils/makePublicCopy.ts
 // Show warning when user is accessing internal `_` properties.
 import { NOT_SERIALIZABLE } from './NOT_SERIALIZABLE.js';
-import { assert, assertUsage, assertWarning, getPropAccessNotation, isBrowser } from './utils.js';
-function getProxyForPublicUsage(obj, objName, skipOnInternalProp, fallback) {
+import { assert, assertUsage, assertWarning } from '../utils/assert.js';
+import { getPropAccessNotation } from '../utils/getPropAccessNotation.js';
+import { isBrowser } from '../utils/isBrowser.js';
+function getPublicProxy(obj, objName, skipOnInternalProp, fallback) {
     return new Proxy(obj, {
         get: (_, prop) => getProp(prop, obj, objName, skipOnInternalProp, fallback),
     });
@@ -19,8 +21,8 @@ function getProp(prop, ...args) {
     if (prop === '_isProxyObject')
         return true;
     if (prop === 'dangerouslyUseInternals') {
-        args[2] = true;
-        return getProxyForPublicUsage(...args);
+        args[2] = true; // skipOnInternalProp
+        return getPublicProxy(...args);
     }
     if (!skipOnInternalProp) {
         if (!globalThis.__VIKE__IS_CLIENT)

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

@@ -1,11 +1,10 @@
 export { execHook };
 export { execHookGlobal };
-export { execHookDirect };
-export { execHookDirectSingle };
-export { execHookDirectSingleWithReturn };
-export { execHookDirectWithoutPageContext };
-export { execHookDirectSync };
-export { execHookBase };
+export { execHookList };
+export { execHookSingle };
+export { execHookSingleSync };
+export { execHookSingleWithReturn };
+export { execHookSingleWithoutPageContext };
 export { getPageContext_sync };
 export { providePageContext };
 export { isUserHookError };
@@ -14,29 +13,24 @@ 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 { 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';
-type PageContextExecHook = PageContextCreated & PageContextConfig & PageContextForPublicUsage;
-type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
+import { type PageContextPublicMinimum } from '../getPageContextPublicShared.js';
+import type { GlobalContextPublicMinimum } from '../getGlobalContextPublicShared.js';
 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, 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<{
+type PageContextExecHook = PageContextPublicMinimum;
+declare function execHook<PageContext extends PageContextExecHook & PageContextConfig>(hookName: HookName, pageContext: PageContext, getPageContextPublic: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookGlobal(hookName: HookNameGlobal, globalContext: GlobalContextPublicMinimum, getGlobalContextPublic: (globalContext: GlobalContextPublicMinimum) => GlobalContextPublicMinimum): Promise<void>;
+declare function execHookList<PageContext extends PageContextExecHook>(hooks: Hook[], pageContext: PageContext, getPageContextPublic: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookSingle<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, getPageContextPublic: (pageContext: PageContext) => PageContext): Promise<void>;
+declare function execHookSingleWithReturn<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, getPageContextPublic: (pageContext: PageContext) => PageContext): Promise<{
     hookReturn: unknown;
 }>;
 declare function isUserHookError(err: unknown): false | HookLoc;
-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): {
+declare function execHookSingleWithoutPageContext<HookReturn>(hook: Omit<Hook, 'hookFn'>, globalContext: GlobalContextPublicMinimum, hookFnCaller: () => HookReturn): Promise<HookReturn>;
+declare function execHookSingleSync<PageContext extends PageContextExecHook>(hook: Omit<Hook<PageContext>, 'hookTimeout'>, globalContext: GlobalContextPublicMinimum, pageContext: PageContext | null, getPageContextPublic: (pageContext: PageContext) => PageContext, hookFnCaller?: () => unknown): {
     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,55 +1,51 @@
-// TODO: rename all exports
 export { execHook };
 export { execHookGlobal };
-export { execHookDirect };
-export { execHookDirectSingle };
-export { execHookDirectSingleWithReturn };
-export { execHookDirectWithoutPageContext };
-export { execHookDirectSync };
-export { execHookBase };
+export { execHookList };
+export { execHookSingle };
+export { execHookSingleSync };
+export { execHookSingleWithReturn };
+export { execHookSingleWithoutPageContext };
 export { getPageContext_sync };
 export { providePageContext };
 export { isUserHookError };
-// 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';
-import { getHookFromPageConfigGlobalCumulative, getHookFromPageContextNew } from './getHook.js';
-import { preparePageContextForPublicUsage, } from '../preparePageContextForPublicUsage.js';
+import { getHooksFromPageConfigGlobalCumulative, getHooksFromPageContextNew } from './getHook.js';
+import { getPageContextPublicShared } from '../getPageContextPublicShared.js';
 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 execHook(hookName, pageContext, getPageContextPublic) {
+    const hooks = getHooksFromPageContextNew(hookName, pageContext);
+    return await execHookList(hooks, pageContext, getPageContextPublic);
 }
-async function execHookGlobal(hookName, globalContext, pageContext, hookArg, prepareForPublicUsage) {
-    const hooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, hookName);
-    const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
+async function execHookGlobal(hookName, globalContext, getGlobalContextPublic) {
+    const hooks = getHooksFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, hookName);
+    const globalContextPublic = getGlobalContextPublic(globalContext);
     await Promise.all(hooks.map(async (hook) => {
-        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, globalContext, pageContext);
+        await execHookBaseAsync(() => hook.hookFn(globalContextPublic), hook, globalContext, null);
     }));
 }
-async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsage) {
+async function execHookList(hooks, pageContext, getPageContextPublic) {
     if (!hooks.length)
         return [];
-    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    const pageContextPublic = getPageContextPublic(pageContext);
     const hooksWithResult = await Promise.all(hooks.map(async (hook) => {
-        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContext._globalContext, pageContextForPublicUsage);
+        const hookReturn = await execHookBaseAsync(() => hook.hookFn(pageContextPublic), hook, pageContext._globalContext, pageContextPublic);
         return { ...hook, hookReturn };
     }));
     return hooksWithResult;
 }
-async function execHookDirectSingle(hook, pageContext, preparePageContextForPublicUsage) {
-    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+async function execHookSingle(hook, pageContext, getPageContextPublic) {
+    const hooksWithResult = await execHookList([hook], pageContext, getPageContextPublic);
     const { hookReturn } = hooksWithResult[0];
     assertUsage(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
 }
-async function execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
-    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+async function execHookSingleWithReturn(hook, pageContext, getPageContextPublic) {
+    const hooksWithResult = await execHookList([hook], pageContext, getPageContextPublic);
     const { hookReturn } = hooksWithResult[0];
     return { hookReturn };
 }
@@ -58,12 +54,18 @@ function isUserHookError(err) {
         return false;
     return globalObject.userHookErrors.get(err) ?? false;
 }
-async function execHookDirectWithoutPageContext(hookFnCaller, hook, globalContext) {
+async function execHookSingleWithoutPageContext(hook, globalContext, hookFnCaller) {
     const { hookName, hookFilePath, hookTimeout } = hook;
-    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, globalContext, null);
+    const hookReturn = await execHookBaseAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, globalContext, null);
     return hookReturn;
 }
-function execHookDirectAsync(hookFnCaller, hook, globalContext, pageContextForPublicUsage) {
+function execHookSingleSync(hook, globalContext, pageContext, getPageContextPublic, hookFnCaller) {
+    const pageContextPublic = pageContext && getPageContextPublic(pageContext);
+    hookFnCaller ?? (hookFnCaller = () => hook.hookFn(pageContextPublic));
+    const hookReturn = execHookBase(hookFnCaller, hook, globalContext, pageContextPublic);
+    return { hookReturn };
+}
+function execHookBaseAsync(hookFnCaller, hook, globalContext, pageContextPublic) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn }, } = hook;
     let resolve;
     let reject;
@@ -94,7 +96,7 @@ function execHookDirectAsync(hookFnCaller, hook, globalContext, pageContextForPu
         }, timeoutErr);
     (async () => {
         try {
-            const ret = await execHookBase(hookFnCaller, hook, globalContext, pageContextForPublicUsage);
+            const ret = await execHookBase(hookFnCaller, hook, globalContext, pageContextPublic);
             resolve(ret);
         }
         catch (err) {
@@ -106,12 +108,7 @@ function execHookDirectAsync(hookFnCaller, hook, globalContext, pageContextForPu
     })();
     return promise;
 }
-function execHookDirectSync(hook, pageContext, preparePageContextForPublicUsage) {
-    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
-    const hookReturn = execHookBase(() => hook.hookFn(pageContextForPublicUsage), hook, pageContext._globalContext, pageContextForPublicUsage);
-    return { hookReturn };
-}
-// Every execHook* variant should call this
+// Every execHook* function should be based on this
 function execHookBase(hookFnCaller, hook, globalContext, pageContext) {
     const { hookName, hookFilePath } = hook;
     assert(hookName !== 'onHookCall'); // ensure no infinite loop
@@ -134,6 +131,7 @@ function execHookBase(hookFnCaller, hook, globalContext, pageContext) {
         }
         catch (err) {
             originalError = err;
+            throw err;
         }
         return originalReturn;
     };
@@ -147,20 +145,22 @@ function execHookBase(hookFnCaller, hook, globalContext, pageContext) {
                     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)
+                    if (err !== originalError) {
+                        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
@@ -181,11 +181,11 @@ function getPageContext_sync() {
     const { pageContext } = globalObject;
     if (!pageContext)
         return null;
-    const pageContextForPublicUsage = pageContext._isProxyObject
+    const pageContextPublic = pageContext._isProxyObject
         ? // providePageContext() is called on the user-land (e.g. it's called by `vike-{react,vue,solid}`) thus it's already a proxy
             pageContext
-        : preparePageContextForPublicUsage(pageContext);
-    return pageContextForPublicUsage;
+        : getPageContextPublicShared(pageContext);
+    return pageContextPublic;
 }
 /**
  * Provide `pageContext` for universal hooks.

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

@@ -1,8 +1,8 @@
 export { getHookFromPageContext };
-export { getHookFromPageContextNew };
+export { getHooksFromPageContextNew };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
-export { getHookFromPageConfigGlobalCumulative };
+export { getHooksFromPageConfigGlobalCumulative };
 export { getHook_setIsPrerenderering };
 export type { Hook };
 export type { HookLoc };
@@ -12,9 +12,9 @@ export { getHookTimeoutDefault };
 import type { PageContextConfig } from '../getPageFiles.js';
 import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../../types/Config.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
-import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-import type { PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
-type HookArgDefault = PageContextPrepareMinimum;
+import type { GlobalContextPublicMinimum } from '../getGlobalContextPublicShared.js';
+import type { PageContextPublicMinimum } from '../getPageContextPublicShared.js';
+type HookArgDefault = PageContextPublicMinimum;
 type Hook<HookArg = HookArgDefault> = HookLoc & {
     hookFn: HookFn<HookArg>;
     hookTimeout: HookTimeout;
@@ -30,9 +30,9 @@ type HookTimeout = {
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookNameOld, false | Partial<HookTimeout>>>;
 declare function getHookFromPageContext(pageContext: PageContextConfig, hookName: HookNameOld): null | Hook;
-declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageContextConfig): Hook[];
+declare function getHooksFromPageContextNew(hookName: HookName, pageContext: PageContextConfig): Hook[];
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
-declare function getHookFromPageConfigGlobalCumulative<HookArg = GlobalContextPrepareMinimum>(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook<HookArg>[];
+declare function getHooksFromPageConfigGlobalCumulative<HookArg = GlobalContextPublicMinimum>(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook<HookArg>[];
 declare function getHookTimeoutDefault(hookName: HookNameOld): HookTimeout;
 declare function getHook_setIsPrerenderering(): void;