vike 0.4.229 → 0.4.230-commit-dd11364

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

@@ -1,10 +1,10 @@
 export { createPageContextServerSide };
 export { createPageContextServerSideWithoutGlobalContext };
-export type { PageContextCreatedServerSide };
-import type { GlobalContextServerInternal, GlobalContextServer } from '../globalContext.js';
+export type { PageContextCreated };
+import type { GlobalContextServerInternal } from '../globalContext.js';
 import type { PageContextInit } from '../renderPage.js';
-type PageContextCreatedServerSide = Awaited<ReturnType<typeof createPageContextServerSide>>;
-declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, globalObject_public: GlobalContextServer, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } }: {
+type PageContextCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
+declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } }: {
     isPrerendering: false;
     ssr: {
         urlHandler: null | ((url: string) => string);
@@ -14,22 +14,34 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
     isPrerendering: true;
     ssr?: undefined;
 }): Promise<{
-    isClientSide: boolean;
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
     isPrerendering: boolean;
-} & Pick<import("../../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+} & Pick<import("../../../shared/types.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
     url?: string;
     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[];
         _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: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        pages: {
+            [k: string]: import("../../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+                route: import("../../../shared/page-configs/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
     } & ({
         _isProduction: false;
         _isPrerendering: false;
@@ -51,14 +63,6 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         isClientSide: false;
         _pageRoutes: import("../../../__internal/index.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[];
-        config: import("../../../types/index.js").ConfigResolved;
-        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
     } | {
         _isPrerendering: true;
         viteConfig: import("vite").ResolvedConfig;
@@ -81,14 +85,6 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         isClientSide: false;
         _pageRoutes: import("../../../__internal/index.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[];
-        config: import("../../../types/index.js").ConfigResolved;
-        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
     } | {
         _isPrerendering: false;
         viteConfig: null;
@@ -111,14 +107,6 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         isClientSide: false;
         _pageRoutes: import("../../../__internal/index.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[];
-        config: import("../../../types/index.js").ConfigResolved;
-        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
     });
     _baseServer: string;
     _baseAssets: string;
@@ -133,23 +121,20 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
     _urlRewrite: null;
     _urlHandler: ((url: string) => string) | null;
     isClientSideNavigation: boolean;
-} & {
+} & import("../../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & {
     urlParsed: import("../utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 } & {
     headers: Record<string, string> | null;
-} & {
-    config: import("../../../types/index.js").ConfigResolved;
-    _source: import("../../../shared/page-configs/getPageConfigUserFriendly.js").Source;
-    _sources: import("../../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
-    _from: import("../../../shared/page-configs/getPageConfigUserFriendly.js").From;
-    isPageContext: true;
 }>;
 declare function createPageContextServerSideWithoutGlobalContext(pageContextInit: PageContextInit): {
-    isClientSide: boolean;
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
     isPrerendering: boolean;
-} & Pick<import("../../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+} & Pick<import("../../../shared/types.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
     url?: string;
     headers?: Record<string, string>;
 };

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

@@ -2,19 +2,14 @@ export { createPageContextServerSide };
 export { createPageContextServerSideWithoutGlobalContext };
 import { assert, assertUsage, assertWarning, augmentType, normalizeHeaders, objectAssign } from '../utils.js';
 import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
-import { createPageContextShared } from '../../../shared/createPageContextShared.js';
-async function createPageContextServerSide(pageContextInit, globalContext, globalObject_public, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
+import { createPageContextObject, createPageContextShared } from '../../../shared/createPageContextShared.js';
+async function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
     urlHandler: null,
     isClientSideNavigation: false
 } }) {
     assert(pageContextInit.urlOriginal);
     const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
     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,
@@ -33,6 +28,7 @@ async function createPageContextServerSide(pageContextInit, globalContext, globa
         _urlHandler: urlHandler,
         isClientSideNavigation
     });
+    objectAssign(pageContextCreated, globalContext._userFriendlyConfigsGlobal);
     // pageContext.urlParsed
     const pageContextUrlComputed = getPageContextUrlComputed(pageContextCreated);
     objectAssign(pageContextCreated, pageContextUrlComputed);
@@ -53,7 +49,7 @@ async function createPageContextServerSide(pageContextInit, globalContext, globa
         }
         objectAssign(pageContextCreated, { headers });
     }
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal);
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._userFriendlyConfigsGlobal);
     augmentType(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }
@@ -62,10 +58,11 @@ function createPageContextServerSideWithoutGlobalContext(pageContextInit) {
     return pageContext;
 }
 function createPageContext(pageContextInit, isPrerendering) {
-    const pageContext = {
+    const pageContext = createPageContextObject();
+    objectAssign(pageContext, {
         isClientSide: false,
         isPrerendering
-    };
+    });
     objectAssign(pageContext, pageContextInit);
     return pageContext;
 }

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

@@ -0,0 +1,12 @@
+export { execHookServer };
+export type { PageContextExecuteHookServer };
+import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
+import type { PageConfigUserFriendlyOld } from '../../../shared/getPageFiles.js';
+import type { HookName } from '../../../shared/page-configs/Config.js';
+type PageContextExecuteHookServer = PageConfigUserFriendlyOld & PageContextForPublicUsageServer;
+declare function execHookServer(hookName: HookName, pageContext: PageContextExecuteHookServer): Promise<(import("../../../shared/hooks/getHook.js").HookLoc & {
+    hookFn: (arg: import("../../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum | import("../../../shared/prepareGlobalContextForPublicUsage.js").GlobalContextPrepareMinimum) => unknown;
+    hookTimeout: import("../../../shared/hooks/getHook.js").HookTimeout;
+} & {
+    hookReturn: unknown;
+})[]>;

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

@@ -0,0 +1,9 @@
+export { execHookServer };
+import { execHook } from '../../../shared/hooks/execHook.js';
+import { preparePageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
+async function execHookServer(hookName, pageContext) {
+    return await execHook(hookName, pageContext, (p) => {
+        preparePageContextForPublicUsageServer(p);
+        return p;
+    });
+}

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

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

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

@@ -1,30 +1,29 @@
 export { executeOnBeforeRenderAndDataHooks };
-import { getHookFromPageContext } from '../../../shared/hooks/getHook.js';
-import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 import { assertOnBeforeRenderHookReturn } from '../../../shared/assertOnBeforeRenderHookReturn.js';
-import { executeHook } from '../../../shared/hooks/executeHook.js';
+import { execHookServer } from './execHookServer.js';
 async function executeOnBeforeRenderAndDataHooks(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;
     }
-    const dataHook = getHookFromPageContext(pageContext, 'data');
-    const onBeforeRenderHook = getHookFromPageContext(pageContext, 'onBeforeRender');
-    if (!dataHook && !onBeforeRenderHook) {
-        return;
-    }
-    preparePageContextForUserConsumptionServerSide(pageContext);
+    const hooks = await execHookServer('data', pageContext);
+    const dataHook = hooks[0]; // TO-DO/soon: support cumulative
     if (dataHook) {
-        const hookResult = await executeHook(() => dataHook.hookFn(pageContext), dataHook, pageContext);
-        // 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: hookResult
+            data: dataHook.hookReturn
         };
         Object.assign(pageContext, pageContextFromHook);
+        // Execute +onData
+        if (!pageContext.isClientSideNavigation) {
+            await execHookServer('onData', pageContext);
+        }
     }
+    const res = await execHookServer('onBeforeRender', pageContext);
+    const onBeforeRenderHook = res[0]; // TO-DO/soon: support cumulative
     if (onBeforeRenderHook) {
-        const hookResult = await executeHook(() => onBeforeRenderHook.hookFn(pageContext), onBeforeRenderHook, pageContext);
-        assertOnBeforeRenderHookReturn(hookResult, onBeforeRenderHook.hookFilePath);
-        const pageContextFromHook = hookResult?.pageContext;
+        const { hookReturn } = onBeforeRenderHook;
+        assertOnBeforeRenderHookReturn(hookReturn, onBeforeRenderHook.hookFilePath);
+        const pageContextFromHook = hookReturn?.pageContext;
         Object.assign(pageContext, pageContextFromHook);
     }
 }

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

@@ -3,16 +3,18 @@ export type { RenderHook };
 import { type HtmlRender } from '../html/renderHtml.js';
 import { type Hook } from '../../../shared/hooks/getHook.js';
 import type { PageAsset } from './getPageAssets.js';
-import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
+import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageContextSerialization } from '../html/serializeContext.js';
+import type { GlobalContextServerInternal } from '../globalContext.js';
 type GetPageAssets = () => Promise<PageAsset[]>;
 type RenderHook = Hook & {
     hookName: HookName;
 };
 type HookName = 'onRenderHtml' | 'render';
-declare function executeOnRenderHtmlHook(pageContext: PageContextForUserConsumptionServerSide & PageContextSerialization & {
+declare function executeOnRenderHtmlHook(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
     pageId: string;
+    _globalContext: GlobalContextServerInternal;
     _pageConfigs: PageConfigRuntime[];
     __getPageAssets: GetPageAssets;
     _isHtmlOnly: boolean;

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

@@ -4,17 +4,16 @@ import { getHookFromPageContext } from '../../../shared/hooks/getHook.js';
 import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, isCallable } from '../utils.js';
 import { isStream } from '../html/stream.js';
 import { assertPageContextProvidedByUser } from '../../../shared/assertPageContextProvidedByUser.js';
-import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
+import { preparePageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
 import { assertHookReturnedObject } from '../../../shared/assertHookReturnedObject.js';
 import { logRuntimeError } from './loggerRuntime.js';
 import pc from '@brillout/picocolors';
-import { executeHook } from '../../../shared/hooks/executeHook.js';
+import { execHookSingleWithReturn } from '../../../shared/hooks/execHook.js';
 async function executeOnRenderHtmlHook(pageContext) {
-    const { renderHook, hookFn } = getRenderHook(pageContext);
-    objectAssign(pageContext, { _renderHook: renderHook });
-    preparePageContextForUserConsumptionServerSide(pageContext);
-    const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook, pageContext);
-    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
+    const hook = getRenderHook(pageContext);
+    objectAssign(pageContext, { _renderHook: hook });
+    const { hookReturn } = await execHookSingleWithReturn(hook, pageContext, preparePageContextForPublicUsageServer);
+    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
     const onErrorWhileStreaming = (err) => {
@@ -29,7 +28,7 @@ async function executeOnRenderHtmlHook(pageContext) {
     };
     const htmlRender = await renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
     assert(typeof htmlRender === 'string' || isStream(htmlRender));
-    return { htmlRender, renderHook };
+    return { htmlRender, renderHook: hook };
 }
 function getRenderHook(pageContext) {
     let hookFound;
@@ -49,10 +48,7 @@ function getRenderHook(pageContext) {
         if (hook) {
             assert(hookName);
             const { hookFilePath, hookFn, hookTimeout } = hook;
-            hookFound = {
-                hookFn,
-                renderHook: { hookFn, hookFilePath, hookName, hookTimeout }
-            };
+            hookFound = { hookFn, hookFilePath, hookName, hookTimeout };
         }
     }
     if (!hookFound) {

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

@@ -100,7 +100,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
         assert(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
         assert(renderHook);
         const { hookFilePath, hookName } = renderHook;
-        return `Make sure the ${hookName}() defined by ${hookFilePath} hook provides ${streamName} instead`;
+        return `Make sure the ${hookName}() hook defined by ${hookFilePath} provides ${streamName} instead`;
     }
 }
 function getErrMsg(htmlRender, renderHook, method, msgAddendum) {

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

@@ -17,7 +17,7 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     let clientEntriesSrc;
     if (isDev) {
         const { _viteDevServer: viteDevServer } = globalContext;
-        clientEntriesSrc = await Promise.all(clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer)));
+        clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer));
         assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
     }
     else {

package/dist/esm/node/runtime/renderPage/{loadUserFilesServerSide.d.ts → loadPageConfigsLazyServerSide.d.ts}

@@ -1,22 +1,22 @@
-export { loadUserFilesServerSide };
+export { loadPageConfigsLazyServerSide };
 export type { PageFiles };
-export type { PageContext_loadUserFilesServerSide };
+export type { PageContext_loadPageConfigsLazyServerSide };
 import { type PageFile } from '../../../shared/getPageFiles.js';
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
+type PageContext_loadPageConfigsLazyServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
     urlOriginal: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _globalContext: GlobalContextServerInternal;
 };
-type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
-declare function loadUserFilesServerSide(pageContext: {
+type PageFiles = PromiseType<ReturnType<typeof loadPageConfigsLazyServerSide>>;
+declare function loadPageConfigsLazyServerSide(pageContext: {
     pageId: string;
-} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
+} & PageContext_loadPageConfigsLazyServerSide): Promise<import("../../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];

package/dist/esm/node/runtime/renderPage/{loadUserFilesServerSide.js → loadPageConfigsLazyServerSide.js}

@@ -1,6 +1,6 @@
-export { loadUserFilesServerSide };
+export { loadPageConfigsLazyServerSide };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
-import { getPageConfigUserFriendly_oldDesign } from '../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getUserFriendlyConfigsPageLazy } from '../../../shared/page-configs/getUserFriendlyConfigs.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
 import { assert, assertUsage, assertWarning, hasProp, isArrayOfStrings, objectAssign, isArray } from '../utils.js';
 import { getPageAssets } from './getPageAssets.js';
@@ -8,7 +8,7 @@ import { debugPageFiles } from './debugPageFiles.js';
 import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
-async function loadUserFilesServerSide(pageContext) {
+async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
@@ -100,7 +100,7 @@ async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pag
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const pageContextExports = getPageConfigUserFriendly_oldDesign(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
+    const pageContextExports = getUserFriendlyConfigsPageLazy(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
     return {
         pageContextExports,
         pageFilesLoaded: pageFilesServerSide

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

@@ -0,0 +1,20 @@
+export { preparePageContextForPublicUsageServer };
+export type { PageContextForPublicUsageServer };
+import type { PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
+import type { PageConfigUserFriendlyOld } from '../../../shared/page-configs/getUserFriendlyConfigs.js';
+import type { PageContextInternalServer } from '../../../shared/types.js';
+import type { GlobalContextServerInternal } from '../globalContext.js';
+type PageContextForPublicUsageServer = PageContextInternalServer & PageConfigUserFriendlyOld & {
+    urlOriginal: string;
+    /** @deprecated */
+    url: string;
+    urlPathname: string;
+    urlParsed: PageContextUrlInternal['urlParsed'];
+    routeParams: Record<string, string>;
+    Page: unknown;
+    pageId: string;
+    is404: null | boolean;
+    isClientSideNavigation: boolean;
+    _globalContext: GlobalContextServerInternal;
+};
+declare function preparePageContextForPublicUsageServer<PageContext extends PageContextForPublicUsageServer>(pageContext: PageContext): PageContext;

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

@@ -0,0 +1,8 @@
+export { preparePageContextForPublicUsageServer };
+import { assertPropertyGetters, preparePageContextForPublicUsage } from '../../../shared/preparePageContextForPublicUsage.js';
+function preparePageContextForPublicUsageServer(pageContext) {
+    // TODO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
+    assertPropertyGetters(pageContext);
+    pageContext = preparePageContextForPublicUsage(pageContext);
+    return pageContext;
+}