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

package/dist/cjs/client/server-routing-runtime/utils.js

@@ -31,3 +31,4 @@ __exportStar(require("../../utils/slice.js"), exports);
 __exportStar(require("../../utils/unique.js"), exports); // Only used by Server Routing (not needed for Client Routing)
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/augmentType.js"), exports);
+__exportStar(require("../../utils/changeEnumerable.js"), exports);

package/dist/cjs/client/shared/{preparePageContextForUserConsumptionClientSide.js → preparePageContextForPublicUsageClientShared.js}

@@ -1,31 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.preparePageContextForUserConsumptionClientSide = preparePageContextForUserConsumptionClientSide;
+exports.preparePageContextForPublicUsageClientShared = preparePageContextForPublicUsageClientShared;
+exports.preparePageContextForPublicUsageClientMinimal = preparePageContextForPublicUsageClientMinimal;
 const utils_js_1 = require("../server-routing-runtime/utils.js");
-const getPageContextProxyForUser_js_1 = require("./getPageContextProxyForUser.js");
-const preparePageContextForUserConsumption_js_1 = require("../../shared/preparePageContextForUserConsumption.js");
-function preparePageContextForUserConsumptionClientSide(pageContext, isClientRouting) {
-    if (isClientRouting) {
-        const pageContextTyped = pageContext;
-        (0, utils_js_1.assert)([true, false].includes(pageContextTyped.isHydration));
-        (0, utils_js_1.assert)([true, false, null].includes(pageContextTyped.isBackwardNavigation));
-    }
-    else {
-        const pageContextTyped = pageContext;
-        (0, utils_js_1.assert)(pageContextTyped.isHydration === true);
-        (0, utils_js_1.assert)(pageContextTyped.isBackwardNavigation === null);
-    }
-    const Page = pageContext.config.Page ||
+const preparePageContextForPublicUsage_js_1 = require("../../shared/preparePageContextForPublicUsage.js");
+function preparePageContextForPublicUsageClientShared(pageContext) {
+    // TODO/now use proxy
+    const Page = pageContext.config?.Page ||
         // TODO/next-major-release: remove
-        pageContext.exports.Page;
+        pageContext.exports?.Page;
     (0, utils_js_1.objectAssign)(pageContext, { Page });
+    // TODO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
+    (0, preparePageContextForPublicUsage_js_1.assertPropertyGetters)(pageContext);
     // TODO/next-major-release: remove
     // - Requires https://github.com/vikejs/vike-vue/issues/198
     // - Last time I tried to remove it (https://github.com/vikejs/vike/commit/705fd23598d9d69bf46a52c8550216cd7117ce71) the tests were failing as expected: only the Vue integrations that used shallowReactive() failed.
     supportVueReactiviy(pageContext);
-    (0, preparePageContextForUserConsumption_js_1.preparePageContextForUserConsumption)(pageContext);
-    const pageContextProxy = (0, getPageContextProxyForUser_js_1.getPageContextProxyForUser)(pageContext);
-    return pageContextProxy;
+    return preparePageContextForPublicUsageClientMinimal(pageContext);
+}
+function preparePageContextForPublicUsageClientMinimal(pageContext) {
+    const pageContextPublic = (0, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage)(pageContext);
+    return pageContextPublic;
 }
 // With Vue + Cient Routing, the `pageContext` is made reactive:
 // ```js
@@ -39,6 +34,7 @@ function supportVueReactiviy(pageContext) {
 // Remove propery descriptor getters because they break Vue's reactivity.
 // E.g. resolve the `pageContext.urlPathname` getter.
 function resolveGetters(pageContext) {
+    return;
     Object.entries(pageContext).forEach(([key, val]) => {
         delete pageContext[key];
         pageContext[key] = val;

package/dist/cjs/node/api/build.js

@@ -1,12 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = build;
 const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
 const vite_1 = require("vite");
-const assert_1 = __importDefault(require("assert"));
 const context_js_1 = require("../cli/context.js");
 const context_js_2 = require("../prerender/context.js");
 const utils_js_1 = require("./utils.js");
@@ -38,7 +34,7 @@ async function build(options = {}) {
         await (0, vite_1.build)(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
         if ((0, context_js_1.isVikeCli)() && (0, context_js_2.isPrerendering)())
-            (0, assert_1.default)(false);
+            (0, utils_js_1.assert)(false);
     }
     return {
     /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`

package/dist/cjs/node/plugin/shared/loggerNotProd.js

@@ -27,7 +27,7 @@ const log_js_1 = require("./loggerNotProd/log.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isNewError_js_1 = require("../../runtime/renderPage/isNewError.js");
 const loggerProd_js_1 = require("../../runtime/renderPage/loggerProd.js");
-const executeHook_js_1 = require("../../../shared/hooks/executeHook.js");
+const execHook_js_1 = require("../../../shared/hooks/execHook.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 (0, loggerRuntime_js_1.overwriteRuntimeProductionLogger)(logRuntimeError, logRuntimeInfo);
 (0, utils_js_1.overwriteAssertProductionLogger)(assertLogger);
@@ -97,7 +97,7 @@ function logErr(err, httpRequestId = null, errorComesFromVite) {
         }
     }
     // Needs to be after assertion messages handling, because user hooks may throw an assertion error
-    const hook = (0, executeHook_js_1.isUserHookError)(err);
+    const hook = (0, execHook_js_1.isUserHookError)(err);
     if (hook) {
         const { hookName, hookFilePath } = hook;
         (0, log_js_1.logWithVikeTag)(picocolors_1.default.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`), 'error', category);

package/dist/cjs/node/prerender/runPrerender.js

@@ -61,7 +61,7 @@ const getHook_js_1 = require("../../shared/hooks/getHook.js");
 const noRouteMatch_js_1 = require("../../shared/route/noRouteMatch.js");
 const getVikeConfig_js_1 = require("../plugin/plugins/importUserCode/v1-design/getVikeConfig.js");
 const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
-const executeHook_js_1 = require("../../shared/hooks/executeHook.js");
+const execHook_js_1 = require("../../shared/hooks/execHook.js");
 const prepareViteApiCall_js_1 = require("../api/prepareViteApiCall.js");
 const context_js_1 = require("./context.js");
 const resolvePrerenderConfig_js_1 = require("./resolvePrerenderConfig.js");
@@ -70,6 +70,8 @@ const context_js_2 = require("../cli/context.js");
 const isViteCliCall_js_1 = require("../plugin/shared/isViteCliCall.js");
 const commonConfig_js_1 = require("../plugin/plugins/commonConfig.js");
 const node_fs_1 = __importDefault(require("node:fs"));
+const getProxyForPublicUsage_js_1 = require("../../shared/getProxyForPublicUsage.js");
+const docLink = 'https://vike.dev/i18n#pre-rendering';
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -132,7 +134,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
-    const { globalContext, globalContext_public } = await (0, globalContext_js_1.getGlobalContextServerInternal)();
+    const { globalContext } = await (0, globalContext_js_1.getGlobalContextServerInternal)();
     globalContext._pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {
         pageContexts: [],
@@ -145,13 +147,13 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext);
     // Allow user to create `pageContext` for parameterized routes and/or bulk data fetching
     // https://vike.dev/onBeforePrerenderStart
-    await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, globalContext_public, concurrencyLimit, doNotPrerenderList);
+    await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
     // Create `pageContext` for each page with a static route
     const urlList = getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList);
-    await createPageContexts(urlList, prerenderContext, globalContext, globalContext_public, concurrencyLimit, false);
+    await createPageContexts(urlList, prerenderContext, globalContext, concurrencyLimit, false);
     // Create `pageContext` for 404 page
     const urlList404 = getUrlList404(globalContext);
-    await createPageContexts(urlList404, prerenderContext, globalContext, globalContext_public, concurrencyLimit, true);
+    await createPageContexts(urlList404, prerenderContext, globalContext, concurrencyLimit, true);
     // Allow user to duplicate the list of `pageContext` for i18n
     // https://vike.dev/onPrerenderStart
     await callOnPrerenderStartHook(prerenderContext, globalContext, concurrencyLimit);
@@ -170,8 +172,8 @@ async function runPrerender(options = {}, standaloneTrigger) {
         console.log(`${picocolors_1.default.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
     await warnMissingPages(prerenderContext._prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
-    const prerenderContextPublic = makePublic(prerenderContext);
-    (0, utils_js_1.objectAssign)(vike.prerenderContext, prerenderContextPublic);
+    const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
+    (0, utils_js_1.objectAssign)(vike.prerenderContext, prerenderContextPublic, true);
     if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
         node_fs_1.default.rmSync(outDirServer, { recursive: true });
     }
@@ -233,7 +235,7 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     (0, utils_js_1.assert)(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext, globalContext_public, concurrencyLimit, doNotPrerenderList) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
     // V1 design
     await Promise.all(globalContext._pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
@@ -276,10 +278,11 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             hookTimeout: (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerenderStart')
         });
     })));
-    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId, hookTimeout }) => concurrencyLimit(async () => {
+    await Promise.all(onBeforePrerenderStartHooks.map(({ pageId, ...hook }) => concurrencyLimit(async () => {
         if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
-        const prerenderResult = await (0, executeHook_js_1.executeHook)(() => hookFn(), { hookName, hookFilePath, hookTimeout }, null);
+        const { hookName, hookFilePath } = hook;
+        const prerenderResult = await (0, execHook_js_1.execHookWithoutPageContext)(() => hook.hookFn(), hook);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
@@ -296,7 +299,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             }
             // Add result
             const providedByHook = { hookFilePath, hookName };
-            const pageContextNew = await createPageContextPrerendering(url, prerenderContext, globalContext, globalContext_public, false, undefined, providedByHook);
+            const pageContextNew = await createPageContextPrerendering(url, prerenderContext, globalContext, false, undefined, providedByHook);
             prerenderContext.pageContexts.push(pageContextNew);
             if (pageContext) {
                 (0, utils_js_1.objectAssign)(pageContextNew, { _pageContextAlreadyProvidedByOnPrerenderHook: true });
@@ -342,22 +345,22 @@ function getUrlList404(globalContext) {
     }
     return urlList;
 }
-async function createPageContexts(urlList, prerenderContext, globalContext, globalContext_public, concurrencyLimit, is404) {
+async function createPageContexts(urlList, prerenderContext, globalContext, concurrencyLimit, is404) {
     await Promise.all(urlList.map(({ urlOriginal, pageId }) => concurrencyLimit(async () => {
         // Already included in a onBeforePrerenderStart() hook
         if (prerenderContext.pageContexts.find((pageContext) => isSameUrl(pageContext.urlOriginal, urlOriginal))) {
             return;
         }
-        const pageContext = await createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, globalContext_public, is404, pageId, null);
+        const pageContext = await createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, is404, pageId, null);
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-async function createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, globalContext_public, is404, pageId, providedByHook) {
+async function createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, is404, pageId, providedByHook) {
     const pageContextInit = {
         urlOriginal,
         ...prerenderContext._pageContextInit
     };
-    const pageContext = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, globalContext_public, {
+    const pageContext = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, {
         isPrerendering: true
     });
     (0, utils_js_1.assert)(pageContext.isPrerendering === true);
@@ -501,26 +504,13 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         (0, utils_js_1.assert)(pageContext.urlOriginal);
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
-    const docLink = 'https://vike.dev/i18n#pre-rendering';
     prerenderContext.pageContexts.forEach((pageContext) => {
         // Preserve URL computed properties when the user is copying pageContext is his onPrerenderStart() hook, e.g. /examples/i18n/
         // https://vike.dev/i18n#pre-rendering
         (0, utils_js_1.preservePropertyGetters)(pageContext);
     });
-    let result = await (0, executeHook_js_1.executeHook)(() => {
-        const prerenderContextPublic = makePublic(prerenderContext);
-        // TODO/v1-release: remove warning
-        Object.defineProperty(prerenderContextPublic, 'prerenderPageContexts', {
-            get() {
-                (0, utils_js_1.assertWarning)(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
-                    showStackTrace: true,
-                    onlyOnce: true
-                });
-                return prerenderContext.pageContexts;
-            }
-        });
-        return hookFn(prerenderContextPublic);
-    }, onPrerenderStartHook, null);
+    const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
+    let result = await (0, execHook_js_1.execHookWithoutPageContext)(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;
@@ -760,7 +750,7 @@ function assertIsNotAbort(err, urlOriginal) {
     if (!(0, abort_js_1.isAbortError)(err))
         return;
     const pageContextAbort = err._pageContextAbort;
-    const hookLoc = (0, executeHook_js_1.isUserHookError)(err);
+    const hookLoc = (0, execHook_js_1.isUserHookError)(err);
     (0, utils_js_1.assert)(hookLoc);
     const thrownBy = ` by ${picocolors_1.default.cyan(`${hookLoc.hookName}()`)} hook defined at ${hookLoc.hookFilePath}`;
     const abortCaller = pageContextAbort._abortCaller;
@@ -769,10 +759,24 @@ function assertIsNotAbort(err, urlOriginal) {
     (0, utils_js_1.assert)(abortCall);
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOriginal} but ${picocolors_1.default.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
-function makePublic(prerenderContext) {
-    const prerenderContextPublic = (0, utils_js_1.getPublicProxy)(prerenderContext, 'prerenderContext', [
-        'output', // vite-plugin-vercel
-        'pageContexts' // https://vike.dev/i18n#pre-rendering
-    ]);
+function preparePrerenderContextForPublicUsage(prerenderContext) {
+    // TODO/v1-release: remove
+    if (!('prerenderPageContexts' in prerenderContext)) {
+        Object.defineProperty(prerenderContext, 'prerenderPageContexts', {
+            get() {
+                (0, utils_js_1.assertWarning)(false, `prerenderPageContexts has been renamed pageContexts, see ${picocolors_1.default.underline(docLink)}`, {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return prerenderContext.pageContexts;
+            }
+        });
+    }
+    // Required because of https://vike.dev/i18n#pre-rendering
+    // - Thus, we have to let users access the original pageContext object => we cannot use ES proxies and we cannot use preparePageContextForPublicUsage()
+    prerenderContext.pageContexts.forEach((pageContext) => {
+        (0, utils_js_1.changeEnumerable)(pageContext, '_isOriginalObject', true);
+    });
+    const prerenderContextPublic = (0, getProxyForPublicUsage_js_1.getProxyForPublicUsage)(prerenderContext, 'prerenderContext');
     return prerenderContextPublic;
 }

package/dist/cjs/node/prerender/utils.js

@@ -31,6 +31,6 @@ __exportStar(require("../../utils/pLimit.js"), exports);
 __exportStar(require("../../utils/isFilePathAbsoluteFilesystem.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
-__exportStar(require("../../utils/getPublicProxy.js"), exports);
 __exportStar(require("../../utils/isNullish.js"), exports);
 __exportStar(require("../../utils/preservePropertyGetters.js"), exports);
+__exportStar(require("../../utils/changeEnumerable.js"), exports);

package/dist/cjs/node/runtime/globalContext.js

@@ -36,6 +36,7 @@ const loadPageRoutes_js_1 = require("../../shared/route/loadPageRoutes.js");
 const assertV1Design_js_1 = require("../shared/assertV1Design.js");
 const resolveBase_js_1 = require("../shared/resolveBase.js");
 const createGlobalContextShared_js_1 = require("../../shared/createGlobalContextShared.js");
+const prepareGlobalContextForPublicUsage_js_1 = require("../../shared/prepareGlobalContextForPublicUsage.js");
 const debug = (0, utils_js_1.createDebugger)('vike:globalContext');
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/globalContext.ts', getInitialGlobalContext());
 // Trick to break down TypeScript circular dependency
@@ -47,10 +48,9 @@ async function getGlobalContextServerInternal() {
     assertGlobalContextIsDefined();
     if (globalObject.isProduction !== true)
         await globalObject.waitForUserFilesUpdate;
-    const { globalContext, globalContext_public } = globalObjectTyped;
+    const { globalContext } = globalObjectTyped;
     assertIsDefined(globalContext);
-    (0, utils_js_1.assert)(globalContext_public);
-    return { globalContext, globalContext_public };
+    return { globalContext };
 }
 function assertIsDefined(globalContext) {
     if (!globalContext) {
@@ -62,7 +62,6 @@ function assertIsDefined(globalContext) {
 function assertGlobalContextIsDefined() {
     assertIsDefined(globalObjectTyped.globalContext);
     (0, utils_js_1.assert)(globalObject.globalContext);
-    (0, utils_js_1.assert)(globalObject.globalContext_public);
 }
 // We purposely return GlobalContext instead of GlobalContextServer because `import { getGlobalContext } from 'vike'` can resolve to the client-side implementation.
 /**
@@ -92,9 +91,7 @@ async function getGlobalContextAsync(isProduction) {
     if (!isProduction)
         await globalObject.waitForUserFilesUpdate;
     assertGlobalContextIsDefined();
-    const { globalContext_public } = globalObjectTyped;
-    (0, utils_js_1.assert)(globalContext_public);
-    return globalContext_public;
+    return getGlobalContextForPublicUsage();
 }
 /**
  * Get runtime information about your app.
@@ -105,26 +102,19 @@ async function getGlobalContextAsync(isProduction) {
  */
 function getGlobalContextSync() {
     debug('getGlobalContextSync()');
-    const { globalContext_public } = globalObjectTyped;
-    (0, utils_js_1.assertUsage)(globalContext_public, createGlobalContextShared_js_1.getGlobalContextSyncErrMsg);
+    const { globalContext } = globalObjectTyped;
+    (0, utils_js_1.assertUsage)(globalContext, createGlobalContextShared_js_1.getGlobalContextSyncErrMsg);
     (0, utils_js_1.assertWarning)(false, 
     // We discourage users from using it because `pageContext.globalContext` is safer: I ain't sure but there could be race conditions when using `getGlobalContextSync()` inside React/Vue components upon HMR.
     // We're lying about "is going to be deprecated in the next major release": let's keep it and see if users need it (so far I can't see a use case for it).
     'getGlobalContextSync() is going to be deprecated in the next major release, see https://vike.dev/getGlobalContext', { onlyOnce: true });
-    return globalContext_public;
-}
-function makePublic(globalContext) {
-    const globalContextPublic = (0, utils_js_1.getPublicProxy)(globalContext, 'globalContext', [
-        'assetsManifest',
-        'config',
-        'viteConfig',
-        'viteConfigRuntime',
-        'pages',
-        'baseServer',
-        'baseAssets',
-        'isClientSide'
-    ], true);
-    return globalContextPublic;
+    return getGlobalContextForPublicUsage();
+}
+function getGlobalContextForPublicUsage() {
+    const { globalContext } = globalObjectTyped;
+    (0, utils_js_1.assert)(globalContext);
+    const globalContextForPublicUsage = (0, prepareGlobalContextForPublicUsage_js_1.prepareGlobalContextForPublicUsage)(globalContext);
+    return globalContextForPublicUsage;
 }
 async function setGlobalContext_viteDevServer(viteDevServer) {
     debug('setGlobalContext_viteDevServer()');
@@ -338,8 +328,6 @@ async function setGlobalContext(virtualFileExports) {
     (0, assertV1Design_js_1.assertV1Design)(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);
-    // Public usage
-    globalObject.globalContext_public = makePublic(globalContext);
     assertGlobalContextIsDefined();
     (0, utils_js_1.onSetupRuntime)();
     // Never actually used, only used for TypeScript `ReturnType<typeof setGlobalContext>`
@@ -361,7 +349,6 @@ async function addGlobalContext(globalContext) {
         (0, utils_js_1.assert)(viteConfigRuntime);
         (0, utils_js_1.assert)(!isPrerendering);
         return {
-            ...globalContext,
             ...globalContextBase,
             ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
             _isProduction: false,
@@ -379,7 +366,6 @@ async function addGlobalContext(globalContext) {
         (0, utils_js_1.assert)(buildInfo);
         (0, utils_js_1.assert)(assetsManifest);
         const globalContextBase2 = {
-            ...globalContext,
             ...globalContextBase,
             ...resolveBaseRuntime(buildInfo.viteConfigRuntime, globalContext.config),
             _isProduction: true,

package/dist/cjs/node/runtime/html/serializeContext.js

@@ -41,7 +41,7 @@ function getPageContextClientSerialized(pageContext) {
 }
 function getGlobalContextClientSerialized(pageContext) {
     const passToClient = pageContext._passToClient;
-    const globalContextClient = applyPassToClient(passToClient, pageContext.globalContext);
+    const globalContextClient = applyPassToClient(passToClient, pageContext._globalContext);
     const globalContextClientSerialized = serializeObject(globalContextClient, 'globalContext', passToClient);
     return globalContextClientSerialized;
 }

package/dist/cjs/node/runtime/renderPage/createPageContextServerSide.js

@@ -5,18 +5,13 @@ exports.createPageContextServerSideWithoutGlobalContext = createPageContextServe
 const utils_js_1 = require("../utils.js");
 const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
 const createPageContextShared_js_1 = require("../../../shared/createPageContextShared.js");
-async function createPageContextServerSide(pageContextInit, globalContext, globalObject_public, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
+async function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
     urlHandler: null,
     isClientSideNavigation: false
 } }) {
     (0, utils_js_1.assert)(pageContextInit.urlOriginal);
     const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
     (0, utils_js_1.objectAssign)(pageContextCreated, {
-        /* Don't spread globalContext for now? Or never spread it as it leads to confusion? The convenience isn't worth the added confusion?
-        // We must use Flatten<T> otherwise TypeScript complains upon assigning types
-        ...(globalContext as Flatten<typeof globalContext>), // least precedence
-        */
-        globalContext: globalObject_public,
         _globalContext: globalContext,
         // The following is defined on `pageContext` because we can eventually make these non-global
         _baseServer: globalContext.baseServer,
@@ -65,10 +60,11 @@ function createPageContextServerSideWithoutGlobalContext(pageContextInit) {
     return pageContext;
 }
 function createPageContext(pageContextInit, isPrerendering) {
-    const pageContext = {
+    const pageContext = (0, createPageContextShared_js_1.createPageContextObject)();
+    (0, utils_js_1.objectAssign)(pageContext, {
         isClientSide: false,
         isPrerendering
-    };
+    });
     (0, utils_js_1.objectAssign)(pageContext, pageContextInit);
     return pageContext;
 }

package/dist/cjs/node/runtime/renderPage/execHookServer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execHookServer = execHookServer;
+const execHook_js_1 = require("../../../shared/hooks/execHook.js");
+const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContextForPublicUsageServer.js");
+async function execHookServer(hookName, pageContext) {
+    return await (0, execHook_js_1.execHook)(hookName, pageContext, (p) => {
+        (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(p);
+        return p;
+    });
+}

package/dist/cjs/node/runtime/renderPage/executeOnBeforeRenderAndDataHooks.js

@@ -2,30 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeOnBeforeRenderAndDataHooks = executeOnBeforeRenderAndDataHooks;
 const assertOnBeforeRenderHookReturn_js_1 = require("../../../shared/assertOnBeforeRenderHookReturn.js");
-const executeHookServer_js_1 = require("./executeHookServer.js");
+const execHookServer_js_1 = require("./execHookServer.js");
 async function executeOnBeforeRenderAndDataHooks(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;
     }
-    const hooks = await (0, executeHookServer_js_1.executeHookServer)('data', pageContext);
+    const hooks = await (0, execHookServer_js_1.execHookServer)('data', pageContext);
     const dataHook = hooks[0]; // TO-DO/soon: support cumulative
     if (dataHook) {
-        // Note: hookResult can be anything (e.g. an object) and is to be assigned to pageContext.data
+        // Note: hookReturn can be anything (e.g. an object) and is to be assigned to pageContext.data
         const pageContextFromHook = {
-            data: dataHook.hookResult
+            data: dataHook.hookReturn
         };
         Object.assign(pageContext, pageContextFromHook);
         // Execute +onData
         if (!pageContext.isClientSideNavigation) {
-            await (0, executeHookServer_js_1.executeHookServer)('onData', pageContext);
+            await (0, execHookServer_js_1.execHookServer)('onData', pageContext);
         }
     }
-    const res = await (0, executeHookServer_js_1.executeHookServer)('onBeforeRender', pageContext);
+    const res = await (0, execHookServer_js_1.execHookServer)('onBeforeRender', pageContext);
     const onBeforeRenderHook = res[0]; // TO-DO/soon: support cumulative
     if (onBeforeRenderHook) {
-        const { hookResult } = onBeforeRenderHook;
-        (0, assertOnBeforeRenderHookReturn_js_1.assertOnBeforeRenderHookReturn)(hookResult, onBeforeRenderHook.hookFilePath);
-        const pageContextFromHook = hookResult?.pageContext;
+        const { hookReturn } = onBeforeRenderHook;
+        (0, assertOnBeforeRenderHookReturn_js_1.assertOnBeforeRenderHookReturn)(hookReturn, onBeforeRenderHook.hookFilePath);
+        const pageContextFromHook = hookReturn?.pageContext;
         Object.assign(pageContext, pageContextFromHook);
     }
 }

package/dist/cjs/node/runtime/renderPage/executeOnRenderHtmlHook.js

@@ -9,17 +9,16 @@ const getHook_js_1 = require("../../../shared/hooks/getHook.js");
 const utils_js_1 = require("../utils.js");
 const stream_js_1 = require("../html/stream.js");
 const assertPageContextProvidedByUser_js_1 = require("../../../shared/assertPageContextProvidedByUser.js");
-const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePageContextForUserConsumptionServerSide.js");
+const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContextForPublicUsageServer.js");
 const assertHookReturnedObject_js_1 = require("../../../shared/assertHookReturnedObject.js");
 const loggerRuntime_js_1 = require("./loggerRuntime.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const executeHook_js_1 = require("../../../shared/hooks/executeHook.js");
+const execHook_js_1 = require("../../../shared/hooks/execHook.js");
 async function executeOnRenderHtmlHook(pageContext) {
-    const { renderHook, hookFn } = getRenderHook(pageContext);
-    (0, utils_js_1.objectAssign)(pageContext, { _renderHook: renderHook });
-    (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
-    const hookReturnValue = await (0, executeHook_js_1.executeHook)(() => hookFn(pageContext), renderHook, pageContext);
-    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
+    const hook = getRenderHook(pageContext);
+    (0, utils_js_1.objectAssign)(pageContext, { _renderHook: hook });
+    const { hookReturn } = await (0, execHook_js_1.execHookSingleWithReturn)(hook, pageContext, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer);
+    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     (0, utils_js_1.objectAssign)(pageContext, { _pageContextPromise: pageContextPromise });
     const onErrorWhileStreaming = (err) => {
@@ -34,7 +33,7 @@ async function executeOnRenderHtmlHook(pageContext) {
     };
     const htmlRender = await (0, renderHtml_js_1.renderDocumentHtml)(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
     (0, utils_js_1.assert)(typeof htmlRender === 'string' || (0, stream_js_1.isStream)(htmlRender));
-    return { htmlRender, renderHook };
+    return { htmlRender, renderHook: hook };
 }
 function getRenderHook(pageContext) {
     let hookFound;
@@ -54,10 +53,7 @@ function getRenderHook(pageContext) {
         if (hook) {
             (0, utils_js_1.assert)(hookName);
             const { hookFilePath, hookFn, hookTimeout } = hook;
-            hookFound = {
-                hookFn,
-                renderHook: { hookFn, hookFilePath, hookName, hookTimeout }
-            };
+            hookFound = { hookFn, hookFilePath, hookName, hookTimeout };
         }
     }
     if (!hookFound) {

package/dist/cjs/node/runtime/renderPage/preparePageContextForPublicUsageServer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePageContextForPublicUsageServer = preparePageContextForPublicUsageServer;
+const preparePageContextForPublicUsage_js_1 = require("../../../shared/preparePageContextForPublicUsage.js");
+function preparePageContextForPublicUsageServer(pageContext) {
+    // TODO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
+    (0, preparePageContextForPublicUsage_js_1.assertPropertyGetters)(pageContext);
+    pageContext = (0, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage)(pageContext);
+    return pageContext;
+}

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -15,7 +15,7 @@ const executeOnRenderHtmlHook_js_1 = require("./executeOnRenderHtmlHook.js");
 const executeOnBeforeRenderAndDataHooks_js_1 = require("./executeOnBeforeRenderAndDataHooks.js");
 const loggerRuntime_js_1 = require("./loggerRuntime.js");
 const isNewError_js_1 = require("./isNewError.js");
-const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePageContextForUserConsumptionServerSide.js");
+const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContextForPublicUsageServer.js");
 const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
@@ -28,7 +28,7 @@ async function renderPageAlreadyRouted(pageContext) {
     (0, utils_js_1.assert)(isError === (pageContext.pageId === (0, error_page_js_1.getErrorPageId)(pageContext._pageFilesAll, pageContext._pageConfigs)));
     (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
     if (!isError) {
-        await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext));
+        await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(pageContext));
     }
     if (!isError) {
         await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
@@ -65,7 +65,7 @@ async function prerenderPage(pageContext) {
     });
     /* Should we execute the guard() hook upon pre-rendering? Is there a use case for this?
      *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling
-    await executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionServerSide(pageContext))
+    await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
     */
     await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
     const { htmlRender, renderHook } = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);

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

@@ -24,6 +24,7 @@ const error_page_js_1 = require("../../shared/error-page.js");
 const handleErrorWithoutErrorPage_js_1 = require("./renderPage/handleErrorWithoutErrorPage.js");
 const loadPageConfigsLazyServerSide_js_1 = require("./renderPage/loadPageConfigsLazyServerSide.js");
 const resolveRedirects_js_1 = require("./renderPage/resolveRedirects.js");
+const getProxyForPublicUsage_js_1 = require("../../shared/getProxyForPublicUsage.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage.ts', {
     httpRequestsCount: 0
 });
@@ -81,8 +82,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 (0, globalContext_js_1.getGlobalContextServerInternal)();
-    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId);
+    const { globalContext } = await (0, globalContext_js_1.getGlobalContextServerInternal)();
+    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, httpRequestId);
     // Check Base URL
     {
         const pageContextHttpResponse = await checkBaseUrl(pageContextBegin, globalContext);
@@ -304,9 +305,9 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
     (0, utils_js_1.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 (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, globalContext_public, {
+    const pageContextBegin = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, {
         isPrerendering: false,
         ssr: {
             urlHandler: _urlHandler,
@@ -488,5 +489,6 @@ function getPageContextInvalidVikeConfig(err, pageContextInit, httpRequestId) {
 function forkPageContext(pageContextBegin) {
     const pageContext = {};
     (0, utils_js_1.objectAssign)(pageContext, pageContextBegin, true);
-    return pageContext;
+    const pageContextWithProxy = (0, getProxyForPublicUsage_js_1.getProxyForMutationTracking)(pageContext);
+    return pageContextWithProxy;
 }

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

@@ -74,5 +74,5 @@ __exportStar(require("../../utils/isVikeReactApp.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/genPromise.js"), exports);
-__exportStar(require("../../utils/getPublicProxy.js"), exports);
 __exportStar(require("../../utils/augmentType.js"), exports);
+__exportStar(require("../../utils/changeEnumerable.js"), exports);