vike 0.4.196-commit-df033dd → 0.4.197

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -164,7 +164,7 @@ async function hasPageContextServer(pageContext) {
 async function hookServerOnlyExists(hookName, pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
-        const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
+        const pageConfig = getPageConfig(pageContext.pageId, pageContext._pageConfigs);
         const hookEnv = getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {};
         assert(isObject(hookEnv));
         return !!hookEnv.server && !hookEnv.client;
@@ -176,7 +176,7 @@ async function hookServerOnlyExists(hookName, pageContext) {
         if (hookName === 'data')
             return false;
         assert(hookName === 'onBeforeRender');
-        const { hasOnBeforeRenderServerSideOnlyHook } = await analyzePageServerSide(pageContext._pageFilesAll, pageContext._pageId);
+        const { hasOnBeforeRenderServerSideOnlyHook } = await analyzePageServerSide(pageContext._pageFilesAll, pageContext.pageId);
         return hasOnBeforeRenderServerSideOnlyHook;
     }
 }
@@ -188,7 +188,7 @@ async function hookServerOnlyExists(hookName, pageContext) {
 function hookClientOnlyExists(hookName, pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
-        const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
+        const pageConfig = getPageConfig(pageContext.pageId, pageContext._pageConfigs);
         const hookEnv = getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {};
         assert(isObject(hookEnv));
         return !!hookEnv.client && !hookEnv.server;
@@ -223,7 +223,7 @@ async function fetchPageContextFromServer(pageContext) {
     if ('serverSideError' in pageContextFromServer || isServerSideError in pageContextFromServer) {
         throw getProjectError(`pageContext couldn't be fetched because an error occurred on the server-side`);
     }
-    assert(hasProp(pageContextFromServer, '_pageId', 'string'));
+    assert(hasProp(pageContextFromServer, 'pageId', 'string'));
     processPageContextFromServer(pageContextFromServer);
     return { pageContextFromServer };
 }

package/dist/esm/client/client-routing-runtime/prefetch.js

@@ -51,7 +51,7 @@ async function prefetch(url) {
         // If a route() hook has a bug or `throw render()` / `throw redirect()`
         return;
     }
-    const pageId = pageContextFromRoute._pageId;
+    const pageId = pageContextFromRoute.pageId;
     if (!pageId) {
         assertWarning(false, `${errPrefix} ${pc.string(url)} ${noRouteMatch}`, {
             showStackTrace: true,
@@ -109,9 +109,9 @@ async function prefetchIfPossible(url) {
         // If a route() hook has a bug or `throw render()` / `throw redirect()`
         return;
     }
-    if (!pageContextFromRoute?._pageId)
+    if (!pageContextFromRoute?.pageId)
         return;
-    if (!(await isClientSideRoutable(pageContextFromRoute._pageId, pageContext)))
+    if (!(await isClientSideRoutable(pageContextFromRoute.pageId, pageContext)))
         return;
-    await prefetchAssets(pageContextFromRoute._pageId, pageContext);
+    await prefetchAssets(pageContextFromRoute.pageId, pageContext);
 }

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -2,7 +2,7 @@ export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
-import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType, genPromise } from './utils.js';
+import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType, genPromise, isCallable } from './utils.js';
 import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
@@ -18,6 +18,7 @@ import { setScrollPosition } from './setScrollPosition.js';
 import { updateState } from './onBrowserHistoryNavigation.js';
 import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from './scrollRestoration.js';
 import { getErrorPageId } from '../../shared/error-page.js';
+import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 const globalObject = getGlobalObject('renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
@@ -28,7 +29,8 @@ const globalObject = getGlobalObject('renderPageClientSide.ts', (() => {
 })());
 const { firstRenderStartPromise } = globalObject;
 async function renderPageClientSide(renderArgs) {
-    const { scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
+    const { urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
+    let { scrollTarget } = renderArgs;
     const { previousPageContext } = globalObject;
     const { isRenderOutdated, setHydrationCanBeAborted, isFirstRender } = getIsRenderOutdated();
     // Note that pageContext.isHydration isn't equivalent to isFirstRender
@@ -93,7 +95,7 @@ async function renderPageClientSide(renderArgs) {
             }
             if (isRenderOutdated())
                 return;
-            if (!pageContextFromRoute._pageId) {
+            if (!pageContextFromRoute.pageId) {
                 /*
                 // We don't use the client router to render the 404 page:
                 //  - So that the +redirects setting (https://vike.dev/redirects) can be applied.
@@ -106,17 +108,17 @@ async function renderPageClientSide(renderArgs) {
                 redirectHard(urlOriginal);
                 return;
             }
-            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
-            const isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
+            assert(hasProp(pageContextFromRoute, 'pageId', 'string')); // Help TS
+            const isClientRoutable = await isClientSideRoutable(pageContextFromRoute.pageId, pageContext);
             if (isRenderOutdated())
                 return;
             if (!isClientRoutable) {
                 redirectHard(urlOriginal);
                 return;
             }
-            const isSamePage = pageContextFromRoute._pageId &&
-                previousPageContext?._pageId &&
-                pageContextFromRoute._pageId === previousPageContext._pageId;
+            const isSamePage = pageContextFromRoute.pageId &&
+                previousPageContext?.pageId &&
+                pageContextFromRoute.pageId === previousPageContext.pageId;
             if (isUserLandPushStateNavigation && isSamePage) {
                 // Skip's Vike's rendering; let the user handle the navigation
                 return;
@@ -126,7 +128,7 @@ async function renderPageClientSide(renderArgs) {
         assert(!('urlOriginal' in pageContextRouted));
         objectAssign(pageContext, pageContextRouted);
         try {
-            objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -284,9 +286,9 @@ async function renderPageClientSide(renderArgs) {
         if (!errorPageId)
             throw new Error('No error page defined.');
         objectAssign(pageContext, {
-            _pageId: errorPageId
+            pageId: errorPageId
         });
-        const isClientRoutable = await isClientSideRoutable(pageContext._pageId, pageContext);
+        const isClientRoutable = await isClientSideRoutable(pageContext.pageId, pageContext);
         if (isRenderOutdated())
             return;
         if (!isClientRoutable) {
@@ -294,7 +296,7 @@ async function renderPageClientSide(renderArgs) {
             return;
         }
         try {
-            objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -323,6 +325,7 @@ async function renderPageClientSide(renderArgs) {
         if ('is404ServerSideRouted' in res)
             return;
         augmentType(pageContext, res.pageContextAugmented);
+        objectAssign(pageContext, { routeParams: {} });
         await renderPageView(pageContext, args);
     }
     async function renderPageView(pageContext, isErrorPage) {
@@ -411,6 +414,15 @@ async function renderPageClientSide(renderArgs) {
                     return;
             }
         }
+        if (!scrollTarget && previousPageContext) {
+            const keepScrollPositionPrev = getKeepScrollPositionSetting(previousPageContext);
+            const keepScrollPositionNext = getKeepScrollPositionSetting(pageContext);
+            if (keepScrollPositionNext !== false &&
+                keepScrollPositionPrev !== false &&
+                areKeysEqual(keepScrollPositionNext, keepScrollPositionPrev)) {
+                scrollTarget = { preserveScroll: true };
+            }
+        }
         // Page scrolling
         setScrollPosition(scrollTarget);
         browserNativeScrollRestoration_disable();
@@ -486,3 +498,38 @@ function getIsRenderOutdated() {
 function getRenderCount() {
     return globalObject.renderCounter;
 }
+function getKeepScrollPositionSetting(pageContext) {
+    const c = pageContext.from.configsStandard.keepScrollPosition;
+    if (!c)
+        return false;
+    let val = c.value;
+    const configDefinedAt = c.definedAt;
+    assert(configDefinedAt);
+    const routeParameterList = getRouteStringParameterList(configDefinedAt);
+    if (isCallable(val))
+        val = val(pageContext, {
+            configDefinedAt: c.definedAt
+            /* We don't pass routeParameterList because it's useless: the user knows the parameter list.
+            routeParameterList
+            */
+        });
+    if (val === true) {
+        return [
+            configDefinedAt,
+            ...routeParameterList.map((param) => {
+                const val = pageContext.routeParams[param];
+                assert(val);
+                return val;
+            })
+        ];
+    }
+    // We skip validation and type-cast instead of assertUsage() in order to save client-side KBs
+    return val;
+}
+function areKeysEqual(key1, key2) {
+    if (key1 === key2)
+        return true;
+    if (!Array.isArray(key1) || !Array.isArray(key2))
+        return false;
+    return key1.length === key2.length && key1.every((_, i) => key1[i] === key2[i]);
+}

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -1,6 +1,6 @@
 export { getPageContext };
 declare function getPageContext(): Promise<{
-    _pageId: string;
+    pageId: string;
     routeParams: Record<string, string>;
 } & {
     isHydration: true;

package/dist/esm/client/server-routing-runtime/getPageContext.js

@@ -12,7 +12,7 @@ async function getPageContext() {
         _hasPageContextFromServer: true,
         _hasPageContextFromClient: false
     });
-    objectAssign(pageContext, await loadPageUserFiles(pageContext._pageId));
+    objectAssign(pageContext, await loadPageUserFiles(pageContext.pageId));
     assertPristineUrl();
     return pageContext;
 }

package/dist/esm/client/shared/executeOnRenderClientHook.d.ts

@@ -7,7 +7,7 @@ type PageContextBeforeRenderClient = {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;
     urlPathname?: string;
-    _pageId: string;
+    pageId: string;
     _pageConfigs: PageConfigRuntime[];
 } & PageContextExports & PageContextForUserConsumptionClientSide;
 declare function executeOnRenderClientHook<PC extends PageContextBeforeRenderClient>(pageContext: PC, isClientRouting: boolean): Promise<void>;

package/dist/esm/client/shared/getPageContextSerializedInHtml.d.ts

@@ -1,5 +1,5 @@
 export { getPageContextSerializedInHtml };
 declare function getPageContextSerializedInHtml(): {
-    _pageId: string;
+    pageId: string;
     routeParams: Record<string, string>;
 };

package/dist/esm/client/shared/getPageContextSerializedInHtml.js

@@ -14,7 +14,7 @@ function getPageContextSerializedInHtml() {
     const pageContextJson = elem.textContent;
     assert(pageContextJson);
     const pageContextSerializedInHtml = parse(pageContextJson);
-    assert(hasProp(pageContextSerializedInHtml, '_pageId', 'string'));
+    assert(hasProp(pageContextSerializedInHtml, 'pageId', 'string'));
     assert(hasProp(pageContextSerializedInHtml, 'routeParams', 'string{}'));
     return pageContextSerializedInHtml;
 }

package/dist/esm/client/shared/preparePageContextForUserConsumptionClientSide.d.ts

@@ -4,7 +4,7 @@ import type { PageContextExports } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
 type PageContextForUserConsumptionClientSide = PageContextExports & PageContextForPassToClientWarning & {
-    _pageId: string;
+    pageId: string;
     _pageConfigs: PageConfigRuntime[];
 };
 declare function preparePageContextForUserConsumptionClientSide<T extends PageContextForUserConsumptionClientSide>(pageContext: T, isClientRouting: boolean): T & {

package/dist/esm/client/shared/preparePageContextForUserConsumptionClientSide.js

@@ -1,20 +1,7 @@
 export { preparePageContextForUserConsumptionClientSide };
-import { assert, isObject, objectAssign } from '../server-routing-runtime/utils.js';
-import { sortPageContext } from '../../shared/sortPageContext.js';
-import { addIs404ToPageProps } from '../../shared/addIs404ToPageProps.js';
+import { assert, objectAssign } from '../server-routing-runtime/utils.js';
 import { getPageContextProxyForUser } from './getPageContextProxyForUser.js';
-// Release `pageContext` for user consumption.
-//
-// This adds `assertPassToClient()`.
-//
-// With Vue support (when `pageContext` is made reactive with Vue).
-//
-// For Vue + Cient Routing, the `pageContext` needs to be made reactive:
-// ```js
-// import { reactive } from 'vue'
-// // See entire example at `/examples/vue-full/`
-// const pageContextReactive = reactive(pageContext)
-// ```
+import { preparePageContextForUserConsumption } from '../../shared/preparePageContextForUserConsumption.js';
 function preparePageContextForUserConsumptionClientSide(pageContext, isClientRouting) {
     if (isClientRouting) {
         const pageContextTyped = pageContext;
@@ -26,22 +13,26 @@ function preparePageContextForUserConsumptionClientSide(pageContext, isClientRou
         assert(pageContextTyped.isHydration === true);
         assert(pageContextTyped.isBackwardNavigation === null);
     }
-    assert('config' in pageContext);
-    assert('configEntries' in pageContext);
-    // TODO/v1-release: remove
-    assert('exports' in pageContext);
-    assert('exportsAll' in pageContext);
-    assert('pageExports' in pageContext);
-    assert(isObject(pageContext.pageExports));
-    const Page = pageContext.exports.Page;
+    const Page = pageContext.config.Page ||
+        // TODO/next-major-release: remove
+        pageContext.exports.Page;
     objectAssign(pageContext, { Page });
-    // For Vue's reactivity
+    // 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);
+    preparePageContextForUserConsumption(pageContext);
+    const pageContextProxy = getPageContextProxyForUser(pageContext);
+    return pageContextProxy;
+}
+// With Vue + Cient Routing, the `pageContext` is made reactive:
+// ```js
+// import { reactive } from 'vue'
+// // See /examples/vue-full/renderer/createVueApp.ts
+// const pageContextReactive = reactive(pageContext)
+// ```
+function supportVueReactiviy(pageContext) {
     resolveGetters(pageContext);
-    // For prettier `console.log(pageContext)`
-    sortPageContext(pageContext);
-    const pageContextForUserConsumption = getPageContextProxyForUser(pageContext);
-    addIs404ToPageProps(pageContext);
-    return pageContextForUserConsumption;
 }
 // Remove propery descriptor getters because they break Vue's reactivity.
 // E.g. resolve the `pageContext.urlPathname` getter.

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -120,6 +120,9 @@ const configDefinitionsBuiltIn = {
     },
     require: {
         env: { config: true }
+    },
+    keepScrollPosition: {
+        env: { client: true }
     }
 };
 const configDefinitionsBuiltInGlobal = {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -237,7 +237,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit) {
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
-        .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
+        .filter(([pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
         const interfaceFilesRelevantList = Object.values(interfaceFilesRelevant).flat(1);

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

@@ -278,7 +278,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
         objectAssign(pageContext, {
             _providedByHook: null,
             routeParams,
-            _pageId: pageId,
+            pageId: pageId,
             _debugRouteMatches: [
                 {
                     pageId,
@@ -441,8 +441,8 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
         const { urlOriginal } = pageContext;
         assert(urlOriginal);
         const pageContextFromRoute = await route(pageContext);
-        assert(hasProp(pageContextFromRoute, '_pageId', 'null') || hasProp(pageContextFromRoute, '_pageId', 'string'));
-        if (pageContextFromRoute._pageId === null) {
+        assert(hasProp(pageContextFromRoute, 'pageId', 'null') || hasProp(pageContextFromRoute, 'pageId', 'string'));
+        if (pageContextFromRoute.pageId === null) {
             let hookName;
             let hookFilePath;
             if (pageContext._providedByHook) {
@@ -464,9 +464,9 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
                 return;
             }
         }
-        assert(pageContextFromRoute._pageId);
+        assert(pageContextFromRoute.pageId);
         objectAssign(pageContext, pageContextFromRoute);
-        const { _pageId: pageId } = pageContext;
+        const { pageId: pageId } = pageContext;
         objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
         let usesClientRouter;
         {

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -14,7 +14,7 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
     assert([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
     const { isProduction } = getGlobalContext();
-    const injectScriptsAt = getInjectScriptsAt(pageContext._pageId, pageContext._pageConfigs);
+    const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
     const injectFilterEntries = pageAssets
         .filter((asset) => {
         if (asset.isEntry && asset.assetType === 'script') {

package/dist/esm/node/runtime/html/injectAssets/injectAssets__public.js

@@ -14,7 +14,7 @@ async function injectAssets__public(htmlString, pageContext) {
     assertUsage(hasProp(pageContext, 'urlPathname', 'string'), errMsg('`pageContext.urlPathname` should be a string'), {
         showStackTrace: true
     });
-    assertUsage(hasProp(pageContext, '_pageId', 'string'), errMsg('`pageContext._pageId` should be a string'), {
+    assertUsage(hasProp(pageContext, 'pageId', 'string'), errMsg('`pageContext.pageId` should be a string'), {
         showStackTrace: true
     });
     assertUsage(hasProp(pageContext, '__getPageAssets'), errMsg('`pageContext.__getPageAssets` is missing'), {

package/dist/esm/node/runtime/html/injectAssets.d.ts

@@ -11,7 +11,7 @@ import type { PageContextSerialization } from './serializePageContextClientSide.
 type PageContextInjectAssets = {
     urlPathname: string;
     __getPageAssets: () => Promise<PageAsset[]>;
-    _pageId: string;
+    pageId: string;
     _isHtmlOnly: boolean;
     _pageContextPromise: PageContextPromise;
     _renderHook: {

package/dist/esm/node/runtime/html/serializePageContextClientSide.d.ts

@@ -4,7 +4,7 @@ export type { PageContextSerialization };
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { UrlRedirect } from '../../../shared/route/abort.js';
 type PageContextSerialization = {
-    _pageId: string;
+    pageId: string;
     routeParams: Record<string, string>;
     _passToClient: string[];
     _pageConfigs: PageConfigRuntime[];

package/dist/esm/node/runtime/html/serializePageContextClientSide.js

@@ -18,7 +18,7 @@ const PASS_TO_CLIENT = [
     '_abortCaller',
     */
     pageContextInitIsPassedToClient,
-    '_pageId',
+    'pageId',
     'routeParams',
     'data' // for data() hook
 ];
@@ -95,7 +95,7 @@ function serialize(value, varName) {
 }
 function getPassToClient(pageContext) {
     let passToClient = [...pageContext._passToClient, ...PASS_TO_CLIENT];
-    if (isErrorPage(pageContext._pageId, pageContext._pageConfigs)) {
+    if (isErrorPage(pageContext.pageId, pageContext._pageConfigs)) {
         assert(hasProp(pageContext, 'is404', 'boolean'));
         addIs404ToPageProps(pageContext);
         passToClient.push(...PASS_TO_CLIENT_ERROR_PAGE);

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

@@ -20,7 +20,7 @@ type HttpResponse = {
     contentType: 'application/json' | 'text/html;charset=utf-8';
 } & HttpResponseBody;
 declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: {
-    _pageId: null | string;
+    pageId: null | string;
     is404: null | boolean;
     errorWhileRendering: null | Error;
     __getPageAssets: GetPageAssets;

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

@@ -12,7 +12,7 @@ import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfin
 async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
-        const isError = !pageContext._pageId || isErrorPage(pageContext._pageId, pageContext._pageConfigs);
+        const isError = !pageContext.pageId || isErrorPage(pageContext.pageId, pageContext._pageConfigs);
         if (pageContext.errorWhileRendering) {
             assert(isError);
         }
@@ -27,8 +27,8 @@ async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     }
     const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
     const headers = [];
-    assert(pageContext._pageId);
-    const cacheControl = getCacheControl(pageContext._pageId, pageContext._pageConfigs);
+    assert(pageContext.pageId);
+    const cacheControl = getCacheControl(pageContext.pageId, pageContext._pageConfigs);
     if (cacheControl) {
         headers.push(['Cache-Control', cacheControl]);
     }

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

@@ -10,7 +10,7 @@ type PageContextDebugRouteMatches = {
 declare function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoaded, pageFilesServerSide, pageFilesClientSide, clientEntries, clientDependencies }: {
     pageContext: {
         urlOriginal: string;
-        _pageId: string;
+        pageId: string;
         _pageFilesAll: PageFile[];
         _pageConfigs: PageConfigRuntime[];
     } & PageContextDebugRouteMatches;

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

@@ -7,7 +7,7 @@ function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoa
     debug('All page files:', printPageFiles(pageContext._pageFilesAll, true)); // TODO
     debug(`URL:`, pageContext.urlOriginal);
     debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._debugRouteMatches));
-    debug(`pageId:`, pageContext._pageId);
+    debug(`pageId:`, pageContext.pageId);
     debug('Page type:', isHtmlOnly ? 'HTML-only' : 'SSR/SPA');
     debug(`Routing type:`, !isHtmlOnly && isClientRouting ? 'Client Routing' : 'Server Routing');
     debug('Server-side page files:', printPageFiles(pageFilesLoaded));

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

@@ -2,6 +2,6 @@ export { executeOnBeforeRenderAndDataHooks };
 import { type PageContextExports } from '../../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 declare function executeOnBeforeRenderAndDataHooks(pageContext: {
-    _pageId: string;
+    pageId: string;
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
 } & PageContextExports & PageContextForUserConsumptionServerSide): Promise<void>;

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

@@ -12,7 +12,7 @@ type RenderHook = Hook & {
 };
 type HookName = 'onRenderHtml' | 'render';
 declare function executeOnRenderHtmlHook(pageContext: PageContextForUserConsumptionServerSide & PageContextSerialization & {
-    _pageId: string;
+    pageId: string;
     _pageConfigs: PageConfigRuntime[];
     __getPageAssets: GetPageAssets;
     _isHtmlOnly: boolean;

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

@@ -6,7 +6,7 @@ declare function handleErrorWithoutErrorPage<PageContext extends {
     isClientSideNavigation: boolean;
     errorWhileRendering: null | Error;
     is404: null | boolean;
-    _pageId: null;
+    pageId: null;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     urlOriginal: string;

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

@@ -6,7 +6,7 @@ import { createHttpResponsePage, createHttpResponseError } from './createHttpRes
 import pc from '@brillout/picocolors';
 // When the user hasn't defined _error.page.js
 async function handleErrorWithoutErrorPage(pageContext) {
-    assert(pageContext._pageId === null);
+    assert(pageContext.pageId === null);
     assert(pageContext.errorWhileRendering || pageContext.is404);
     {
         const isV1 = pageContext._pageConfigs.length > 0;

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

@@ -13,7 +13,7 @@ type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContex
 };
 type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
 declare function loadUserFilesServerSide(pageContext: {
-    _pageId: string;
+    pageId: string;
 } & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageContextExports & {
     Page: unknown;
     _isHtmlOnly: boolean;

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

@@ -9,12 +9,12 @@ import { analyzePage } from './analyzePage.js';
 import { getGlobalContext } from '../globalContext.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
 async function loadUserFilesServerSide(pageContext) {
-    const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
+    const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
-        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext._pageId, !getGlobalContext().isProduction),
-        analyzePageClientSideInit(pageContext._pageFilesAll, pageContext._pageId, { sharedPageFilesAlreadyLoaded: true })
+        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext.pageId, !getGlobalContext().isProduction),
+        analyzePageClientSideInit(pageContext._pageFilesAll, pageContext.pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
-    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = analyzePage(pageContext._pageFilesAll, pageConfig, pageContext._pageId);
+    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = analyzePage(pageContext._pageFilesAll, pageConfig, pageContext.pageId);
     const isV1Design = !!pageConfig;
     const passToClient = [];
     const errMsg = ' should be an array of strings.';

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

@@ -12,7 +12,7 @@ type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal
     urlParsed: PageContextUrlInternal['urlParsed'];
     routeParams: Record<string, string>;
     Page: unknown;
-    _pageId: string;
+    pageId: string;
     _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
     isClientSideNavigation: boolean;

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

@@ -1,16 +1,11 @@
 export { preparePageContextForUserConsumptionServerSide };
-import { assert, isPlainObject, isObject } from '../utils.js';
-import { sortPageContext } from '../../../shared/sortPageContext.js';
+import { assert, isPlainObject } from '../utils.js';
 import { assertPageContextUrl } from '../../../shared/getPageContextUrlComputed.js';
-import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
+import { preparePageContextForUserConsumption } from '../../../shared/preparePageContextForUserConsumption.js';
 function preparePageContextForUserConsumptionServerSide(pageContext) {
     assertPageContextUrl(pageContext);
     assert(isPlainObject(pageContext.routeParams));
     assert('Page' in pageContext);
-    assert(isObject(pageContext.pageExports));
-    assert(isObject(pageContext.exports));
-    assert(isObject(pageContext.exportsAll));
     assert(typeof pageContext.isClientSideNavigation === 'boolean');
-    sortPageContext(pageContext);
-    addIs404ToPageProps(pageContext);
+    preparePageContextForUserConsumption(pageContext);
 }