vike 0.4.230 → 0.4.231-commit-a0ca5e4

package/dist/esm/shared/createGlobalContextShared.d.ts

@@ -1,13 +1,16 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
-export type { GlobalContextShared };
-export type { GlobalContextSharedPublic };
+export type { GlobalContextBase };
+export type { GlobalContextBasePublic };
+export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextClientInternal;
 import type { PageFile } from './getPageFiles.js';
-import type { PageConfigRuntime } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../types/PageConfig.js';
+import type { GlobalContextServerInternal } from '../node/runtime/globalContext.js';
+import type { GlobalContextClientInternal } from '../client/runtime-client-routing/globalContext.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 declare function createGlobalContextShared<GlobalContextAddendum extends object>(virtualFileExports: unknown, globalObject: {
     globalContext?: Record<string, unknown>;
-}, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): Promise<{
+}, addGlobalContext?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>): Promise<{
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -18,22 +21,21 @@ declare function createGlobalContextShared<GlobalContextAddendum extends object>
     _virtualFileExports: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
-    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _userFriendlyConfigsGlobal: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
-    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    _vikeConfigPublicGlobal: {
+        config: import("../types/index.js").ConfigResolved;
+        _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    };
+    config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-            route: import("./page-configs/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
 } & Awaited<GlobalContextAddendum>>;
-type GlobalContextSharedPublic = Pick<GlobalContextShared, 'config' | 'pages' | 'isGlobalContext'>;
-type GlobalContextShared = ReturnType<typeof createGlobalContextBase>;
+type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
+type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
 declare function createGlobalContextBase(virtualFileExports: unknown): {
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -45,17 +47,16 @@ declare function createGlobalContextBase(virtualFileExports: unknown): {
     _virtualFileExports: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
-    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _userFriendlyConfigsGlobal: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
-    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    _vikeConfigPublicGlobal: {
+        config: import("../types/index.js").ConfigResolved;
+        _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    };
+    config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-            route: import("./page-configs/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
 };

package/dist/esm/shared/createGlobalContextShared.js

@@ -1,8 +1,8 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
 import { changeEnumerable, objectAssign, unique } from './utils.js';
-import { parseGlobResults } from './getPageFiles/parseGlobResults.js';
-import { getUserFriendlyConfigsGlobal, getUserFriendlyConfigsPageEager } from './page-configs/getUserFriendlyConfigs.js';
+import { parseVirtualFileExports } from './getPageFiles/parseVirtualFileExports.js';
+import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEager } from './page-configs/resolveVikeConfigPublic.js';
 import { execHookGlobal } from './hooks/execHook.js';
 import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
@@ -33,7 +33,7 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
     return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExports) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, userFriendlyConfigsGlobal, userFriendlyConfigsPageEager } = getConfigsAll(virtualFileExports);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, vikeConfigPublicGlobal, vikeConfigPublicPagesEager } = getConfigsAll(virtualFileExports);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -47,29 +47,29 @@ function createGlobalContextBase(virtualFileExports) {
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
-        _userFriendlyConfigsGlobal: userFriendlyConfigsGlobal,
-        config: userFriendlyConfigsGlobal.config,
-        pages: userFriendlyConfigsPageEager
+        _vikeConfigPublicGlobal: vikeConfigPublicGlobal,
+        config: vikeConfigPublicGlobal.config,
+        pages: vikeConfigPublicPagesEager
     };
     changeEnumerable(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
 function getConfigsAll(virtualFileExports) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseGlobResults(virtualFileExports);
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExports(virtualFileExports);
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
-    const userFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal({
+    const vikeConfigPublicGlobal = resolveVikeConfigPublicGlobal({
         pageConfigGlobalValues: pageConfigGlobal.configValues
     });
-    const userFriendlyConfigsPageEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        return getUserFriendlyConfigsPageEager(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
+    const vikeConfigPublicPagesEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
+        return resolveVikeConfigPublicPageEager(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
     }));
     return {
         pageFilesAll,
         allPageIds,
         pageConfigs,
         pageConfigGlobal,
-        userFriendlyConfigsGlobal,
-        userFriendlyConfigsPageEager
+        vikeConfigPublicGlobal,
+        vikeConfigPublicPagesEager
     };
 }
 function getAllPageIds(pageFilesAll, pageConfigs) {

package/dist/esm/shared/createPageContextShared.d.ts

@@ -1,9 +1,14 @@
 export { createPageContextShared };
 export { createPageContextObject };
-import type { PageConfigUserFriendly } from './page-configs/getUserFriendlyConfigs.js';
-import type { PageConfigGlobalRuntime } from './page-configs/PageConfig.js';
+import type { VikeConfigPublicGlobal } from './page-configs/resolveVikeConfigPublic.js';
+import type { PageConfigGlobalRuntime } from '../types/PageConfig.js';
 import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
-declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, userFriendlyConfigsGlobal: PageConfigUserFriendly): Promise<T & PageConfigUserFriendly>;
+declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, vikeConfigPublicGlobal: VikeConfigPublicGlobal): Promise<T & {
+    config: import("../types/index.js").ConfigResolved;
+    _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+}>;
 declare function createPageContextObject(): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/esm/shared/createPageContextShared.js

@@ -3,8 +3,8 @@ export { createPageContextObject };
 import { execHookGlobal } from './hooks/execHook.js';
 import { preparePageContextForPublicUsage } from './preparePageContextForPublicUsage.js';
 import { changeEnumerable, objectAssign } from './utils.js';
-async function createPageContextShared(pageContextCreated, pageConfigGlobal, userFriendlyConfigsGlobal) {
-    objectAssign(pageContextCreated, userFriendlyConfigsGlobal);
+async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
+    objectAssign(pageContextCreated, vikeConfigPublicGlobal);
     await execHookGlobal('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage);
     return pageContextCreated;
 }

package/dist/esm/shared/error-page.d.ts

@@ -1,7 +1,7 @@
 export { getErrorPageId };
 export { isErrorPageId };
 export { isErrorPage };
-import type { PageConfigRuntime } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../types/PageConfig.js';
 import type { PageFile } from './getPageFiles.js';
 declare function getErrorPageId(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): string | null;
 declare function isErrorPageId(pageId: string, _isV1Design: false): boolean;

package/dist/esm/shared/getPageFiles/analyzeClientSide.d.ts

@@ -1,5 +1,5 @@
 export { analyzeClientSide };
-import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../types/PageConfig.js';
 import type { PageFile } from './getPageFileObject.js';
 declare function analyzeClientSide(pageConfig: PageConfigRuntime | null, pageFilesAll: PageFile[], pageId: string): {
     isClientRuntimeLoaded: boolean;

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.d.ts

@@ -11,4 +11,4 @@ declare function determineClientEntry({ pageFilesClientSide, pageFilesServerSide
     clientEntries: string[];
     clientDependencies: ClientDependency[];
 };
-declare function getVikeClientEntry(isClientRouting: boolean): "@@vike/dist/esm/client/client-routing-runtime/entry.js" | "@@vike/dist/esm/client/server-routing-runtime/entry.js";
+declare function getVikeClientEntry(isClientRouting: boolean): "@@vike/dist/esm/client/runtime-client-routing/entry.js" | "@@vike/dist/esm/client/runtime-server-routing/entry.js";

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -23,6 +23,6 @@ function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtml
 }
 function getVikeClientEntry(isClientRouting) {
     return isClientRouting
-        ? '@@vike/dist/esm/client/client-routing-runtime/entry.js'
-        : '@@vike/dist/esm/client/server-routing-runtime/entry.js';
+        ? '@@vike/dist/esm/client/runtime-client-routing/entry.js'
+        : '@@vike/dist/esm/client/runtime-server-routing/entry.js';
 }

package/dist/esm/shared/getPageFiles/analyzePageClientSide.js

@@ -32,7 +32,6 @@ async function analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFiles
         if (sharedPageFilesAlreadyLoaded && p.isEnv('CLIENT_AND_SERVER')) {
             return;
         }
-        // TODO: Is `loadExportNames()` cached ? Does it use filesExports if possible? HMR?
         await p.loadExportNames?.();
         /*
         if (pageFile.exportNames) {

package/dist/esm/shared/getPageFiles/{parseGlobResults.d.ts → parseVirtualFileExports.d.ts}

@@ -1,7 +1,7 @@
-export { parseGlobResults };
+export { parseVirtualFileExports };
 import { type PageFile } from './getPageFileObject.js';
-import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
-declare function parseGlobResults(pageFilesExports: unknown): {
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../types/PageConfig.js';
+declare function parseVirtualFileExports(virtualFileExports: unknown): {
     pageFilesAll: PageFile[];
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;

package/dist/esm/shared/getPageFiles/{parseGlobResults.js → parseVirtualFileExports.js}

@@ -1,27 +1,27 @@
-export { parseGlobResults };
+export { parseVirtualFileExports };
 // TODO/v1-release: remove old design code, and remove all assertions.
 import { assert, hasProp, isCallable, isObject, cast, isArray } from '../utils.js';
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
 import { parsePageConfigs } from '../page-configs/serialize/parsePageConfigs.js';
-// TODO/now: rename
-function parseGlobResults(pageFilesExports) {
-    assert(hasProp(pageFilesExports, 'pageFilesLazy', 'object'));
-    assert(hasProp(pageFilesExports, 'pageFilesEager', 'object'));
-    assert(hasProp(pageFilesExports, 'pageFilesExportNamesLazy', 'object'));
-    assert(hasProp(pageFilesExports, 'pageFilesExportNamesEager', 'object'));
-    assert(hasProp(pageFilesExports.pageFilesLazy, '.page'));
-    assert(hasProp(pageFilesExports.pageFilesLazy, '.page.client') || hasProp(pageFilesExports.pageFilesLazy, '.page.server'));
-    assert(hasProp(pageFilesExports, 'pageFilesList', 'string[]'));
-    assert(hasProp(pageFilesExports, 'pageConfigsSerialized'));
-    assert(hasProp(pageFilesExports, 'pageConfigGlobalSerialized'));
-    const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
+function parseVirtualFileExports(virtualFileExports) {
+    assert(hasProp(virtualFileExports, 'pageFilesLazy', 'object'));
+    assert(hasProp(virtualFileExports, 'pageFilesEager', 'object'));
+    assert(hasProp(virtualFileExports, 'pageFilesExportNamesLazy', 'object'));
+    assert(hasProp(virtualFileExports, 'pageFilesExportNamesEager', 'object'));
+    assert(hasProp(virtualFileExports.pageFilesLazy, '.page'));
+    assert(hasProp(virtualFileExports.pageFilesLazy, '.page.client') ||
+        hasProp(virtualFileExports.pageFilesLazy, '.page.server'));
+    assert(hasProp(virtualFileExports, 'pageFilesList', 'string[]'));
+    assert(hasProp(virtualFileExports, 'pageConfigsSerialized'));
+    assert(hasProp(virtualFileExports, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExports;
     assertPageConfigsSerialized(pageConfigsSerialized);
     assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
     const { pageConfigs, pageConfigGlobal } = parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
-    parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const loadModule = globValue;
         assertLoadModule(loadModule);
@@ -32,7 +32,7 @@ function parseGlobResults(pageFilesExports) {
             }
         };
     });
-    parseGlobResult(pageFilesExports.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const loadModule = globValue;
         assertLoadModule(loadModule);
@@ -45,20 +45,20 @@ function parseGlobResults(pageFilesExports) {
         };
     });
     // `pageFilesEager` contains `.page.route.js` files
-    parseGlobResult(pageFilesExports.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const moduleExports = globValue;
         assert(isObject(moduleExports));
         pageFile.fileExports = moduleExports;
     });
-    parseGlobResult(pageFilesExports.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const moduleExports = globValue;
         assert(isObject(moduleExports));
         assert(hasProp(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
         pageFile.exportNames = moduleExports.exportNames;
     });
-    pageFilesExports.pageFilesList.forEach((filePath) => {
+    virtualFileExports.pageFilesList.forEach((filePath) => {
         pageFilesMap[filePath] = pageFilesMap[filePath] ?? getPageFileObject(filePath);
     });
     const pageFilesAll = Object.values(pageFilesMap);

package/dist/esm/shared/getPageFiles.d.ts

@@ -1,4 +1,4 @@
 export type { PageFile } from './getPageFiles/getPageFileObject.js';
-export type { ExportsAll, PageConfigUserFriendlyOld } from './page-configs/getUserFriendlyConfigs.js';
+export type { ExportsAll, VikeConfigPublicPageLazy } from './page-configs/resolveVikeConfigPublic.js';
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';

package/dist/esm/shared/getProxyForPublicUsage.d.ts

@@ -1,4 +1,4 @@
 export { getProxyForPublicUsage };
 type Target = Record<string, unknown>;
 type Fallback = (prop: string | symbol) => unknown;
-declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: string, skipOnInternalProp?: true, fallback?: Fallback): Obj;
+declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: 'pageContext' | 'globalContext' | 'prerenderContext' | 'vikeConfig', skipOnInternalProp?: true, fallback?: Fallback): Obj;

package/dist/esm/shared/getProxyForPublicUsage.js

@@ -45,7 +45,7 @@ function onInternalProp(propStr, objName) {
     //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use import.meta.env.SSR
     if (isBrowser())
         return;
-    // TODO/now remove this and only warn on built-in access instead
+    // TODO/now-proxy remove this and only warn on built-in access instead
     if (propStr === '_configFromHook')
         return;
     if (propStr.startsWith('_')) {

package/dist/esm/shared/hooks/execHook.d.ts

@@ -10,16 +10,16 @@ export { getPageContext };
 export { providePageContext };
 export { isUserHookError };
 export type { PageContextExecuteHook };
-import type { PageContextClient, PageContextServer } from '../types.js';
+import type { PageContextClient, PageContextServer } from '../../types/PageContext.js';
 import type { Hook, HookLoc } from './getHook.js';
-import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
-import type { HookName, HookNameGlobal } from '../page-configs/Config.js';
-import type { PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+import type { VikeConfigPublicPageLazy } from '../getPageFiles.js';
+import type { HookName, HookNameGlobal } from '../../types/Config.js';
+import type { PageConfigGlobalRuntime } from '../../types/PageConfig.js';
 import type { PageContextForPublicUsageServer } from '../../node/runtime/renderPage/preparePageContextForPublicUsageServer.js';
 import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
 import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-type PageContextExecuteHook = PageConfigUserFriendlyOld & PageContextForPublicUsage;
+type PageContextExecuteHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;

package/dist/esm/shared/hooks/getHook.d.ts

@@ -9,9 +9,9 @@ export type { HookLoc };
 export type { HookTimeout };
 export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
-import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
-import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../page-configs/Config.js';
-import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
+import type { VikeConfigPublicPageLazy } from '../getPageFiles.js';
+import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../../types/Config.js';
+import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
 import type { PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 type Hook = HookLoc & {
@@ -28,8 +28,8 @@ type HookTimeout = {
     warning: number | false;
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookNameOld, false | Partial<HookTimeout>>>;
-declare function getHookFromPageContext(pageContext: PageConfigUserFriendlyOld, hookName: HookNameOld): null | Hook;
-declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageConfigUserFriendlyOld): Hook[];
+declare function getHookFromPageContext(pageContext: VikeConfigPublicPageLazy, hookName: HookNameOld): null | Hook;
+declare function getHookFromPageContextNew(hookName: HookName, pageContext: VikeConfigPublicPageLazy): Hook[];
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
 declare function getHookFromPageConfigGlobalCumulative(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook[];

package/dist/esm/shared/page-configs/assertPlusFileExport.js

@@ -17,7 +17,7 @@ function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
     const exportDefault = pc.code('export default');
     const exportNamed = pc.code(`export { ${configName} }`);
     if (exportNamesValid.length === 0) {
-        assertUsage(false, `${filePathToShowToUser} should have ${exportNamed} or ${exportDefault}`);
+        assertUsage(false, `${filePathToShowToUser} should define ${exportNamed} or ${exportDefault}`);
     }
     if (exportNamesValid.length === 2) {
         assertUsage(false, `${filePathToShowToUser} is ambiguous: remove ${exportDefault} or ${exportNamed}`);

package/dist/esm/shared/page-configs/findPageConfig.d.ts

@@ -1,3 +1,3 @@
 export { findPageConfig };
-import type { PageConfigRuntime } from './PageConfig.js';
+import type { PageConfigRuntime } from '../../types/PageConfig.js';
 declare function findPageConfig(pageConfigs: PageConfigRuntime[], pageId: string): null | PageConfigRuntime;

package/dist/esm/shared/page-configs/getConfigDefinedAt.d.ts

@@ -4,7 +4,7 @@ export { getDefinedAtString };
 export { getDefinedByString };
 export type { ConfigDefinedAt };
 export type { ConfigDefinedAtOptional };
-import type { DefinedAtData, DefinedBy } from './PageConfig.js';
+import type { DefinedAtData, DefinedBy } from '../../types/PageConfig.js';
 type ConfigDefinedAtOptional = ConfigDefinedAt | `Config ${string} defined internally`;
 type ConfigDefinedAt = `Config ${string} defined at ${string}`;
 declare function getConfigDefinedAt<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: NonNullable<DefinedAtData>): `${SentenceBegin} ${ConfigName} defined at ${string}`;

package/dist/esm/shared/page-configs/getConfigValueBuildTime.d.ts

@@ -1,7 +1,7 @@
 export { getConfigValueBuildTime };
 import { type ResolveTypeAsString } from '../utils.js';
-import type { PageConfigBuildTime, ConfigValue } from './PageConfig.js';
-import type { ConfigNameBuiltIn } from './Config.js';
+import type { PageConfigBuildTime, ConfigValue } from '../../types/PageConfig.js';
+import type { ConfigNameBuiltIn } from '../../types/Config.js';
 import { type TypeAsString } from './getConfigValueTyped.js';
 declare function getConfigValueBuildTime<Type extends TypeAsString = undefined>(pageConfig: PageConfigBuildTime, configName: ConfigNameBuiltIn, type?: Type): null | (ConfigValue & {
     value: ResolveTypeAsString<Type>;

package/dist/esm/shared/page-configs/getConfigValueRuntime.d.ts

@@ -1,7 +1,7 @@
 export { getConfigValueRuntime };
 import { type ResolveTypeAsString } from '../utils.js';
-import type { PageConfigRuntime, ConfigValue } from './PageConfig.js';
-import type { ConfigNameBuiltIn } from './Config.js';
+import type { PageConfigRuntime, ConfigValue } from '../../types/PageConfig.js';
+import type { ConfigNameBuiltIn } from '../../types/Config.js';
 import { type TypeAsString } from './getConfigValueTyped.js';
 declare function getConfigValueRuntime<Type extends TypeAsString = undefined>(pageConfig: PageConfigRuntime, configName: ConfigNameBuiltIn, type?: Type): null | (ConfigValue & {
     value: ResolveTypeAsString<Type>;

package/dist/esm/shared/page-configs/getConfigValueTyped.d.ts

@@ -1,8 +1,8 @@
 export { getConfigValueTyped };
 export type { TypeAsString };
 import { type ResolveTypeAsString } from '../utils.js';
-import type { ConfigValue } from './PageConfig.js';
-import type { ConfigNameBuiltIn } from './Config.js';
+import type { ConfigValue } from '../../types/PageConfig.js';
+import type { ConfigNameBuiltIn } from '../../types/Config.js';
 type TypeAsString = 'string' | 'boolean' | undefined;
 declare function getConfigValueTyped<Type extends TypeAsString = undefined>(configValue: ConfigValue, configName: ConfigNameBuiltIn, type?: Type): null | (ConfigValue & {
     value: ResolveTypeAsString<Type>;

package/dist/esm/shared/page-configs/helpers.d.ts

@@ -1,7 +1,7 @@
 export { getPageConfig };
 export { getConfigValueFilePathToShowToUser };
 export { getHookFilePathToShowToUser };
-import type { PageConfigRuntime, DefinedAtData } from './PageConfig.js';
+import type { PageConfigRuntime, DefinedAtData } from '../../types/PageConfig.js';
 declare function getPageConfig(pageId: string, pageConfigs: PageConfigRuntime[]): PageConfigRuntime;
 declare function getConfigValueFilePathToShowToUser(definedAtData: DefinedAtData): null | string;
 declare function getHookFilePathToShowToUser(definedAtData: DefinedAtData): string;

package/dist/esm/shared/page-configs/loadConfigValues.d.ts

@@ -1,3 +1,3 @@
 export { loadConfigValues };
-import type { PageConfigRuntime, PageConfigRuntimeLoaded } from './PageConfig.js';
+import type { PageConfigRuntime, PageConfigRuntimeLoaded } from '../../types/PageConfig.js';
 declare function loadConfigValues(pageConfig: PageConfigRuntime, isDev: boolean): Promise<PageConfigRuntimeLoaded>;

package/dist/esm/shared/page-configs/loadConfigValues.js

@@ -7,7 +7,7 @@ async function loadConfigValues(pageConfig, isDev) {
         !isDev) {
         return pageConfig;
     }
-    const { moduleId, moduleExports } = pageConfig.loadConfigValuesAll();
+    const { moduleId, moduleExports } = pageConfig.loadConfigLazy();
     const configValuesLoaded = await moduleExports;
     // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
     if (!configValuesLoaded)

package/dist/esm/shared/page-configs/{getUserFriendlyConfigs.d.ts → resolveVikeConfigPublic.d.ts}

@@ -1,9 +1,9 @@
-export { getUserFriendlyConfigsGlobal };
-export { getUserFriendlyConfigsPageEager };
-export { getUserFriendlyConfigsPageLazy };
-export type { PageConfigsUserFriendly };
-export type { PageConfigUserFriendly };
-export type { PageConfigUserFriendlyOld };
+export { resolveVikeConfigPublicGlobal };
+export { resolveVikeConfigPublicPageEager };
+export { resolveVikeConfigPublicPageLazy };
+export type { VikeConfigPublicGlobal };
+export type { VikeConfigPublicPageEager };
+export type { VikeConfigPublicPageLazy };
 export type { Source };
 export type { Sources };
 export type { From };
@@ -11,10 +11,10 @@ export type { ExportsAll };
 export type { ConfigEntries };
 import type { FileType } from '../getPageFiles/fileTypes.js';
 import type { PageFile } from '../getPageFiles/getPageFileObject.js';
-import type { ConfigValues, PageConfigBuildTime, PageConfigGlobalRuntime, PageConfigRuntime, PageConfigRuntimeLoaded } from './PageConfig.js';
+import type { ConfigValues, PageConfigBuildTime, PageConfigGlobalRuntime, PageConfigRuntime, PageConfigRuntimeLoaded } from '../../types/PageConfig.js';
 import { type ConfigDefinedAtOptional } from './getConfigDefinedAt.js';
-import type { ConfigResolved } from './Config/PageContextConfig.js';
-import type { Route } from './Config.js';
+import type { ConfigResolved } from '../../types/Config/PageContextConfig.js';
+import type { Route } from '../../types/Config.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
     exportSource: string;
@@ -35,7 +35,7 @@ type ConfigEntries = Record<string, {
     configDefinedAt: ConfigDefinedAtOptional;
     configDefinedByFile: string | null;
 }[]>;
-type PageConfigUserFriendlyOld = {
+type VikeConfigPublicPageLazy = {
     config: ConfigResolved;
     source: Source;
     sources: Sources;
@@ -58,8 +58,7 @@ type Source = Record<string, // configName
 SourceAny>;
 type Sources = Record<string, // configName
 SourceAny[]>;
-type SourceAny = SourceConfigs;
-type SourceConfigs = SourceConfigsStandard | SourceConfigsCumulative | SourceConfigsComputed;
+type SourceAny = SourceConfigsStandard | SourceConfigsCumulative | SourceConfigsComputed;
 type SourceConfigsStandard = {
     type: 'configsStandard';
     value: unknown;
@@ -67,6 +66,7 @@ type SourceConfigsStandard = {
 };
 type SourceConfigsCumulative = {
     type: 'configsCumulative';
+    definedAt: string;
     values: {
         value: unknown;
         definedAt: string;
@@ -74,16 +74,15 @@ type SourceConfigsCumulative = {
 };
 type SourceConfigsComputed = {
     type: 'configsComputed';
+    definedAt: 'Vike';
     value: unknown;
 };
-type PageConfigUserFriendly = {
+type VikeConfigPublic = {
     config: ConfigResolved;
     _source: Source;
     _sources: Sources;
     _from: From;
 };
-type PageConfigsUserFriendly = Record<string, // pageId
-PageConfigUserFriendlyWithRoute>;
 type WithRoute = {
     route: Route;
     isErrorPage?: undefined;
@@ -91,11 +90,12 @@ type WithRoute = {
     route?: undefined;
     isErrorPage: true;
 };
-type PageConfigUserFriendlyWithRoute = PageConfigUserFriendly & WithRoute;
-declare function getUserFriendlyConfigsPageEager(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, PageConfigUserFriendlyWithRoute];
-declare function getUserFriendlyConfigsGlobal({ pageConfigGlobalValues }: {
+type VikeConfigPublicPageEager = VikeConfigPublic & WithRoute;
+type VikeConfigPublicGlobal = VikeConfigPublic;
+declare function resolveVikeConfigPublicPageEager(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, VikeConfigPublicPageEager];
+declare function resolveVikeConfigPublicGlobal({ pageConfigGlobalValues }: {
     pageConfigGlobalValues: ConfigValues;
-}): PageConfigUserFriendly;
-declare function getUserFriendlyConfigsPageLazy(pageFiles: PageFile[], // V0.4 design
+}): VikeConfigPublicGlobal;
+declare function resolveVikeConfigPublicPageLazy(pageFiles: PageFile[], // V0.4 design
 pageConfig: PageConfigRuntimeLoaded | null, // V1 design
-pageConfigGlobal: PageConfigGlobalRuntime): PageConfigUserFriendlyOld;
+pageConfigGlobal: PageConfigGlobalRuntime): VikeConfigPublicPageLazy;