vike 0.4.250-commit-2686732 → 0.4.250-commit-7552006

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

@@ -1,5 +1,6 @@
 export { addIs404ToPageProps };
-import { assertWarning, isObject } from './utils.js';
+import { assertWarning } from '../utils/assert.js';
+import { isObject } from '../utils/isObject.js';
 function addIs404ToPageProps(pageContext) {
     addIs404(pageContext);
 }

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

@@ -1,5 +1,6 @@
 export { assertHookReturnedObject };
-import { assert, assertUsage, stringifyStringArray } from './utils.js';
+import { assert, assertUsage } from '../utils/assert.js';
+import { stringifyStringArray } from '../utils/stringifyStringArray.js';
 function assertHookReturnedObject(obj, keysExpected, errPrefix) {
     assert(!errPrefix.endsWith(' '));
     const keysUnknown = [];

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

@@ -1,5 +1,6 @@
 export { assertOnBeforeRenderHookReturn };
-import { assertUsage, isPlainObject } from './utils.js';
+import { assertUsage } from '../utils/assert.js';
+import { isPlainObject } from '../utils/isPlainObject.js';
 import { assertPageContextProvidedByUser } from './assertPageContextProvidedByUser.js';
 import { assertHookReturnedObject } from './assertHookReturnedObject.js';
 import pc from '@brillout/picocolors';

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

@@ -1,5 +1,6 @@
 export { assertPageContextProvidedByUser };
-import { assert, assertUsage, assertWarning, isObject } from './utils.js';
+import { assert, assertUsage, assertWarning } from '../utils/assert.js';
+import { isObject } from '../utils/isObject.js';
 import pc from '@brillout/picocolors';
 function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName, hookFilePath, }) {
     if (pageContextProvidedByUser === undefined || pageContextProvidedByUser === null)

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

@@ -1,5 +1,5 @@
 export { assertVirtualFileExports };
-import { assert } from './utils.js';
+import { assert } from '../utils/assert.js';
 function assertVirtualFileExports(moduleExports, test, moduleId) {
     if (!moduleExports || !test(moduleExports)) {
         /* https://github.com/vikejs/vike/issues/2903#issuecomment-3642285811

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

@@ -5,14 +5,14 @@ export type { GlobalContextBasePublic };
 export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextClientInternal;
 import type { PageFile } from './getPageFiles.js';
 import type { PageConfigRuntime } from '../types/PageConfig.js';
-import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+import { type GlobalContextPublicMinimum } from './getGlobalContextPublicShared.js';
 import type { GlobalContextServerInternal } from '../server/runtime/globalContext.js';
 import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
 import { type Hook } from './hooks/getHook.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 declare function createGlobalContextShared<GlobalContextAdded extends {}, GlobalContextAddedAsync extends {}>(virtualFileExportsGlobalEntry: unknown, globalObject: {
     globalContext?: {};
-    onCreateGlobalContextHooks?: Hook<GlobalContextPrepareMinimum>[];
+    onCreateGlobalContextHooks?: Hook<GlobalContextPublicMinimum>[];
     previousCreateGlobalContextPromise?: Promise<void>;
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
     _globalConfigPublic: {

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

@@ -1,11 +1,16 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
-import { assert, changeEnumerable, genPromise, objectAssign, objectReplace, unique } from './utils.js';
+import { assert } from '../utils/assert.js';
+import { objectReplace } from '../utils/objectReplace.js';
+import { changeEnumerable } from '../utils/changeEnumerable.js';
+import { genPromise } from '../utils/genPromise.js';
+import { objectAssign } from '../utils/objectAssign.js';
+import { unique } from '../utils/unique.js';
 import { parseVirtualFileExportsGlobalEntry } from './getPageFiles/parseVirtualFileExportsGlobalEntry.js';
 import { resolveGlobalContextConfig } from './page-configs/resolveVikeConfigPublic.js';
 import { execHookGlobal } from './hooks/execHook.js';
-import { prepareGlobalContextForPublicUsage, } from './prepareGlobalContextForPublicUsage.js';
-import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
+import { getGlobalContextPublicShared } from './getGlobalContextPublicShared.js';
+import { getHooksFromPageConfigGlobalCumulative } from './hooks/getHook.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 // TO-DO/eventually use flat globalContext — like flat pageContext
 async function createGlobalContextShared(virtualFileExportsGlobalEntry, globalObject, addGlobalContext, 
@@ -50,11 +55,11 @@ addGlobalContextTmp, addGlobalContextAsync) {
             const globalContextAddedAsync = await addGlobalContextAsync?.(globalContext);
             objectAssign(globalContext, globalContextAddedAsync);
         }
-        const onCreateGlobalContextHooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
+        const onCreateGlobalContextHooks = getHooksFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
         let hooksCalled = false;
         if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {
             globalObject.onCreateGlobalContextHooks = onCreateGlobalContextHooks;
-            await execHookGlobal('onCreateGlobalContext', globalContext, null, globalContext, prepareGlobalContextForPublicUsage);
+            await execHookGlobal('onCreateGlobalContext', globalContext, getGlobalContextPublicShared);
             hooksCalled = true;
         }
         if (isNewGlobalContext) {

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.