vike 0.4.237 → 0.4.238

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

@@ -2,8 +2,8 @@ export { getGlobalContextClientInternal };
 import { createGetGlobalContextClient } from '../shared/createGetGlobalContextClient.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 // @ts-ignore
-import * as virtualFileExports from 'virtual:vike:entry:client:client-routing';
-const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExports, true, addGlobalContext);
+import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:client-routing';
+const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExportsGlobalEntry, true, addGlobalContext);
 async function addGlobalContext(globalContext) {
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return {

package/dist/esm/client/runtime-client-routing/prefetch/getPrefetchSettings.d.ts

@@ -1,10 +1,10 @@
 export { getPrefetchSettings };
 export { PAGE_CONTEXT_MAX_AGE_DEFAULT };
 export type { PrefetchSettingResolved };
-import type { VikeConfigPublicPageLazy } from '../../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../../shared/getPageFiles.js';
 declare const PAGE_CONTEXT_MAX_AGE_DEFAULT = 5000;
 type PrefetchSettingResolved = {
     staticAssets: false | 'hover' | 'viewport';
     pageContext: false | number;
 };
-declare function getPrefetchSettings(pageContext: VikeConfigPublicPageLazy, linkTag: null | HTMLElement): PrefetchSettingResolved;
+declare function getPrefetchSettings(pageContext: VikeConfigPublicPageLazyLoaded, linkTag: null | HTMLElement): PrefetchSettingResolved;

package/dist/esm/client/runtime-client-routing/prefetch.d.ts

@@ -7,14 +7,14 @@ export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
 import { type PageContextCreated } from './createPageContextClientSide.js';
 import { type PageContextFromServerHooks, getPageContextFromServerHooks } from './getPageContextFromHooks.js';
-import type { VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../shared/getPageFiles.js';
 type ResultPageContextFromServer = Awaited<ReturnType<typeof getPageContextFromServerHooks>>;
 type PageContextForPrefetch = PageContextCreated & {
     pageId: string;
 };
 declare function getPageContextPrefetched(pageContext: {
     urlPathname: string;
-} & VikeConfigPublicPageLazy): null | PageContextFromServerHooks;
+} & VikeConfigPublicPageLazyLoaded): null | PageContextFromServerHooks;
 declare function populatePageContextPrefetchCache(pageContext: PageContextForPrefetch, result: ResultPageContextFromServer): void;
 /**
  * Programmatically prefetch client assets.

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

@@ -60,8 +60,8 @@ async function prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge)
     const result = await getPageContextFromServerHooks(pageContextLink, false);
     setPageContextPrefetchCache(pageContextLink, result, resultMaxAge);
 }
-function populatePageContextPrefetchCache(pageContext /*& VikeConfigPublicPageLazy*/, result) {
-    // TO-DO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use VikeConfigPublicPageLazy as it isn't available here.)
+function populatePageContextPrefetchCache(pageContext /*& VikeConfigPublicPageLazyLoaded*/, result) {
+    // TO-DO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use VikeConfigPublicPageLazyLoaded as it isn't available here.)
     if (!isBrilloutDocpress())
         return;
     setPageContextPrefetchCache(pageContext, result, null);

package/dist/esm/client/runtime-client-routing/preparePageContextForPublicUsageClient.d.ts

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

package/dist/esm/client/runtime-client-routing/renderPageClientSide.d.ts

@@ -6,8 +6,9 @@ export { getPageContextClient };
 export type { PageContextBegin };
 import { type PageContextFromRewrite } from '../../shared/route/abort.js';
 import { type ScrollTarget } from './setScrollPosition.js';
-import type { VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../shared/getPageFiles.js';
 import type { PageContextClient } from '../../types/PageContext.js';
+import type { VikeGlobalInternal } from '../../types/VikeGlobalInternal.js';
 declare const firstRenderStartPromise: Promise<void>;
 type PageContextRouted = {
     pageId: string;
@@ -43,7 +44,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
     _globalContext: {
         isGlobalContext: true;
         _isOriginalObject: true;
-        _virtualFileExports: unknown;
+        _virtualFileExportsGlobalEntry: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -56,7 +57,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
         };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
         };
     } & {
         isClientSide: true;
@@ -83,7 +84,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
     isHydration: boolean;
     previousPageContext: ({
         pageId: string;
-    } & VikeConfigPublicPageLazy & PageContextRouted & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & import("../../types/PageContext.js").PageContextInternalClient & Omit<Partial<{
+    } & VikeConfigPublicPageLazyLoaded & PageContextRouted & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & import("../../types/PageContext.js").PageContextInternalClient & Omit<Partial<{
         isPageContext: true;
         Page: import("../../types/Config.js").Config["Page"];
         routeParams: Record<string, string>;
@@ -156,9 +157,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
     }) | null;
 }>;
 declare global {
-    var _vike: {
-        fullyRenderedUrl?: string;
-    } | undefined;
+    var _vike: VikeGlobalInternal;
 }
 declare function disableClientRouting(err: unknown, log: boolean): void;
 declare function getRenderCount(): number;

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

@@ -3,7 +3,7 @@ export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
-import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop, } from './utils.js';
+import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, updateType, 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';
@@ -159,7 +159,7 @@ async function renderPageClientSide(renderArgs) {
             await onError(res.err);
             return;
         }
-        augmentType(pageContext, res.pageContext);
+        updateType(pageContext, res.pageContext);
         setPageContextCurrent(pageContext);
         // Set global hydrationCanBeAborted
         if (pageContext.exports.hydrationCanBeAborted) {
@@ -184,7 +184,7 @@ async function renderPageClientSide(renderArgs) {
             }
             if (isRenderOutdated())
                 return;
-            augmentType(pageContext, pageContextAugmented);
+            updateType(pageContext, pageContextAugmented);
             // Render page view
             await renderPageView(pageContext);
         }
@@ -225,7 +225,7 @@ async function renderPageClientSide(renderArgs) {
             }
             if (isRenderOutdated())
                 return;
-            augmentType(pageContext, pageContextFromClientHooks);
+            updateType(pageContext, pageContextFromClientHooks);
             await renderPageView(pageContext);
         }
     }
@@ -336,7 +336,7 @@ async function renderPageClientSide(renderArgs) {
             onError(res.err);
             return;
         }
-        augmentType(pageContext, res.pageContext);
+        updateType(pageContext, res.pageContext);
         setPageContextCurrent(pageContext);
         let pageContextFromServerHooks;
         try {
@@ -364,7 +364,7 @@ async function renderPageClientSide(renderArgs) {
         }
         if (isRenderOutdated())
             return;
-        augmentType(pageContext, pageContextFromClientHooks);
+        updateType(pageContext, pageContextFromClientHooks);
         await renderPageView(pageContext, args);
     }
     async function renderPageView(pageContext, isErrorPage) {

package/dist/esm/client/runtime-client-routing/utils.d.ts

@@ -17,7 +17,7 @@ export * from '../../utils/slice.js';
 export * from '../../utils/throttle.js';
 export * from '../../utils/assertRoutingType.js';
 export * from '../../utils/onPageVisibilityChange.js';
-export * from '../../utils/augmentType.js';
+export * from '../../utils/updateType.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/catchInfiniteLoop.js';

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

@@ -21,7 +21,7 @@ export * from '../../utils/slice.js';
 export * from '../../utils/throttle.js';
 export * from '../../utils/assertRoutingType.js';
 export * from '../../utils/onPageVisibilityChange.js';
-export * from '../../utils/augmentType.js';
+export * from '../../utils/updateType.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/catchInfiniteLoop.js';

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

@@ -9,7 +9,7 @@ declare function createPageContextClientSide(): Promise<{
     _globalContext: {
         isGlobalContext: true;
         _isOriginalObject: true;
-        _virtualFileExports: unknown;
+        _virtualFileExportsGlobalEntry: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -22,7 +22,7 @@ declare function createPageContextClientSide(): Promise<{
         };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
         };
     } & {
         isClientSide: true;
@@ -38,6 +38,6 @@ declare function createPageContextClientSide(): Promise<{
     _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 & {
+} & import("../../shared/getPageFiles.js").VikeConfigPublicPageLazyLoaded & {
     _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
 }>;

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

@@ -1,5 +1,5 @@
 export { createPageContextClientSide };
-import { assertUsage, augmentType, objectAssign } from './utils.js';
+import { assertUsage, updateType, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
 import { loadPageConfigsLazyClientSide, } from '../shared/loadPageConfigsLazyClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
@@ -22,9 +22,9 @@ async function createPageContextClientSide() {
     });
     objectAssign(pageContextCreated, getPageContextSerializedInHtml());
     // Sets pageContext.config to global configs
-    augmentType(pageContextCreated, createPageContextShared(pageContextCreated, globalContext._vikeConfigPublicGlobal));
+    updateType(pageContextCreated, createPageContextShared(pageContextCreated, globalContext._vikeConfigPublicGlobal));
     // Sets pageContext.config to local configs (overrides the pageContext.config set above)
-    augmentType(pageContextCreated, await loadPageConfigsLazyClientSideAndExecHook(pageContextCreated));
+    updateType(pageContextCreated, await loadPageConfigsLazyClientSideAndExecHook(pageContextCreated));
     assertPristineUrl();
     return pageContextCreated;
 }

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

@@ -7,7 +7,7 @@ type GlobalContextClientInternalWithServerRouting = Awaited<ReturnType<typeof ge
 declare const getGlobalContextClientInternal: () => Promise<{
     isGlobalContext: true;
     _isOriginalObject: true;
-    _virtualFileExports: unknown;
+    _virtualFileExportsGlobalEntry: unknown;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -20,7 +20,7 @@ declare const getGlobalContextClientInternal: () => Promise<{
     };
     config: import("../../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+        [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
     };
 } & {
     isClientSide: true;

package/dist/esm/client/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:entry:client:server-routing';
-const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExports, false);
+import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:server-routing';
+const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExportsGlobalEntry, false);

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

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

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

@@ -10,5 +10,5 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js';
 export * from '../../utils/getPropAccessNotation.js';
-export * from '../../utils/augmentType.js';
+export * from '../../utils/updateType.js';
 export * from '../../utils/changeEnumerable.js';

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

@@ -14,5 +14,5 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js'; // Only used by Server Routing (not needed for Client Routing)
 export * from '../../utils/getPropAccessNotation.js';
-export * from '../../utils/augmentType.js';
+export * from '../../utils/updateType.js';
 export * from '../../utils/changeEnumerable.js';

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

@@ -5,10 +5,10 @@ export type GlobalContextClientInternalShared = GlobalContextClientInternal | Gl
 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<{
+declare function createGetGlobalContextClient<GlobalContextAddendum extends object>(virtualFileExportsGlobalEntry: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>): () => Promise<{
     isGlobalContext: true;
     _isOriginalObject: true;
-    _virtualFileExports: unknown;
+    _virtualFileExportsGlobalEntry: unknown;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -21,7 +21,7 @@ declare function createGetGlobalContextClient<GlobalContextAddendum extends obje
     };
     config: import("../../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+        [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
     };
 } & {
     /**

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

@@ -13,23 +13,23 @@ const globalObject = getGlobalObject('createGetGlobalContextClient.ts', (() => {
         globalContextInitialPromiseResolve,
     };
 })());
-function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGlobalContext) {
+function createGetGlobalContextClient(virtualFileExportsGlobalEntry, isClientRouting, addGlobalContext) {
     assert(globalObject.isClientRouting === undefined || globalObject.isClientRouting === isClientRouting);
     globalObject.isClientRouting = isClientRouting;
     // Eagerly call onCreateGlobalContext() hook
     getGlobalContext();
     return getGlobalContext;
     async function getGlobalContext() {
-        // HMR => virtualFileExports differ
-        if (globalObject.virtualFileExports === virtualFileExports) {
+        // HMR => virtualFileExportsGlobalEntry differ
+        if (globalObject.virtualFileExportsGlobalEntry === virtualFileExportsGlobalEntry) {
             const globalContext = await globalObject.globalContextPromise;
             return globalContext;
         }
         else {
-            globalObject.virtualFileExports = virtualFileExports;
+            globalObject.virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry;
         }
         // Create
-        const globalContextPromise = createGlobalContextShared(virtualFileExports, globalObject, undefined, async (globalContext) => {
+        const globalContextPromise = createGlobalContextShared(virtualFileExportsGlobalEntry, globalObject, undefined, async (globalContext) => {
             const globalContextAddendum = {
                 /**
                  * Whether the environment is client-side or server-side / pre-rendering.

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

@@ -1,6 +1,6 @@
 export { execHookOnRenderClient };
 export type { PageContextBeforeRenderClient };
-import type { PageFile, VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import type { PageFile, VikeConfigPublicPageLazyLoaded } from '../../shared/getPageFiles.js';
 import type { PageContextForPublicUsageClientShared } from './preparePageContextForPublicUsageClientShared.js';
 import type { GlobalContextClientInternalShared } from './createGetGlobalContextClient.js';
 type PageContextBeforeRenderClient = {
@@ -9,5 +9,5 @@ type PageContextBeforeRenderClient = {
     urlPathname?: string;
     pageId: string;
     _globalContext: GlobalContextClientInternalShared;
-} & VikeConfigPublicPageLazy & PageContextForPublicUsageClientShared;
+} & VikeConfigPublicPageLazyLoaded & PageContextForPublicUsageClientShared;
 declare function execHookOnRenderClient<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

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

@@ -11,7 +11,7 @@ type PageContext_loadPageConfigsLazyClientSide = {
         _pageConfigGlobal: PageConfigGlobalRuntime;
     };
 };
-declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<import("../../shared/getPageFiles.js").VikeConfigPublicPageLazyLoaded & {
     _pageFilesLoaded: PageFile[];
 }>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

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

@@ -1,9 +1,9 @@
 export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
-import { resolveVikeConfigPublicPageLazy } from '../../shared/page-configs/resolveVikeConfigPublic.js';
+import { resolveVikeConfigPublicPageLazyLoaded } from '../../shared/page-configs/resolveVikeConfigPublic.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
-import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
+import { loadAndParseVirtualFilePageEntry } from '../../shared/page-configs/loadAndParseVirtualFilePageEntry.js';
 import { objectAssign } from '../runtime-server-routing/utils.js';
 const errStamp = '_isAssetsError';
 async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
@@ -16,7 +16,7 @@ async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs,
         // prettier-ignore
         // biome-ignore format:
         const result = await Promise.all([
-            pageConfig && loadConfigValues(pageConfig, isDev),
+            pageConfig && loadAndParseVirtualFilePageEntry(pageConfig, isDev),
             ...pageFilesClientSide.map((p) => p.loadFile?.()),
         ]);
         pageConfigLoaded = result[0];
@@ -30,7 +30,7 @@ async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs,
         }
         throw err;
     }
-    const configPublicPageLazy = resolveVikeConfigPublicPageLazy(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
+    const configPublicPageLazy = resolveVikeConfigPublicPageLazyLoaded(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, configPublicPageLazy);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

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

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

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

@@ -1,8 +1,8 @@
 export { build };
-import type { APIOptions } from './types.js';
+import type { ApiOptions } from './types.js';
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
-declare function build(options?: APIOptions): Promise<{}>;
+declare function build(options?: ApiOptions): Promise<{}>;

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

@@ -1,45 +1,19 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
-import { build as buildVite, version, createBuilder } from 'vite';
-import { isVikeCli } from '../cli/context.js';
-import { wasPrerenderRun } from '../prerender/context.js';
-import { assert, assertVersion } from './utils.js';
+import { createBuilder } from 'vite';
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigFromUserEnhanced, vikeConfig } = await prepareViteApiCall(options, 'build');
-    // Pass it to pluginAutoFullBuild()
+    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'build');
+    // Pass it to vike:build:pluginBuildApp
     if (viteConfigFromUserEnhanced)
         viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
-    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);
-        // See Vite plugin vike:build:pluginBuildApp
-        await builder.buildApp();
-    }
-    else {
-        // This buildVite() call does everything:
-        // 1. Build client-side
-        // 2. Build server-side
-        //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L90
-        // 3. Pre-render (if enabled)
-        //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L98
-        //    > We purposely don't start the pre-rendering in this `build()` function but in a Rollup hook instead.
-        //    > 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 (
-        // 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);
-        }
-    }
+    const builder = await createBuilder(viteConfigFromUserEnhanced);
+    // buildApp() is implemented by vike:build:pluginBuildApp
+    await builder.buildApp();
     return {
     /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`
     viteConfig: viteConfigFromUserEnhanced,

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

@@ -1,13 +1,13 @@
 export { isVikeCliOrApi };
-export { setContextApiOperation };
-export { clearContextApiOperation };
-export { getApiOperation };
-import type { APIOptions, Operation } from './types.js';
-type ApiOperation = {
-    operation: Operation;
-    options: APIOptions;
+export { setContextVikeApiOperation };
+export { clearContextVikeApiOperation };
+export { getVikeApiOperation };
+import type { ApiOptions, ApiOperation } from './types.js';
+type VikeApiOperation = {
+    operation: ApiOperation;
+    options: ApiOptions;
 };
-declare function getApiOperation(): ApiOperation | null;
+declare function getVikeApiOperation(): VikeApiOperation | null;
 declare function isVikeCliOrApi(): boolean;
-declare function setContextApiOperation(operation: Operation, options: APIOptions): void;
-declare function clearContextApiOperation(): void;
+declare function setContextVikeApiOperation(operation: ApiOperation, options: ApiOptions): void;
+declare function clearContextVikeApiOperation(): void;

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

@@ -1,20 +1,21 @@
 export { isVikeCliOrApi };
-export { setContextApiOperation };
-export { clearContextApiOperation };
-export { getApiOperation };
-import { assert, getGlobalObject } from './utils.js';
+export { setContextVikeApiOperation };
+export { clearContextVikeApiOperation };
+export { getVikeApiOperation };
+// We don't import from ./utils.js because we tolerate this file to be loaded in production
+import { assert, getGlobalObject } from '../runtime/utils.js';
 const globalObject = getGlobalObject('api/context.ts', {});
-function getApiOperation() {
-    return globalObject.apiOperation ?? null;
+function getVikeApiOperation() {
+    return globalObject.vikeApiOperation ?? null;
 }
 function isVikeCliOrApi() {
     // The CLI uses the API
-    return !!globalObject.apiOperation;
+    return !!globalObject.vikeApiOperation;
 }
-function setContextApiOperation(operation, options) {
-    assert(!globalObject.apiOperation);
-    globalObject.apiOperation = { operation, options };
+function setContextVikeApiOperation(operation, options) {
+    assert(!globalObject.vikeApiOperation);
+    globalObject.vikeApiOperation = { operation, options };
 }
-function clearContextApiOperation() {
-    globalObject.apiOperation = undefined;
+function clearContextVikeApiOperation() {
+    globalObject.vikeApiOperation = undefined;
 }

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

@@ -1,12 +1,12 @@
 export { dev };
 import { type ResolvedConfig, type ViteDevServer } from 'vite';
-import type { APIOptions } from './types.js';
+import type { ApiOptions } from './types.js';
 /**
  * Programmatically trigger `$ vike dev`
  *
  * https://vike.dev/api#dev
  */
-declare function dev(options?: APIOptions): Promise<{
+declare function dev(options?: ApiOptions): Promise<{
     viteServer: ViteDevServer;
     viteConfig: ResolvedConfig;
 }>;

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

@@ -1,14 +1,12 @@
 export { dev };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { createServer } from 'vite';
-import { setGlobalContext_isProduction } from '../runtime/globalContext.js';
 /**
  * Programmatically trigger `$ vike dev`
  *
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    setGlobalContext_isProduction(false);
     const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'dev');
     const server = await createServer(viteConfigFromUserEnhanced);
     return {

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

@@ -2,8 +2,6 @@ export { build_ as build };
 export { dev_ as dev };
 export { preview_ as preview };
 export { prerender_ as prerender };
-import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-assertIsNotBrowser();
 const build_ = async (...args) => (await import('./build.js')).build(...args);
 const dev_ = async (...args) => (await import('./dev.js')).dev(...args);
 const preview_ = async (...args) => (await import('./preview.js')).preview(...args);

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

@@ -1,6 +1,6 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assertIsNotProductionRuntime } from '../runtime/utils.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
 function onLoad() {
     assertIsNotBrowser();
     assertIsNotProductionRuntime();

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

@@ -3,13 +3,11 @@ export { getViteRoot };
 export { assertViteRoot };
 export { normalizeViteRoot };
 import type { InlineConfig, ResolvedConfig } from 'vite';
-import type { APIOptions, Operation } from './types.js';
-import { type VikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
-declare function prepareViteApiCall(options: APIOptions, operation: Operation): Promise<{
-    vikeConfig: VikeConfigInternal;
+import type { ApiOptions, ApiOperation } from './types.js';
+declare function prepareViteApiCall(options: ApiOptions, operation: ApiOperation): Promise<{
     viteConfigResolved: ResolvedConfig;
     viteConfigFromUserEnhanced: InlineConfig | undefined;
 }>;
-declare function getViteRoot(operation: Operation): Promise<string>;
+declare function getViteRoot(operation: ApiOperation): Promise<string>;
 declare function normalizeViteRoot(root: string): string;
 declare function assertViteRoot(root: string, config: ResolvedConfig): void;