vike 0.4.228-commit-c2f6e1f → 0.4.228-commit-8d90991

package/dist/esm/node/runtime/renderPage.d.ts

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addAsyncHookwrapper };
 export type { PageContextInit };
 export type { PageContextBegin };
-import { type GlobalContextInternal } from './globalContext.js';
+import { type GlobalContextServer, type GlobalContextInternal } from './globalContext.js';
 import { type HttpResponse } from './renderPage/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
 import type { PageContextBuiltInServerInternal } from '../../shared/types.js';
@@ -18,13 +18,106 @@ declare let asyncHookWrapper: <PageContext>(_httpRequestId: number, ret: () => P
     pageContextReturn: Awaited<PageContext>;
 }>;
 declare function renderPage_addAsyncHookwrapper(wrapper: typeof asyncHookWrapper): void;
-declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextInternal, httpRequestId: number): Promise<{
+declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextInternal, globalContext_public: GlobalContextServer, httpRequestId: number): Promise<{
     isClientSide: boolean;
     isPrerendering: boolean;
 } & Pick<PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
     /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
     /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
 } & {
+    globalContext: GlobalContextServer;
+    _globalContext: {
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & ({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer;
+        viteConfig: import("vite").ResolvedConfig;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        baseServer: string;
+        baseAssets: string;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: true;
+        viteConfig: import("vite").ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    });
     _baseServer: string;
     _baseAssets: string;
     _includeAssetsImportedByServer: boolean;
@@ -34,38 +127,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
     _allPageIds: string[];
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    _globalContext: GlobalContextInternal;
-    globalContext: Pick<{
-        viteConfigRuntime: import("../plugin/shared/getViteConfigRuntime.js").ViteConfigRuntime;
-        config: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigUserFriendly["config"];
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-    } & import("../shared/resolveBase.js").BaseUrlsResolved & ({
-        pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-        pageConfigs: import("../../__internal/index.js").PageConfig[];
-        pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        allPageIds: string[];
-        pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-        onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-        config: import("../../types/index.js").ConfigResolved;
-    } & ({
-        isProduction: false;
-        isPrerendering: false;
-        viteConfig: import("vite").ResolvedConfig;
-        viteDevServer: import("vite").ViteDevServer;
-        assetsManifest: null;
-    } | ({
-        isProduction: true;
-        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
-        viteDevServer: null;
-    } & ({
-        isPrerendering: false;
-        viteConfig: null;
-    } | {
-        isPrerendering: true;
-        usesClientRouter: boolean;
-        viteConfig: import("vite").ResolvedConfig;
-    })))), "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig" | "viteConfigRuntime">;
     _pageContextInit: PageContextInit;
     _urlRewrite: null;
     _urlHandler: ((url: string) => string) | null;

package/dist/esm/node/runtime/renderPage.js

@@ -14,7 +14,7 @@ import { assertArguments } from './renderPage/assertArguments.js';
 import { log404 } from './renderPage/log404/index.js';
 import { isVikeConfigInvalid } from './renderPage/isVikeConfigInvalid.js';
 import pc from '@brillout/picocolors';
-import { serializePageContextAbort, serializePageContextClientSide } from './html/serializePageContextClientSide.js';
+import { getPageContextClientSerializedAbort, getPageContextClientSerialized } from './html/serializeContext.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
@@ -76,8 +76,8 @@ async function renderPagePrepare(pageContextInit, httpRequestId) {
     else {
         // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
     }
-    const globalContext = await getGlobalContextInternal();
-    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, httpRequestId);
+    const { globalContext, globalContext_public } = await getGlobalContextInternal();
+    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId);
     // Check Base URL
     {
         const pageContextHttpResponse = await checkBaseUrl(pageContextBegin, globalContext);
@@ -154,7 +154,7 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
             Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
         {
-            const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
+            const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
             if (!errorPageId) {
                 objectAssign(pageContextErrorPageInit, { pageId: null });
                 return handleErrorWithoutErrorPage(pageContextErrorPageInit);
@@ -299,9 +299,9 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
     assert(pageContext.errorWhileRendering);
     return pageContext;
 }
-async function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
+async function getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextBegin = await createPageContextServerSide(pageContextInit, globalContext, {
+    const pageContextBegin = await createPageContextServerSide(pageContextInit, globalContext, globalContext_public, {
         isPrerendering: false,
         ssr: {
             urlHandler: _urlHandler,
@@ -397,12 +397,12 @@ function normalize(url) {
 async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextBegin, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageBegin to it: we only use some pageContextNominalPageBegin information.
 pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext) {
-    logAbortErrorHandled(errAbort, globalContext.isProduction, pageContextNominalPageBegin);
+    logAbortErrorHandled(errAbort, globalContext._isProduction, pageContextNominalPageBegin);
     const pageContextAbort = errAbort._pageContextAbort;
     let pageContextSerialized;
     if (pageContextNominalPageBegin.isClientSideNavigation) {
         if (pageContextAbort.abortStatusCode) {
-            const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
+            const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
             const abortCall = pageContextAbort._abortCall;
             assert(abortCall);
             assertUsage(errorPageId, `You called ${pc.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
@@ -412,10 +412,10 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, pageContextErrorPageInit, true);
             objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
-            pageContextSerialized = serializePageContextClientSide(pageContext);
+            pageContextSerialized = getPageContextClientSerialized(pageContext);
         }
         else {
-            pageContextSerialized = serializePageContextAbort(pageContextAbort);
+            pageContextSerialized = getPageContextClientSerializedAbort(pageContextAbort);
         }
         const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
         const pageContextReturn = { httpResponse };

package/dist/esm/node/runtime/utils.d.ts

@@ -54,5 +54,5 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
-export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/getPublicProxy.js';
 export * from '../../utils/augmentType.js';

package/dist/esm/node/runtime/utils.js

@@ -58,5 +58,5 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
-export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/getPublicProxy.js';
 export * from '../../utils/augmentType.js';

package/dist/esm/shared/VikeNamespace.d.ts

@@ -3,26 +3,30 @@ export type { VikePackages };
 declare global {
     /** Refine Vike types. */
     namespace Vike {
-        /** Extend and/or refine the `Config` type (`import type { Config } from 'vike/types'`).
-         *
-         *  For example:
-         *  - You can refine the type of `Config['Page']`.
-         *  - You can define the type of custom configurations created with `config.meta` (https://vike.dev/meta)
+        /** Extend the `Config` type (`import type { Config } from 'vike/types'`).
          *
          *  https://vike.dev/meta#typescript
          */
         interface Config {
         }
-        /** Extend and/or refine the `PageContext` type (`import type { PageContext } from 'vike/types'`).
-         *
-         *  For example:
-         *  - You can refine the type of `PageContext['Page']`.
-         *  - You can define the type of custom `pageContext` values such as `pageContext.user`, see https://vike.dev/pageContext#custom
+        /** Extend the `PageContext` type (`import type { PageContext } from 'vike/types'`).
          *
          *  https://vike.dev/pageContext#typescript
          */
         interface PageContext {
         }
+        /** Extend the `PageContextClient` type (`import type { PageContextClient } from 'vike/types'`).
+         *
+         *  https://vike.dev/pageContext#typescript
+         */
+        interface PageContextClient {
+        }
+        /** Extend the `PageContextServer` type (`import type { PageContextServer } from 'vike/types'`).
+         *
+         *  https://vike.dev/pageContext#typescript
+         */
+        interface PageContextServer {
+        }
         /** Refine the `pageContext.config` type.
          *
          *  It's used for cumulative configs: the `pageContext.config[configName]` type is an `array` whereas `Config[configName]` isn't.
@@ -31,6 +35,24 @@ declare global {
          */
         interface ConfigResolved {
         }
+        /** Extend the `GlobalContext` type (`import type { GlobalContext } from 'vike/types'`).
+         *
+         *  https://vike.dev/globalContext#typescript
+         */
+        interface GlobalContext {
+        }
+        /** Extend the `GlobalContextClient` type (`import type { GlobalContextClient } from 'vike/types'`).
+         *
+         *  https://vike.dev/globalContext#typescript
+         */
+        interface GlobalContextClient {
+        }
+        /** Extend the `GlobalContextServer` type (`import type { GlobalContextServer } from 'vike/types'`).
+         *
+         *  https://vike.dev/globalContext#typescript
+         */
+        interface GlobalContextServer {
+        }
     }
     /** This namespace is only used by:
      *  - `vike-react`

package/dist/esm/shared/createGlobalContextShared.d.ts

@@ -0,0 +1,25 @@
+export { createGlobalContextShared };
+export type { GlobalContextShared };
+export type { GlobalContextSharedPublic };
+declare function createGlobalContextShared<GlobalContextAddendum extends object>(virtualFileExports: unknown, globalObject: {
+    globalContext?: Record<string, unknown>;
+}, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): Promise<{
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("./getPageFiles.js").PageFile[];
+    _pageConfigs: import("./page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    pages: import("./page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+} & Awaited<GlobalContextAddendum>>;
+type GlobalContextSharedPublic = Pick<GlobalContextShared, 'config' | 'pages'>;
+type GlobalContextShared = ReturnType<typeof createGlobalContextBase>;
+declare function createGlobalContextBase(virtualFileExports: unknown): {
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("./getPageFiles.js").PageFile[];
+    _pageConfigs: import("./page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    pages: import("./page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+};

package/dist/esm/shared/createGlobalContextShared.js

@@ -0,0 +1,43 @@
+export { createGlobalContextShared };
+import { getPageConfigsRuntime } from './getPageConfigsRuntime.js';
+import { executeHookGenericGlobalCumulative } from './hooks/executeHookGeneric.js';
+import { objectAssign } from './utils.js';
+async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
+    const globalContext = createGlobalContextBase(virtualFileExports);
+    const globalContextAddendum = await addGlobalContext?.(globalContext);
+    objectAssign(globalContext, globalContextAddendum);
+    if (!globalObject.globalContext) {
+        globalObject.globalContext = globalContext;
+        // - We deliberately call onCreateGlobalContext() only at the beginning and only once per process.
+        // - TO-DO/eventually: HMR
+        //    - Once Photon supports it: `server.hot.send({ type: 'full-server-reload' })`
+        //    - Either use:
+        //      - import.meta.hot
+        //        - https://vite.dev/guide/api-hmr.html
+        //        - Use a Vite transformer to inject import.meta.hot code into each user-land `+onCreateGlobalContext.js` file
+        //        - Seems more idiomatic
+        //      - globalContext._viteDevServer.hot.send()
+        //        - Send 'full-server-reload' signal whenever a onCreateGlobalContext() function is modified => we need a globalObject to track all hooks and see if one of them is new/modified.
+        //        - Seems less idiomatic
+        await executeHookGenericGlobalCumulative('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+    }
+    else {
+        // Singleton: ensure all `globalContext` user-land references are preserved & updated.
+        // We don't use objectReplace() in order to keep user-land properties.
+        objectAssign(globalObject.globalContext, globalContext);
+    }
+    return globalObject.globalContext;
+}
+function createGlobalContextBase(virtualFileExports) {
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = getPageConfigsRuntime(virtualFileExports);
+    const globalContext = {
+        _virtualFileExports: virtualFileExports,
+        _pageFilesAll: pageFilesAll,
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        _allPageIds: allPageIds,
+        config: globalConfig.config,
+        pages: pageConfigsUserFriendly
+    };
+    return globalContext;
+}

package/dist/esm/shared/createPageContextShared.js

@@ -1,5 +1,5 @@
 export { createPageContextShared };
-import { executeHookGenericGlobalCumulative } from '../node/runtime/renderPage/executeHookGeneric.js';
+import { executeHookGenericGlobalCumulative } from './hooks/executeHookGeneric.js';
 import { getPageConfigGlobalUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
 import { objectAssign } from './utils.js';
 async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
@@ -10,6 +10,6 @@ async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
         _isPageContextObject: true,
         ...pageConfigGlobalUserFriendly
     }, true);
-    await executeHookGenericGlobalCumulative('onCreatePageContext', pageConfigGlobal, pageContextCreated);
+    await executeHookGenericGlobalCumulative('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
     return pageContextCreated;
 }

package/dist/esm/shared/hooks/executeHookGeneric.d.ts

@@ -0,0 +1,8 @@
+export { executeHookGeneric };
+export { executeHookGenericGlobalCumulative };
+import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
+import { type HookName } from './getHook.js';
+import type { HookNameGlobal } from '../page-configs/Config.js';
+import type { PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+declare function executeHookGeneric(hookName: HookName, pageContext: PageConfigUserFriendlyOld): Promise<void>;
+declare function executeHookGenericGlobalCumulative(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: object | null, arg: object): Promise<void>;

package/dist/esm/{node/runtime/renderPage → shared/hooks}/executeHookGeneric.js

@@ -1,16 +1,16 @@
 export { executeHookGeneric }; // TO-DO/refactor: start using executeHookGeneric() and, eventually, prominently use it
 export { executeHookGenericGlobalCumulative };
-import { executeHook } from '../../../shared/hooks/executeHook.js';
-import { getHookFromPageContext, getHookFromPageConfigGlobalCumulative } from '../../../shared/hooks/getHook.js';
+import { executeHook } from './executeHook.js';
+import { getHookFromPageContext, getHookFromPageConfigGlobalCumulative } from './getHook.js';
 async function executeHookGeneric(hookName, pageContext) {
     const hook = getHookFromPageContext(pageContext, hookName);
     if (!hook)
         return;
     await executeHook(() => hook.hookFn(pageContext), hook, pageContext);
 }
-async function executeHookGenericGlobalCumulative(hookName, pageConfigGlobal, pageContext) {
+async function executeHookGenericGlobalCumulative(hookName, pageConfigGlobal, pageContext, arg) {
     const hooks = getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName);
     await Promise.all(hooks.map(async (hook) => {
-        await executeHook(() => hook.hookFn(pageContext), hook, null);
+        await executeHook(() => hook.hookFn(arg), hook, pageContext);
     }));
 }

package/dist/esm/shared/htmlElementIds.d.ts

@@ -0,0 +1,2 @@
+export declare const htmlElementId_pageContext = "vike_pageContext";
+export declare const htmlElementId_globalContext = "vike_globalContext";

package/dist/esm/shared/htmlElementIds.js

@@ -0,0 +1,2 @@
+export const htmlElementId_pageContext = 'vike_pageContext';
+export const htmlElementId_globalContext = 'vike_globalContext';

package/dist/esm/shared/page-configs/Config.d.ts

@@ -41,11 +41,11 @@ import type { InjectFilterEntry } from '../../types/index.js';
 import type { VikeVitePluginOptions } from '../../node/plugin/index.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
-import type { PageContextClient, PageContextServer } from '../types.js';
+import type { GlobalContext, PageContextClient, PageContextServer } from '../types.js';
 import type { InlineConfig } from 'vite';
 type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
-type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext';
+type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext';
 type HookNameOldDesign = 'render' | 'prerender';
 type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
@@ -335,6 +335,11 @@ type ConfigBuiltIn = {
      *  https://vike.dev/onCreatePageContext
      */
     onCreatePageContext?: ((pageContext: PageContextServer) => void) | ImportString | null;
+    /** Hook called when the `globalContext` object is created.
+     *
+     *  https://vike.dev/onCreateGlobalContext
+     */
+    onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportString | null;
     /** Hook for fetching data.
      *
      *  https://vike.dev/data

package/dist/esm/shared/types.d.ts

@@ -1,22 +1,28 @@
-export { PageContext };
-export { PageContextServer };
-export { PageContextClient };
-export { PageContextWithServerRouting };
-export { PageContextClientWithServerRouting };
-export { PageContextBuiltInServerInternal };
-export { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
-export { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
-export { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
+export type { PageContext };
+export type { PageContextServer };
+export type { PageContextClient };
+export type { GlobalContext };
+export type { GlobalContextServer };
+export type { GlobalContextClient };
+export type { PageContextWithServerRouting };
+export type { PageContextClientWithServerRouting };
+export type { GlobalContextClientWithServerRouting };
+export type { PageContextBuiltInServerInternal };
+export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
+export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
+export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
 import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from './getPageContextUrlComputed.js';
 import type { ConfigEntries, ExportsAll, From, Source, Sources } from './page-configs/getPageConfigUserFriendly.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';
-import type { GlobalContextPublic } from '../node/runtime/globalContext.js';
-import type { GlobalContextPublicClientSide } from '../client/client-routing-runtime/globalContextClientSide.js';
+import type { GlobalContextServer } from '../node/runtime/globalContext.js';
+import type { GlobalContextClient } from '../client/client-routing-runtime/globalContext.js';
+import type { GlobalContextClientWithServerRouting } from '../client/server-routing-runtime/globalContext.js';
 type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & Vike.PageContext;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
 type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & Vike.PageContext;
+type GlobalContext = GlobalContextServer | GlobalContextClient;
 type PageContextWithServerRouting<Data = unknown> = PageContextClientWithServerRouting<Data> | PageContextServer<Data>;
 type PageContextClientWithServerRouting<Data = unknown> = PageContextBuiltInClientWithServerRouting<Data> & Vike.PageContext;
 type PageContextBuiltInCommon<Data> = {
@@ -152,7 +158,7 @@ type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageConte
      *
      * https://vike.dev/getGlobalContext
      */
-    globalContext: GlobalContextPublic;
+    globalContext: GlobalContextServer;
     isHydration?: undefined;
     isBackwardNavigation?: undefined;
     previousPageContext?: undefined;
@@ -172,6 +178,7 @@ type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltI
      * https://vike.dev/pageContext
      */
     previousPageContext: PageContextClient<Data> | null;
+    globalContext: GlobalContextClient;
 } & PageContextUrlClient;
 type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'exports' | 'abortReason' | 'pageId' | 'data'> & PageContextClientCommon & {
     /**
@@ -186,6 +193,7 @@ type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltI
      * The `isBackwardNavigation` property only works with Client Routing. (The value is always `null` when using Server Routing.)
      */
     isBackwardNavigation: null;
+    globalContext: GlobalContextClientWithServerRouting;
 };
 type PageContextClientCommon = {
     /**
@@ -203,7 +211,6 @@ type PageContextClientCommon = {
      * https://vike.dev/pageContext
      */
     isPrerendering: false;
-    globalContext: GlobalContextPublicClientSide;
 };
 /** For Vike internal use */
 type PageContextBuiltInServerInternal = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data'>;

package/dist/esm/types/index.d.ts

@@ -1,8 +1,4 @@
-export type { PageContext } from '../shared/types.js';
-export type { PageContextServer } from '../shared/types.js';
-export type { PageContextClient } from '../shared/types.js';
-export type { PageContextWithServerRouting } from '../shared/types.js';
-export type { PageContextClientWithServerRouting } from '../shared/types.js';
+export type { PageContext, PageContextServer, PageContextClient, GlobalContext, GlobalContextServer, GlobalContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, GlobalContextClientWithServerRouting } from '../shared/types.js';
 export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.228-commit-c2f6e1f";
+export declare const PROJECT_VERSION: "0.4.228-commit-8d90991";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.228-commit-c2f6e1f';
+export const PROJECT_VERSION = '0.4.228-commit-8d90991';

package/dist/esm/utils/catchInfiniteLoop.js

@@ -1,5 +1,5 @@
 export { catchInfiniteLoop };
-import { assert, assertWarning } from './assert.js';
+import { assertUsage, assertWarning } from './assert.js';
 const trackers = {};
 function catchInfiniteLoop(functionName, maxNumberOfCalls = 100, withinSeconds = 5) {
     // Init
@@ -12,14 +12,14 @@ function catchInfiniteLoop(functionName, maxNumberOfCalls = 100, withinSeconds =
     // Count
     tracker.count++;
     // Error
-    const msg = `[Infinite Loop] ${functionName} called ${tracker.count} times within ${withinSeconds} seconds`;
+    const msg = `[Infinite Loop] Rendering ${tracker.count} times within ${withinSeconds} seconds [${functionName}]`;
     if (tracker.count > maxNumberOfCalls) {
-        assert(false, msg);
+        assertUsage(false, msg);
     }
     // Warning, at 50% threshold
     if (!tracker.warned && tracker.count > maxNumberOfCalls * 0.5) {
         // Warning is shown upon 10 calls a second, on average during 5 seconds, given the default parameters
-        assertWarning(false, msg, { onlyOnce: false });
+        assertWarning(false, msg, { onlyOnce: false, showStackTrace: true });
         tracker.warned = true;
     }
 }

package/dist/esm/utils/getGlobalObject.d.ts

@@ -1,6 +1,6 @@
 export { getGlobalObject };
 export { assertIsSingleModuleInstance };
-type Key = `${string}/${string}.ts`;
+type Key = `${string}.ts`;
 /** Share information across module instances. */
 declare function getGlobalObject<T extends Record<string, unknown> = never>(key: Key, defaultValue: T): T;
 /** Assert that the module is instantiated only once. */

package/dist/esm/utils/getPublicProxy.d.ts

@@ -0,0 +1,2 @@
+export { getPublicProxy };
+declare function getPublicProxy<Obj extends Record<string, unknown>, PropsPublic extends readonly (keyof Obj)[]>(obj: Obj, objName: string, propsPublic: PropsPublic, expectCustomUserLandProps?: true): Pick<Obj, PropsPublic[number]>;

package/dist/esm/utils/getPublicProxy.js

@@ -0,0 +1,25 @@
+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
+//   TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute, #<Object>
+//   ```
+// - Previous implementation using property getters: https://github.com/vikejs/vike/blob/main/vike/utils/makePublicCopy.ts
+import { assert, assertWarning } from './assert.js';
+// Show warning when user is accessing internal `_` properties.
+function getPublicProxy(obj, objName, propsPublic, expectCustomUserLandProps) {
+    if (!expectCustomUserLandProps) {
+        Object.keys(obj).forEach((key) => assert(key.startsWith('_') || propsPublic.includes(key)));
+        propsPublic.forEach((prop) => prop in obj);
+    }
+    return new Proxy(obj, {
+        get(_, prop) {
+            const propStr = String(prop);
+            if (propStr.startsWith('_')) {
+                assertWarning(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub and elaborate your use case so that the Vike team can add official support for your use case.`, { onlyOnce: true });
+            }
+            // @ts-ignore Seems to be TypeScript bug
+            return Reflect.get(...arguments);
+        }
+    });
+}

package/dist/esm/utils/objectAssign.d.ts

@@ -1,2 +1,2 @@
 export { objectAssign };
-declare function objectAssign<Obj extends object, ObjAddendum extends object | null>(obj: Obj, objAddendum: ObjAddendum, objAddendumCanBePageContextObject?: true): asserts obj is Obj & ObjAddendum;
+declare function objectAssign<Obj extends object, ObjAddendum extends object | null | undefined>(obj: Obj, objAddendum: ObjAddendum, objAddendumCanBePageContextObject?: true): asserts obj is Obj & ObjAddendum;