vike 0.4.229-commit-7056ef0 → 0.4.229-commit-5da80bf

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

@@ -2,11 +2,11 @@ export { renderPage };
 export { renderPage_addAsyncHookwrapper };
 export type { PageContextInit };
 export type { PageContextBegin };
-import { type GlobalContextServer, type GlobalContextServerInternal } from './globalContext.js';
+import { type GlobalContextServerInternal } from './globalContext.js';
 import { type HttpResponse } from './renderPage/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
-import type { PageContextBuiltInServerInternal } from '../../shared/types.js';
-type PageContextInit = Pick<PageContextBuiltInServerInternal, 'urlOriginal' | 'headersOriginal'> & {
+import type { PageContextInternalServer } from '../../shared/types.js';
+type PageContextInit = Pick<PageContextInternalServer, 'urlOriginal' | 'headersOriginal'> & {
     /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
     /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
 };
@@ -18,16 +18,19 @@ 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: GlobalContextServerInternal, globalContext_public: GlobalContextServer, httpRequestId: number): Promise<{
-    isClientSide: boolean;
+declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, httpRequestId: number): Promise<{
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
     isPrerendering: boolean;
-} & Pick<PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+} & Pick<PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
     /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
     /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
 } & {
-    globalContext: GlobalContextServer;
     _globalContext: {
         isGlobalContext: true;
+        _isOriginalObject: true;
         _virtualFileExports: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../__internal/index.js").PageConfig[];
@@ -65,23 +68,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        isGlobalContext: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-        _pageConfigs: import("../../__internal/index.js").PageConfig[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
-        config: import("../../types/index.js").ConfigResolved;
-        pages: {
-            [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-                route: import("../../shared/page-configs/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
-        };
     } | {
         _isPrerendering: true;
         viteConfig: import("vite").ResolvedConfig;
@@ -104,23 +90,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        isGlobalContext: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-        _pageConfigs: import("../../__internal/index.js").PageConfig[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
-        config: import("../../types/index.js").ConfigResolved;
-        pages: {
-            [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-                route: import("../../shared/page-configs/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
-        };
     } | {
         _isPrerendering: false;
         viteConfig: null;
@@ -143,23 +112,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        isGlobalContext: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-        _pageConfigs: import("../../__internal/index.js").PageConfig[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
-        config: import("../../types/index.js").ConfigResolved;
-        pages: {
-            [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-                route: import("../../shared/page-configs/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
-        };
     });
     _baseServer: string;
     _baseAssets: string;
@@ -180,8 +132,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
     url: string;
 } & {
     headers: Record<string, string> | null;
-} & {
-    isPageContext: true;
 } & {
     _httpRequestId: number;
 }>;

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

@@ -19,6 +19,7 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadPageConfigsLazyServerSide } from './renderPage/loadPageConfigsLazyServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
+import { getProxyForMutationTracking } from '../../shared/getProxyForPublicUsage.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
     httpRequestsCount: 0
 });
@@ -76,8 +77,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, globalContext_public } = await getGlobalContextServerInternal();
-    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId);
+    const { globalContext } = await getGlobalContextServerInternal();
+    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, httpRequestId);
     // Check Base URL
     {
         const pageContextHttpResponse = await checkBaseUrl(pageContextBegin, globalContext);
@@ -299,9 +300,9 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
     assert(pageContext.errorWhileRendering);
     return pageContext;
 }
-async function getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId) {
+async function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextBegin = await createPageContextServerSide(pageContextInit, globalContext, globalContext_public, {
+    const pageContextBegin = await createPageContextServerSide(pageContextInit, globalContext, {
         isPrerendering: false,
         ssr: {
             urlHandler: _urlHandler,
@@ -483,5 +484,6 @@ function getPageContextInvalidVikeConfig(err, pageContextInit, httpRequestId) {
 function forkPageContext(pageContextBegin) {
     const pageContext = {};
     objectAssign(pageContext, pageContextBegin, true);
-    return pageContext;
+    const pageContextWithProxy = getProxyForMutationTracking(pageContext);
+    return pageContextWithProxy;
 }

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/getPublicProxy.js';
 export * from '../../utils/augmentType.js';
+export * from '../../utils/changeEnumerable.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/getPublicProxy.js';
 export * from '../../utils/augmentType.js';
+export * from '../../utils/changeEnumerable.js';

package/dist/esm/shared/NOT_SERIALIZABLE.js

@@ -1,2 +1 @@
-// TODO: move to ../node/runtime/html/NOT_SERIALIZABLE.ts once code is distributed as ESM
 export const NOT_SERIALIZABLE = '__VIKE__NOT_SERIALIZABLE__';

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

@@ -1,7 +1,2 @@
 export { addIs404ToPageProps };
-import type { PageConfigRuntime } from './page-configs/PageConfig.js';
-declare function addIs404ToPageProps(pageContext: Record<string, unknown> & PageContextAssertIs404): void;
-type PageContextAssertIs404 = {
-    pageId: string;
-    _pageConfigs: PageConfigRuntime[];
-};
+declare function addIs404ToPageProps(pageContext: Record<string, unknown>): void;

package/dist/esm/shared/addIs404ToPageProps.js

@@ -1,15 +1,8 @@
 export { addIs404ToPageProps };
-import { assert, assertWarning, hasProp, isObject } from './utils.js';
-import { isErrorPage } from './error-page.js';
+import { assertWarning, isObject } from './utils.js';
 function addIs404ToPageProps(pageContext) {
-    assertIs404(pageContext);
     addIs404(pageContext);
 }
-function assertIs404(pageContext) {
-    if (isErrorPage(pageContext.pageId, pageContext._pageConfigs)) {
-        assert(hasProp(pageContext, 'is404', 'boolean'));
-    }
-}
 function addIs404(pageContext) {
     if (pageContext.is404 === undefined || pageContext.is404 === null)
         return;

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

@@ -14,6 +14,7 @@ declare function createGlobalContextShared<GlobalContextAddendum extends object>
      * https://vike.dev/globalContext#typescript
      */
     isGlobalContext: true;
+    _isOriginalObject: true;
     _virtualFileExports: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
@@ -40,6 +41,7 @@ declare function createGlobalContextBase(virtualFileExports: unknown): {
      * https://vike.dev/globalContext#typescript
      */
     isGlobalContext: true;
+    _isOriginalObject: true;
     _virtualFileExports: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];

package/dist/esm/shared/createGlobalContextShared.js

@@ -1,9 +1,10 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
-import { objectAssign, unique } from './utils.js';
+import { changeEnumerable, objectAssign, unique } from './utils.js';
 import { parseGlobResults } from './getPageFiles/parseGlobResults.js';
 import { getUserFriendlyConfigsGlobal, getUserFriendlyConfigsPageEager } from './page-configs/getUserFriendlyConfigs.js';
-import { executeHookGlobalCumulative } from './hooks/executeHook.js';
+import { execHookGlobal } from './hooks/execHook.js';
+import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
     const globalContext = createGlobalContextBase(virtualFileExports);
@@ -22,12 +23,12 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
         //      - 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 executeHookGlobalCumulative('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+        await execHookGlobal('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage);
     }
     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);
+        objectAssign(globalObject.globalContext, globalContext, true);
     }
     return globalObject.globalContext;
 }
@@ -40,6 +41,7 @@ function createGlobalContextBase(virtualFileExports) {
          * https://vike.dev/globalContext#typescript
          */
         isGlobalContext: true,
+        _isOriginalObject: true,
         _virtualFileExports: virtualFileExports,
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
@@ -49,6 +51,7 @@ function createGlobalContextBase(virtualFileExports) {
         config: userFriendlyConfigsGlobal.config,
         pages: userFriendlyConfigsPageEager
     };
+    changeEnumerable(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
 function getConfigsAll(virtualFileExports) {

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

@@ -1,6 +1,10 @@
 export { createPageContextShared };
+export { createPageContextObject };
 import type { PageConfigUserFriendly } from './page-configs/getUserFriendlyConfigs.js';
 import type { PageConfigGlobalRuntime } from './page-configs/PageConfig.js';
-declare function createPageContextShared<T extends object>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, userFriendlyConfigsGlobal: PageConfigUserFriendly): Promise<T & {
+import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
+declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, userFriendlyConfigsGlobal: PageConfigUserFriendly): Promise<T & PageConfigUserFriendly>;
+declare function createPageContextObject(): {
+    _isOriginalObject: true;
     isPageContext: true;
-} & PageConfigUserFriendly>;
+};

package/dist/esm/shared/createPageContextShared.js

@@ -1,9 +1,20 @@
 export { createPageContextShared };
-import { executeHookGlobalCumulative } from './hooks/executeHook.js';
-import { objectAssign } from './utils.js';
+export { createPageContextObject };
+import { getProxyForMutationTracking } from './getProxyForPublicUsage.js';
+import { execHookGlobal } from './hooks/execHook.js';
+import { preparePageContextForPublicUsage } from './preparePageContextForPublicUsage.js';
+import { changeEnumerable, objectAssign } from './utils.js';
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, userFriendlyConfigsGlobal) {
-    objectAssign(pageContextCreated, { isPageContext: true }, true);
     objectAssign(pageContextCreated, userFriendlyConfigsGlobal);
-    await executeHookGlobalCumulative('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
+    await execHookGlobal('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage);
     return pageContextCreated;
 }
+function createPageContextObject() {
+    const pageContext = {
+        _isOriginalObject: true,
+        isPageContext: true
+    };
+    changeEnumerable(pageContext, '_isOriginalObject', false);
+    const pageContextWithProxy = getProxyForMutationTracking(pageContext);
+    return pageContextWithProxy;
+}

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

@@ -1 +1 @@
-export { getPageContext, providePageContext } from './hooks/executeHook.js';
+export { getPageContext, providePageContext } from './hooks/execHook.js';

package/dist/esm/shared/getPageContext.js

@@ -1 +1 @@
-export { getPageContext, providePageContext } from './hooks/executeHook.js';
+export { getPageContext, providePageContext } from './hooks/execHook.js';

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

@@ -1,9 +1,9 @@
 export { getPageContextUrlComputed };
-export { assertPageContextUrl };
 export type { PageContextUrlInternal };
 export type { PageContextUrlClient };
 export type { PageContextUrlServer };
 export type { PageContextUrlSource };
+import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
 import { type UrlPublic } from './utils.js';
 type PageContextUrlComputed = {
     /** Parsed information about the current URL */
@@ -17,7 +17,7 @@ type PageContextUrl = {
     /** The URL of the HTTP request */
     urlOriginal: string;
 } & PageContextUrlComputed;
-type PageContextUrlInternal = PageContextUrl & {
+type PageContextUrlInternal = PageContextPrepareMinimum & PageContextUrl & {
     _urlRewrite: string | null;
 };
 type PageContextUrlClient = PageContextUrl;
@@ -40,6 +40,3 @@ type PageContextUrlSource = {
     _baseServer: string;
     _urlHandler: null | ((url: string) => string);
 };
-declare function assertPageContextUrl(pageContext: {
-    urlOriginal: string;
-} & PageContextUrlClient): void;

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -1,14 +1,14 @@
 export { getPageContextUrlComputed };
-export { assertPageContextUrl };
 // =====================
 // File determining the URL logic.
 // 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 { assert, parseUrl, assertWarning, isPlainObject, isPropertyGetter, isBrowser, changeEnumerable } from './utils.js';
+import { assertPropertyGetters } from './preparePageContextForPublicUsage.js';
+import { assert, parseUrl, assertWarning, isBrowser, changeEnumerable } from './utils.js';
 function getPageContextUrlComputed(pageContext) {
     assert(typeof pageContext.urlOriginal === 'string');
-    assertPageContextUrlComputed(pageContext);
+    assertPropertyGetters(pageContext);
     const pageContextUrlComputed = {};
     objectDefineProperty(pageContextUrlComputed, 'urlPathname', {
         get: urlPathnameGetter,
@@ -128,37 +128,3 @@ function urlParsedGetter() {
     }
     return urlParsedEnhanced;
 }
-function assertPageContextUrl(pageContext) {
-    assert(typeof pageContext.urlOriginal === 'string');
-    assert(typeof pageContext.urlPathname === 'string');
-    assert(isPlainObject(pageContext.urlParsed));
-    assert(pageContext.urlPathname === pageContext.urlParsed.pathname);
-    assertPageContextUrlComputed(pageContext);
-}
-function assertPageContextUrlComputed(pageContext) {
-    /*
-    If the isPropertyGetter() assertions fail then it's most likely because Object.assign() was used instead of `objectAssign()`:
-    ```js
-    const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
-  
-    // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
-    Object.assign(pageContext, pageContextUrlComputed)
-  
-    // ❌ Also breaks property descriptors/getters
-    const pageContext = { ...pageContextUrlComputed }
-  
-    // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
-    objectAssign(pageContext, pageContextUrlComputed)
-    ```
-    */
-    if ('urlPathname' in pageContext) {
-        assert(typeof pageContext.urlPathname === 'string');
-        assert(isPropertyGetter(pageContext, 'urlPathname'));
-        assert(isPropertyGetter(pageContext, 'urlParsed'));
-        assert(isPropertyGetter(pageContext, 'url'));
-    }
-    else {
-        assert(!('urlParsed' in pageContext));
-        assert(!('url' in pageContext));
-    }
-}

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

@@ -0,0 +1,12 @@
+export { getProxyForPublicUsage };
+export { getProxyForPublicUsageFlat };
+export { getProxyForMutationTracking };
+type Target = Record<string, unknown> & {
+    _onChange?: () => void;
+    _proxyTarget?: any;
+    _userMods?: any;
+    _proxyTargetPublic?: any;
+};
+declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: string, skipOnInternalProp?: true): Obj;
+declare function getProxyForPublicUsageFlat<Obj extends Target>(obj: Obj, objName: string, skipOnInternalProp?: true): Obj;
+declare function getProxyForMutationTracking<Obj extends Target>(obj: Obj): Obj;

package/dist/esm/shared/getProxyForPublicUsage.js

@@ -0,0 +1,104 @@
+export { getProxyForPublicUsage };
+export { getProxyForPublicUsageFlat };
+export { getProxyForMutationTracking };
+// 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
+// Show warning when user is accessing internal `_` properties.
+import { NOT_SERIALIZABLE } from './NOT_SERIALIZABLE.js';
+import { assert, assertUsage, assertWarning, getPropAccessNotation, isBrowser, objectAssign, objectReplace } from './utils.js';
+function getProxyForPublicUsage(obj, objName, skipOnInternalProp) {
+    return new Proxy(obj, {
+        get: getTrapGet(obj, objName, skipOnInternalProp)
+    });
+}
+function getProxyForPublicUsageFlat(obj, objName, skipOnInternalProp) {
+    assert(obj._isOriginalObject);
+    assert(obj._proxyTarget);
+    obj._proxyTargetPublic ?? (obj._proxyTargetPublic = {});
+    const target = obj._proxyTargetPublic;
+    obj._userMods ?? (obj._userMods = {});
+    const objUserMods = obj._userMods;
+    const update = () => {
+        assert(obj._proxyTarget);
+        objectReplace(target, obj._proxyTarget);
+        objectAssign(target, objUserMods);
+    };
+    obj._onChange = () => {
+        update();
+    };
+    update();
+    return new Proxy(target, {
+        // get: getTrapGet(target, objName, skipOnInternalProp),
+        set(_, prop, val) {
+            const ret = Reflect.set(objUserMods, prop, val);
+            update();
+            return ret;
+        },
+        defineProperty(_, ...args) {
+            const ret = Reflect.defineProperty(objUserMods, ...args);
+            update();
+            return ret;
+        },
+        deleteProperty(_, ...args) {
+            const ret = Reflect.deleteProperty(objUserMods, ...args);
+            update();
+            return ret;
+        }
+    });
+}
+function getTrapGet(obj, objName, skipOnInternalProp) {
+    return function (_, prop) {
+        const propStr = String(prop);
+        if (!skipOnInternalProp)
+            onInternalProp(propStr, objName);
+        const val = obj[prop];
+        onNotSerializable(propStr, val, objName);
+        return val;
+    };
+}
+function getProxyForMutationTracking(obj) {
+    objectAssign(obj, { _proxyTarget: obj });
+    return new Proxy(obj, {
+        set(...args) {
+            const ret = Reflect.set(...args);
+            obj._onChange?.();
+            return ret;
+        },
+        defineProperty(...args) {
+            const ret = Reflect.defineProperty(...args);
+            obj._onChange?.();
+            return ret;
+        },
+        deleteProperty(...args) {
+            const ret = Reflect.deleteProperty(...args);
+            obj._onChange?.();
+            return ret;
+        }
+    });
+}
+function onNotSerializable(propStr, val, objName) {
+    if (val !== NOT_SERIALIZABLE)
+        return;
+    const propName = getPropAccessNotation(propStr);
+    assert(isBrowser());
+    assertUsage(false, `Can't access ${objName}${propName} on the client side. Because it can't be serialized, see server logs.`);
+}
+function onInternalProp(propStr, objName) {
+    // - We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
+    // - TO-DO/eventually: use import.meta.CLIENT instead of isBrowser()
+    //   - Where import.meta.CLIENT is defined by Vike
+    //   - Using import.meta.env.CLIENT (note `.env.`) doesn't seem possible: https://github.com/brillout/playground_node_import.meta.env
+    //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use import.meta.env.SSR
+    if (isBrowser())
+        return;
+    // TODO/now remove this and only warn on built-in access instead
+    if (propStr === '_configFromHook')
+        return;
+    if (propStr.startsWith('_')) {
+        assertWarning(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub to request official support for your use case.`, { onlyOnce: true, showStackTrace: true });
+    }
+}

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

@@ -0,0 +1,63 @@
+export { execHook };
+export { execHookSingle };
+export { execHookSingleWithReturn };
+export { execHookErrorHandling };
+export { execHooksErrorHandling };
+export { execHookWithoutPageContext };
+export { execHookGlobal };
+export { execHookSync };
+export { getPageContext };
+export { providePageContext };
+export { isUserHookError };
+export type { PageContextExecuteHook };
+import type { PageContextClient, PageContextServer } from '../types.js';
+import type { Hook, HookLoc } from './getHook.js';
+import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
+import type { HookName, HookNameGlobal } from '../page-configs/Config.js';
+import type { PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+import type { PageContextForPublicUsageServer } from '../../node/runtime/renderPage/preparePageContextForPublicUsageServer.js';
+import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
+import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
+import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
+type PageContextExecuteHook = PageConfigUserFriendlyOld & PageContextForPublicUsage;
+type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
+type HookWithResult = Hook & {
+    hookReturn: unknown;
+};
+declare function execHookSingle<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
+declare function execHookSingleWithReturn<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+    hookReturn: unknown;
+}>;
+declare function execHook<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookErrorHandling<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+    hooks: HookWithResult[];
+    err?: undefined;
+} | {
+    hooks: Hook[];
+    err: unknown;
+}>;
+declare function execHooksErrorHandling<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+    hooks: HookWithResult[];
+    err?: undefined;
+} | {
+    hooks: Hook[];
+    err: unknown;
+}>;
+declare function execHookGlobal<HookArg extends PageContextPrepareMinimum | GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
+declare function isUserHookError(err: unknown): false | HookLoc;
+declare function execHookWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>): Promise<HookReturn>;
+declare function execHookSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
+    hookReturn: unknown;
+};
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+declare function getPageContext<PageContext = PageContextClient | PageContextServer>(): null | PageContext;
+/**
+ * Provide `pageContext` for universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+declare function providePageContext(pageContext: null | PageContextPrepareMinimum): void;