vike 0.4.250-commit-193dea3 → 0.4.250-commit-2686732

package/dist/node/prerender/runPrerender.d.ts

@@ -72,10 +72,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     isClientSide: false;
     isPrerendering: boolean;
     _requestId: number;
-} & Pick<import("../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-    url?: string;
-    headers?: Record<string, string>;
-} & {
+} & import("../../types/PageContext.js").PageContextInit & {
     _globalContext: ({
         _globalConfigPublic: {
             pages: {
@@ -170,7 +167,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _pageFilesAll: PageFile[];
     _baseServer: string;
     _baseAssets: string;
-    _pageContextInit: import("../../server/runtime/renderPageServer.js").PageContextInit;
+    _pageContextInit: import("../../types/PageContext.js").PageContextInit;
     _urlHandler: ((url: string) => string) | null;
     isClientSideNavigation: boolean;
 } & {

package/dist/node/prerender/runPrerender.js

@@ -45,7 +45,7 @@ async function runPrerender(options = {}, trigger) {
     const viteConfig = await resolveViteConfig(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await getVikeConfigInternal();
     const { outDirServer } = getOutDirs(viteConfig, undefined);
-    const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
+    const prerenderConfigGlobal = await resolvePrerenderConfigGlobal(vikeConfig);
     const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
     if (!isPrerenderingEnabled) {
         assert(trigger !== 'auto-run');
@@ -117,8 +117,8 @@ async function runPrerender(options = {}, trigger) {
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext) {
     // V1 design
-    pageConfigs.forEach((pageConfig) => {
-        const prerenderConfigLocal = resolvePrerenderConfigLocal(pageConfig);
+    await Promise.all(pageConfigs.map(async (pageConfig) => {
+        const prerenderConfigLocal = await resolvePrerenderConfigLocal(pageConfig);
         const { pageId } = pageConfig;
         if (!prerenderConfigLocal) {
             if (!defaultLocalValue) {
@@ -131,7 +131,7 @@ async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, default
                 doNotPrerenderList.push({ pageId });
             }
         }
-    });
+    }));
     // Old design
     // TO-DO/next-major-release: remove
     await Promise.all(globalContext._pageFilesAll
@@ -218,7 +218,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
         const { hookName, hookFilePath } = hook;
-        const prerenderResult = await execHookDirectWithoutPageContext(() => hook.hookFn(), hook);
+        const prerenderResult = await execHookDirectWithoutPageContext(() => hook.hookFn(), hook, globalContext);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
@@ -446,7 +446,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         preservePropertyGetters(pageContext);
     });
     const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
-    let result = await execHookDirectWithoutPageContext(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
+    let result = await execHookDirectWithoutPageContext(() => hookFn(prerenderContextPublic), onPrerenderStartHook, globalContext);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;

package/dist/node/vite/onLoad.js

@@ -4,11 +4,12 @@ import { assertIsNotProductionRuntime, markSetup_vikeVitePlugin } from '../../ut
 import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
 import { version as viteVersion } from 'vite';
 import { assertViteVersion } from '../../utils/assertViteVersion.js';
+import { installUncaughtErrorHandlers } from '../../utils/installUncaughtErrorHandlers.js';
 function onLoad() {
     markSetup_vikeVitePlugin();
     assertIsNotBrowser();
     assertNodeVersion();
     assertViteVersion(viteVersion);
-    // Ensure we don't bloat the server runtime with heavy dependencies such Vite and esbuild
-    assertIsNotProductionRuntime();
+    assertIsNotProductionRuntime(); // Don't bloat server with heavy dependencies like Vite and esbuild
+    installUncaughtErrorHandlers();
 }

package/dist/node/vite/plugins/build/pluginBuildApp.js

@@ -129,7 +129,7 @@ async function triggerPrerendering(config, viteEnv, bundle) {
     //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
     if (!bundle[getManifestFilePathRelative(config.build.manifest)])
         return;
-    if (!isPrerenderAutoRunEnabled(vikeConfig))
+    if (!(await isPrerenderAutoRunEnabled(vikeConfig)))
         return;
     const configInline = getFullBuildInlineConfig(config);
     const res = await runPrerenderFromAutoRun(configInline);

package/dist/node/vite/plugins/build/pluginModuleBanner.js

@@ -6,7 +6,8 @@ import { getMagicString } from '../../shared/getMagicString.js';
 // - Terser removes legal comments, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
 // - Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
 //   - But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
-// - Potential alternative: https://github.com/vitejs/vite/issues/21228#issuecomment-3627899741
+// - Potential alternative: Rolldown's `postBanner` https://x.com/voidzerodev/status/2001683010446299613
+// - Potential alternative: Rolldown's `//#region` https://github.com/vitejs/vite/issues/21228#issuecomment-3627899741
 function pluginModuleBanner() {
     let config;
     let isEnabled = false;

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -33,6 +33,11 @@ const configDefinitionsBuiltIn = {
         global: true,
         cumulative: true,
     },
+    onHookCall: {
+        env: { server: true, client: true },
+        global: true,
+        cumulative: true,
+    },
     onBeforeRender: {
         env: { server: true },
     },

package/dist/node/vite/shared/resolveVikeConfigInternal.js

@@ -164,7 +164,7 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
         }
         else {
             logErrorServerDev(err, null);
-            resolve(getVikeConfigDummy(esbuildCache));
+            resolve(await getVikeConfigDummy(esbuildCache));
         }
     }
 }
@@ -178,7 +178,7 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
     const globalConfigPublic = resolveGlobalConfig(pageConfigGlobal, pageConfigs);
-    const prerenderContext = resolvePrerenderContext({
+    const prerenderContext = await resolvePrerenderContext({
         config: globalConfigPublic.config,
         _from: globalConfigPublic._from,
         _pageConfigs: pageConfigs,
@@ -1092,8 +1092,8 @@ function isGlobalLocation(locationId, plusFilesByLocationId) {
         .map(([locationId]) => locationId);
     return locationIdsPage.every((locId) => isInherited(locationId, locId));
 }
-function resolvePrerenderContext(vikeConfig) {
-    const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
+async function resolvePrerenderContext(vikeConfig) {
+    const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = await resolvePrerenderConfigGlobal(vikeConfig);
     globalObject.prerenderContext ?? (globalObject.prerenderContext = {
         isPrerenderingEnabled: false,
         isPrerenderingEnabledForAllPages: false,
@@ -1121,14 +1121,14 @@ function restartViteDevServer() {
     })();
     swallowViteLogForceOptimization_disable();
 }
-function getVikeConfigDummy(esbuildCache) {
+async function getVikeConfigDummy(esbuildCache) {
     const pageConfigsDummy = [];
     const pageConfigGlobalDummy = {
         configValueSources: {},
         configDefinitions: {},
     };
     const globalConfigPublicDummy = resolveGlobalConfig(pageConfigGlobalDummy, pageConfigsDummy);
-    const prerenderContextDummy = resolvePrerenderContext({
+    const prerenderContextDummy = await resolvePrerenderContext({
         config: globalConfigPublicDummy.config,
         _from: globalConfigPublicDummy._from,
         _pageConfigs: pageConfigsDummy,

package/dist/server/onLoad.js

@@ -4,9 +4,11 @@ import { assertNodeVersion } from '../utils/assertNodeVersion.js';
 import { setAssertAlwaysShowStackTrace } from '../utils/assert.js';
 import { installRequireShim } from '@brillout/require-shim';
 import { isDebugError } from '../utils/debug.js';
+import { installUncaughtErrorHandlers } from '../utils/installUncaughtErrorHandlers.js';
 function onLoad() {
     assertIsNotBrowser();
     assertNodeVersion();
+    installUncaughtErrorHandlers();
     if (isDebugError()) {
         // Is also executed upon `$ vike build` because node/vite/utils.ts imports server/utils.ts
         Error.stackTraceLimit = Infinity;

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

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

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

@@ -4,10 +4,10 @@ export { setLogRuntimeDev };
 export { assertPageContext_logRuntime };
 export type { PageContext_logRuntime };
 import type { LogType } from '../../node/vite/shared/loggerDev.js';
-import type { PageContextCreatedServerMinimum } from './renderPageServer/createPageContextServerSide.js';
+import type { PageContextCreatedServerBase } from './renderPageServer/createPageContextServerSide.js';
 type LogRuntimeInfo = (msg: string, pageContext: PageContext_logRuntime, logType: LogType) => void;
 type LogRuntimeError = (err: unknown, pageContext: PageContext_logRuntime) => void;
-type PageContext_logRuntime = null | (PageContextCreatedServerMinimum & {
+type PageContext_logRuntime = null | (PageContextCreatedServerBase & {
     _requestId: number;
 });
 declare function setLogRuntimeDev(logRuntimeErrorDev: LogRuntimeError, logRuntimeInfoDev: LogRuntimeInfo): void;

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.