vike 0.4.231 → 0.4.232-commit-134207d

package/dist/esm/client/{client-routing-runtime → runtime-client-routing}/renderPageClientSide.js

@@ -3,15 +3,15 @@ export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
-import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop } from './utils.js';
-import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient } from './getPageContextFromHooks.js';
+import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop, } from './utils.js';
+import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient, } from './getPageContextFromHooks.js';
 import { createPageContextClientSide } from './createPageContextClientSide.js';
-import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache } from './prefetch.js';
+import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
 import { pushHistoryState } from './history.js';
-import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
+import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { route } from '../../shared/route/index.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { setScrollPosition } from './setScrollPosition.js';
@@ -20,22 +20,22 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { setPageContextCurrent } from './getPageContextCurrent.js';
 import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-import { execHooksErrorHandling, execHookErrorHandling } from '../../shared/hooks/execHook.js';
-import { preparePageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
+import { execHooksErrorHandling, execHookErrorHandling, } from '../../shared/hooks/execHook.js';
+import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
 import { getHookFromPageContextNew } from '../../shared/hooks/getHook.js';
 import { preparePageContextForPublicUsageClientMinimal } from '../shared/preparePageContextForPublicUsageClientShared.js';
-const globalObject = getGlobalObject('client-routing-runtime/renderPageClientSide.ts', (() => {
+const globalObject = getGlobalObject('runtime-client-routing/renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
         renderCounter: 0,
         firstRenderStartPromise,
-        firstRenderStartPromiseResolve
+        firstRenderStartPromiseResolve,
     };
 })());
 const { firstRenderStartPromise } = globalObject;
 async function renderPageClientSide(renderArgs) {
     catchInfiniteLoop('renderPageClientSide()');
-    const { urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, doNotRenderIfSamePage, isClientSideNavigation = true, pageContextInitClient } = renderArgs;
+    const { urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, doNotRenderIfSamePage, isClientSideNavigation = true, pageContextInitClient, } = renderArgs;
     let { scrollTarget } = renderArgs;
     const { previousPageContext } = globalObject;
     addLinkPrefetchHandlers_unwatch();
@@ -47,7 +47,7 @@ async function renderPageClientSide(renderArgs) {
         pageContextsFromRewrite,
         isClientSideNavigation,
         pageContextInitClient,
-        isFirstRender
+        isFirstRender,
     };
     if (globalObject.clientRoutingIsDisabled) {
         redirectHard(urlOriginal);
@@ -135,7 +135,7 @@ async function renderPageClientSide(renderArgs) {
             objectAssign(pageContext, pageContextFromRoute);
         }
         try {
-            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
+            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -264,7 +264,7 @@ async function renderPageClientSide(renderArgs) {
                     await renderPageClientSide({
                         ...renderArgs,
                         scrollTarget: undefined,
-                        pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort]
+                        pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
                     });
                     return;
                 }
@@ -283,7 +283,7 @@ async function renderPageClientSide(renderArgs) {
                             urlOriginal: urlRedirect,
                             overwriteLastHistoryEntry: false,
                             isBackwardNavigation: false,
-                            redirectCount: redirectCount + 1
+                            redirectCount: redirectCount + 1,
                         });
                     }
                     return;
@@ -300,11 +300,11 @@ async function renderPageClientSide(renderArgs) {
                 objectAssign(pageContext, { is404: false });
             }
         }
-        const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+        const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._globalContext._pageConfigs);
         if (!errorPageId)
             throw new Error('No error page defined.');
         objectAssign(pageContext, {
-            pageId: errorPageId
+            pageId: errorPageId,
         });
         const isClientRoutable = await isClientSideRoutable(pageContext.pageId, pageContext);
         if (isRenderOutdated())
@@ -314,7 +314,7 @@ async function renderPageClientSide(renderArgs) {
             return;
         }
         try {
-            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
+            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -452,7 +452,7 @@ async function renderPageClientSide(renderArgs) {
         stampFinished(urlOriginal);
     }
 }
-async function getPageContextBegin(isForErrorPage, { urlOriginal, isBackwardNavigation, pageContextsFromRewrite, isClientSideNavigation, pageContextInitClient, isFirstRender }) {
+async function getPageContextBegin(isForErrorPage, { urlOriginal, isBackwardNavigation, pageContextsFromRewrite, isClientSideNavigation, pageContextInitClient, isFirstRender, }) {
     const previousPageContext = globalObject.previousPageContext ?? null;
     const pageContext = await createPageContextClientSide(urlOriginal);
     objectAssign(pageContext, {
@@ -460,18 +460,18 @@ async function getPageContextBegin(isForErrorPage, { urlOriginal, isBackwardNavi
         isClientSideNavigation,
         isHydration: isFirstRender && !isForErrorPage,
         previousPageContext,
-        ...pageContextInitClient
+        ...pageContextInitClient,
     });
     // TODO/next-major-release: remove
     Object.defineProperty(pageContext, '_previousPageContext', {
         get() {
             assertWarning(false, 'pageContext._previousPageContext has been renamed pageContext.previousPageContext', {
                 showStackTrace: true,
-                onlyOnce: true
+                onlyOnce: true,
             });
             return previousPageContext;
         },
-        enumerable: false
+        enumerable: false,
     });
     {
         const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
@@ -520,7 +520,7 @@ function disableClientRouting(err, log) {
         'Failed to fetch static asset.',
         isProd ? 'This usually happens when a new frontend is deployed.' : null,
         'Falling back to Server Routing.',
-        '(The next page navigation will use Server Routing instead of Client Routing.)'
+        '(The next page navigation will use Server Routing instead of Client Routing.)',
     ]
         .filter(Boolean)
         .join(' '), { onlyOnce: true });
@@ -547,7 +547,7 @@ function getIsRenderOutdated() {
     return {
         isRenderOutdated,
         setHydrationCanBeAborted,
-        isFirstRender: renderNumber === 1
+        isFirstRender: renderNumber === 1,
     };
 }
 function getRenderCount() {
@@ -563,7 +563,7 @@ function getKeepScrollPositionSetting(pageContext) {
     const routeParameterList = getRouteStringParameterList(configDefinedAt);
     if (isCallable(val))
         val = val(pageContext, {
-            configDefinedAt: c.definedAt
+            configDefinedAt: c.definedAt,
             /* We don't pass routeParameterList because it's useless: the user knows the parameter list.
             routeParameterList
             */
@@ -575,7 +575,7 @@ function getKeepScrollPositionSetting(pageContext) {
                 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

package/dist/esm/client/{client-routing-runtime → runtime-client-routing}/scrollRestoration.js

@@ -6,7 +6,7 @@ export { scrollRestoration_initialRenderIsDone };
 // - Firefox doesn't restore the scroll position upon page reload but does upon Cmd-Shift-T
 // See also: https://github.com/cyco130/knave/blob/e9e1bc7687848504293197f1b314b7d12ad0d228/design.md#scroll-restoration
 import { getGlobalObject, onPageHide, onPageShow } from './utils.js';
-const globalObject = getGlobalObject('client-routing-runtime/scrollRestoration.ts', {});
+const globalObject = getGlobalObject('runtime-client-routing/scrollRestoration.ts', {});
 function scrollRestoration_init() {
     // Use the native scroll restoration mechanism only for the first render
     scrollRestoration_enable();

package/dist/esm/client/{client-routing-runtime → runtime-client-routing}/setScrollPosition.js

@@ -89,7 +89,7 @@ function setScroll(scrollPosition) {
             // In principle, `requestAnimationFrame() -> setTimeout(, 0)` should be enough.
             //  - https://stackoverflow.com/questions/61281139/waiting-for-repaint-in-javascript
             //  - But it's not enough for `Firefox 97.0.1`.
-            //  - The following strategy is very agressive. It doesn't need to be that aggressive for Firefox. But we do it to be safe.
+            //  - The following strategy is very aggressive. It doesn't need to be that aggressive for Firefox. But we do it to be safe.
             const start = new Date().getTime();
             while (true) {
                 await sleep(10);

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

@@ -0,0 +1,43 @@
+export { createPageContextClientSide };
+declare function createPageContextClientSide(): Promise<{
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: true;
+    isPrerendering: false;
+    isHydration: true;
+    _globalContext: {
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        _vikeConfigPublicGlobal: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        pages: {
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+        };
+    } & {
+        isClientSide: true;
+    } & object;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    isBackwardNavigation: null;
+    _hasPageContextFromServer: true;
+} & {
+    pageId: string;
+    routeParams: Record<string, string>;
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+} & import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+    _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
+}>;

package/dist/esm/client/{server-routing-runtime → runtime-server-routing}/createPageContextClientSide.js

@@ -14,19 +14,16 @@ async function createPageContextClientSide() {
         isPrerendering: false,
         isHydration: true,
         _globalContext: globalContext,
-        _pageFilesAll: globalContext._pageFilesAll,
-        _pageConfigs: globalContext._pageConfigs,
-        _pageConfigGlobal: globalContext._pageConfigGlobal,
-        _allPageIds: globalContext._allPageIds,
+        _pageFilesAll: globalContext._pageFilesAll, // TODO/v1-release: remove
         isBackwardNavigation: null,
-        _hasPageContextFromServer: true
+        _hasPageContextFromServer: true,
     });
     objectAssign(pageContextCreated, getPageContextSerializedInHtml());
     // Sets pageContext.config to global configs
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._userFriendlyConfigsGlobal);
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal);
     augmentType(pageContextCreated, pageContextAugmented);
     // Sets pageContext.config to local configs (overrides the pageContext.config set above)
-    objectAssign(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated.pageId, pageContextCreated._pageFilesAll, pageContextCreated._pageConfigs, pageContextCreated._pageConfigGlobal));
+    objectAssign(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated.pageId, globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal));
     assertPristineUrl();
     return pageContextCreated;
 }

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

@@ -0,0 +1,27 @@
+export { getGlobalContextClientInternal };
+export type { GlobalContextClientWithServerRouting };
+export type { GlobalContextClientInternalWithServerRouting };
+import type { GlobalContextBasePublic } from '../../shared/createGlobalContextShared.js';
+type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextClientInternalWithServerRouting = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
+declare const getGlobalContextClientInternal: () => Promise<{
+    isGlobalContext: true;
+    _isOriginalObject: true;
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _vikeConfigPublicGlobal: {
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+    };
+    config: import("../../types/index.js").ConfigResolved;
+    pages: {
+        [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+    };
+} & {
+    isClientSide: true;
+} & object>;

package/dist/esm/client/{server-routing-runtime → runtime-server-routing}/globalContext.js

@@ -1,5 +1,5 @@
 export { getGlobalContextClientInternal };
 import { createGetGlobalContextClient } from '../shared/createGetGlobalContextClient.js';
 // @ts-ignore
-import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-routing';
+import * as virtualFileExports from 'virtual:vike:entry:client:server-routing';
 const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExports, false);

package/dist/esm/client/{server-routing-runtime → runtime-server-routing}/index.d.ts

@@ -1,4 +1,4 @@
-import type { PageContextBuiltInClientWithServerRouting } from '../../shared/types.js';
+import type { PageContextBuiltInClientWithServerRouting } from '../../types/PageContext.js';
 /** @deprecated
  * Replace:
  *   ```

package/dist/esm/client/{server-routing-runtime → runtime-server-routing}/preparePageContextForPublicUsageClient.d.ts

@@ -1,9 +1,9 @@
 export { preparePageContextForPublicUsageClient };
 export type { PageContextForPublicUsageClient };
-import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
-import type { PageContextInternalClient_ServerRouting } from '../../shared/types.js';
+import type { VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import type { PageContextInternalClient_ServerRouting } from '../../types/PageContext.js';
 import type { PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
-type PageContextForPublicUsageClient = PageContextPrepareMinimum & PageContextInternalClient_ServerRouting & PageConfigUserFriendlyOld;
+type PageContextForPublicUsageClient = PageContextPrepareMinimum & PageContextInternalClient_ServerRouting & VikeConfigPublicPageLazy;
 declare function preparePageContextForPublicUsageClient<PageContext extends PageContextForPublicUsageClient>(pageContext: PageContext): PageContext & {
     Page: unknown;
 };

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

@@ -1,25 +1,27 @@
 export { getGlobalContext };
 export { getGlobalContextSync };
 export { createGetGlobalContextClient };
-import { type GlobalContextShared } from '../../shared/createGlobalContextShared.js';
-declare function createGetGlobalContextClient<GlobalContextAddendum extends object>(virtualFileExports: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): () => Promise<{
+export type GlobalContextClientInternalShared = GlobalContextClientInternal | GlobalContextClientInternalWithServerRouting;
+import { type GlobalContextBase } from '../../shared/createGlobalContextShared.js';
+import type { GlobalContextClientInternal } from '../runtime-client-routing/globalContext.js';
+import type { GlobalContextClientInternalWithServerRouting } from '../runtime-server-routing/globalContext.js';
+declare function createGetGlobalContextClient<GlobalContextAddendum extends object>(virtualFileExports: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>): () => Promise<{
     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;
+    _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
+    _vikeConfigPublicGlobal: {
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+    };
     config: import("../../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-            route: import("../../shared/page-configs/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
 } & Awaited<{
     /**

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

@@ -3,14 +3,14 @@ export { getGlobalContext };
 export { getGlobalContextSync };
 // Internal usage
 export { createGetGlobalContextClient };
-import { createGlobalContextShared, getGlobalContextSyncErrMsg } from '../../shared/createGlobalContextShared.js';
+import { createGlobalContextShared, getGlobalContextSyncErrMsg, } from '../../shared/createGlobalContextShared.js';
 import { getGlobalContextSerializedInHtml } from './getJsonSerializedInHtml.js';
 import { assert, assertUsage, genPromise, getGlobalObject, objectAssign } from './utils.js';
 const globalObject = getGlobalObject('createGetGlobalContextClient.ts', (() => {
     const { promise: globalContextPromise, resolve: globalContextPromiseResolve } = genPromise();
     return {
         globalContextPromise,
-        globalContextPromiseResolve
+        globalContextPromiseResolve,
     };
 })());
 function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGlobalContext) {
@@ -34,7 +34,7 @@ function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGl
                  *
                  * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
                  */
-                isClientSide: true
+                isClientSide: true,
             };
             objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
             objectAssign(globalContextAddendum, await addGlobalContext?.(globalContext));

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

@@ -1,13 +1,13 @@
 export { executeOnRenderClientHook };
 export type { PageContextBeforeRenderClient };
-import type { PageFile, PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
+import type { PageFile, VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
 import type { PageContextForPublicUsageClientShared } from './preparePageContextForPublicUsageClientShared.js';
-import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
+import type { GlobalContextClientInternalShared } from './createGetGlobalContextClient.js';
 type PageContextBeforeRenderClient = {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;
     urlPathname?: string;
     pageId: string;
-    _pageConfigs: PageConfigRuntime[];
-} & PageConfigUserFriendlyOld & PageContextForPublicUsageClientShared;
+    _globalContext: GlobalContextClientInternalShared;
+} & VikeConfigPublicPageLazy & PageContextForPublicUsageClientShared;
 declare function executeOnRenderClientHook<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

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

@@ -1,5 +1,5 @@
 export { executeOnRenderClientHook };
-import { assert, assertUsage } from '../server-routing-runtime/utils.js';
+import { assert, assertUsage } from '../runtime-server-routing/utils.js';
 import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
 import { execHookSingle } from '../../shared/hooks/execHook.js';
 async function executeOnRenderClientHook(pageContext, prepareForPublicUsage) {
@@ -17,7 +17,7 @@ async function executeOnRenderClientHook(pageContext, prepareForPublicUsage) {
     if (!hook) {
         const urlToShowToUser = getUrlToShowToUser(pageContext);
         assert(urlToShowToUser);
-        if (pageContext._pageConfigs.length > 0) {
+        if (pageContext._globalContext._pageConfigs.length > 0) {
             // V1 design
             assertUsage(false, `No onRenderClient() hook defined for URL '${urlToShowToUser}', but it's needed, see https://vike.dev/onRenderClient`);
         }

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

@@ -1,15 +1,9 @@
 export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
-export type { PageContextUserFiles };
-import { type PageFile, type PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
-import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-type PageContextUserFilesLoaded = PageConfigUserFriendlyOld & {
+import { type PageFile, type VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
+type PageContextUserFilesLoaded = VikeConfigPublicPageLazy & {
     _pageFilesLoaded: PageFile[];
 };
-type PageContextUserFiles = {
-    _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfigRuntime[];
-    _pageConfigGlobal: PageConfigGlobalRuntime;
-};
 declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

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

@@ -1,10 +1,10 @@
 export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
-import { getUserFriendlyConfigsPageLazy } from '../../shared/page-configs/getUserFriendlyConfigs.js';
+import { resolveVikeConfigPublicPageLazy } from '../../shared/page-configs/resolveVikeConfigPublic.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
-import { objectAssign } from '../server-routing-runtime/utils.js';
+import { objectAssign } from '../runtime-server-routing/utils.js';
 const stamp = '__whileFetchingAssets';
 async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
@@ -30,7 +30,7 @@ async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs,
         }
         throw err;
     }
-    const pageContextExports = getUserFriendlyConfigsPageLazy(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
+    const pageContextExports = resolveVikeConfigPublicPageLazy(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });
@@ -58,7 +58,7 @@ function isFetchError(err) {
         // ??
         'error resolving module specifier',
         // ??
-        'failed to resolve module'
+        'failed to resolve module',
     ];
     return FAILED_TO_FETCH_MESSAGES.some((s) => err.message.toLowerCase().includes(s.toLowerCase()));
 }

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

@@ -1,10 +1,10 @@
 export { preparePageContextForPublicUsageClientShared };
 export { preparePageContextForPublicUsageClientMinimal };
 export type { PageContextForPublicUsageClientShared };
-import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
 import { type PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
-import type { PageContextInternalClient } from '../../shared/types.js';
-type PageContextForPublicUsageClientShared = PageContextPrepareMinimum & PageContextInternalClient & PageConfigUserFriendlyOld;
+import type { PageContextInternalClient } from '../../types/PageContext.js';
+type PageContextForPublicUsageClientShared = PageContextPrepareMinimum & PageContextInternalClient & VikeConfigPublicPageLazy;
 declare function preparePageContextForPublicUsageClientShared<PageContext extends PageContextForPublicUsageClientShared>(pageContext: PageContext): PageContext & {
     Page: unknown;
 };

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

@@ -1,9 +1,9 @@
 export { preparePageContextForPublicUsageClientShared };
 export { preparePageContextForPublicUsageClientMinimal };
-import { objectAssign } from '../server-routing-runtime/utils.js';
-import { assertPropertyGetters, preparePageContextForPublicUsage } from '../../shared/preparePageContextForPublicUsage.js';
+import { objectAssign } from '../runtime-server-routing/utils.js';
+import { assertPropertyGetters, preparePageContextForPublicUsage, } from '../../shared/preparePageContextForPublicUsage.js';
 function preparePageContextForPublicUsageClientShared(pageContext) {
-    // TODO/now use proxy
+    // TODO/now-proxy use proxy
     const Page = pageContext.config?.Page ||
         // TODO/next-major-release: remove
         pageContext.exports?.Page;
@@ -20,7 +20,7 @@ function preparePageContextForPublicUsageClientMinimal(pageContext) {
     const pageContextPublic = preparePageContextForPublicUsage(pageContext);
     return pageContextPublic;
 }
-// With Vue + Cient Routing, the `pageContext` is made reactive:
+// With Vue + Client Routing, the `pageContext` is made reactive:
 // ```js
 // import { reactive } from 'vue'
 // // See /examples/vue-full/renderer/createVueApp.ts
@@ -29,7 +29,7 @@ function preparePageContextForPublicUsageClientMinimal(pageContext) {
 function supportVueReactiviy(pageContext) {
     resolveGetters(pageContext);
 }
-// Remove propery descriptor getters because they break Vue's reactivity.
+// Remove property descriptor getters because they break Vue's reactivity.
 // E.g. resolve the `pageContext.urlPathname` getter.
 function resolveGetters(pageContext) {
     Object.entries(pageContext).forEach(([key, val]) => {

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

@@ -2,7 +2,7 @@ export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite, version, createBuilder } from 'vite';
 import { isVikeCli } from '../cli/context.js';
-import { isPrerendering } from '../prerender/context.js';
+import { wasPrerenderRun } from '../prerender/context.js';
 import { assert, assertVersion } from './utils.js';
 /**
  * Programmatically trigger `$ vike build`
@@ -14,7 +14,7 @@ async function build(options = {}) {
     // Pass it to pluginAutoFullBuild()
     if (viteConfigFromUserEnhanced)
         viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
-    if (vikeConfig.global.config.vite6BuilderApp) {
+    if (vikeConfig.config.vite6BuilderApp) {
         // This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
         assertVersion('Vite', version, '6.0.0');
         const builder = await createBuilder(viteConfigFromUserEnhanced);
@@ -32,8 +32,13 @@ async function build(options = {}) {
         //    > Rationale: https://github.com/vikejs/vike/issues/2123
         await buildVite(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
-        if (isVikeCli() && isPrerendering())
+        if (
+        // When calling Vike's prerender() API pre-rendering is run without force exit
+        ![false, 'prerender()'].includes(wasPrerenderRun()) &&
+            // When calling Vike's build() API pre-rendering is auto run without force exit
+            isVikeCli()) {
             assert(false);
+        }
     }
     return {
     /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`

package/dist/esm/node/api/dev.js

@@ -13,6 +13,6 @@ async function dev(options = {}) {
     const server = await createServer(viteConfigFromUserEnhanced);
     return {
         viteServer: server,
-        viteConfig: server.config
+        viteConfig: server.config,
     };
 }

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -4,9 +4,9 @@ export { assertViteRoot };
 export { normalizeViteRoot };
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { APIOptions, Operation } from './types.js';
-import { type VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import { type VikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
 declare function prepareViteApiCall(options: APIOptions, operation: Operation): Promise<{
-    vikeConfig: VikeConfigObject;
+    vikeConfig: VikeConfigInternal;
     viteConfigResolved: ResolvedConfig;
     viteConfigFromUserEnhanced: InlineConfig | undefined;
 }>;