vike 0.4.230-commit-f07cc20 → 0.4.231-commit-a0ca5e4

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;

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

@@ -1,51 +1,49 @@
-export { getUserFriendlyConfigsGlobal };
-export { getUserFriendlyConfigsPageEager };
-export { getUserFriendlyConfigsPageLazy };
+// TODO/now-same-api: use public API internally?
+// TODO/now-flat-pageContext: rename definedAt => definedBy
+export { resolveVikeConfigPublicGlobal };
+export { resolveVikeConfigPublicPageEager };
+export { resolveVikeConfigPublicPageLazy };
 import { assertDefaultExports, forbiddenDefaultExports } from '../getPageFiles/assert_exports_old_design.js';
 import { getConfigDefinedAtOptional, getDefinedAtString } from './getConfigDefinedAt.js';
 import { getConfigValueFilePathToShowToUser } from './helpers.js';
 import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser, isScriptFile, isTemplateFile, objectDefineProperty } from '../utils.js';
 import pc from '@brillout/picocolors';
-function getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
-    const pageConfigUserFriendly = getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues });
+function resolveVikeConfigPublicPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
+    const vikeConfigPublicPage_ = resolveVikeConfigPublic_base({ pageConfigGlobalValues, pageConfigValues });
+    const vikeConfigPublicPage = getPublicCopy(vikeConfigPublicPage_);
     let page;
     if (!pageConfig.isErrorPage) {
-        const route = pageConfigUserFriendly.config.route ?? pageConfig.routeFilesystem.routeString;
+        const route = vikeConfigPublicPage.config.route ?? pageConfig.routeFilesystem.routeString;
         page = {
-            ...pageConfigUserFriendly,
+            ...vikeConfigPublicPage,
             route
         };
     }
     else {
         page = {
-            ...pageConfigUserFriendly,
+            ...vikeConfigPublicPage,
             isErrorPage: true
         };
     }
     return [pageConfig.pageId, page];
 }
-function getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues }) {
-    const pageConfigUserFriendly = getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues });
-    return getPublicCopy(pageConfigUserFriendly);
-}
-function getPublicCopy(pageConfigUserFriendly) {
-    const p = pageConfigUserFriendly;
+function getPublicCopy(vikeConfigPublic) {
     return {
-        config: p.config,
-        _source: p.source,
-        _sources: p.sources,
-        _from: p.from
+        config: vikeConfigPublic.config,
+        _source: vikeConfigPublic.source,
+        _sources: vikeConfigPublic.sources,
+        _from: vikeConfigPublic.from
     };
 }
-function getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues }) {
+function resolveVikeConfigPublic_base({ pageConfigGlobalValues, pageConfigValues }) {
     const configValues = { ...pageConfigGlobalValues, ...pageConfigValues };
-    return getUserFriendlyConfigs_V1Design({ configValues });
+    return resolveVikeConfigPublic_V1Design({ configValues });
 }
-function getUserFriendlyConfigsGlobal({ pageConfigGlobalValues }) {
-    const pageConfigGlobalUserFriendly = getUserFriendlyConfigs_V1Design({ configValues: pageConfigGlobalValues });
-    return getPublicCopy(pageConfigGlobalUserFriendly);
+function resolveVikeConfigPublicGlobal({ pageConfigGlobalValues }) {
+    const vikeConfigPublicGlobal = resolveVikeConfigPublic_V1Design({ configValues: pageConfigGlobalValues });
+    return getPublicCopy(vikeConfigPublicGlobal);
 }
-function getUserFriendlyConfigsPageLazy(pageFiles, // V0.4 design
+function resolveVikeConfigPublicPageLazy(pageFiles, // V0.4 design
 pageConfig, // V1 design
 pageConfigGlobal) {
     const config = {};
@@ -72,7 +70,7 @@ pageConfigGlobal) {
     let sources;
     let from;
     if (pageConfig) {
-        const res = getUserFriendlyConfigs_base({
+        const res = resolveVikeConfigPublic_base({
             pageConfigGlobalValues: pageConfigGlobal.configValues,
             pageConfigValues: pageConfig.configValues
         });
@@ -112,7 +110,7 @@ pageConfigGlobal) {
         from,
         source,
         sources,
-        // TODO/eventually: deprecate/remove every prop below
+        // TODO/now-flat-pageContext: deprecate every prop below
         configEntries,
         exports,
         exportsAll
@@ -135,7 +133,7 @@ pageConfigGlobal) {
     return pageContextExports;
 }
 // V1 design
-function getUserFriendlyConfigs_V1Design(pageConfig) {
+function resolveVikeConfigPublic_V1Design(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};
@@ -188,6 +186,7 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
         if (configValue.type === 'cumulative') {
             const src = {
                 type: 'configsCumulative',
+                definedAt: getDefinedAtString(configValue.definedAtData, configName),
                 values: configValue.value.map((value, i) => {
                     const definedAtFile = configValue.definedAtData[i];
                     assert(definedAtFile);
@@ -205,6 +204,7 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
         if (configValue.type === 'computed') {
             const src = {
                 type: 'configsComputed',
+                definedAt: 'Vike', // Vike currently doesn't support user-land computed configs => computed configs are always defined by Vike => there isn't any file path to show.
                 value: configValue.value
             };
             addSrc(src, configName);

package/dist/esm/shared/page-configs/serialize/PageConfigSerialized.d.ts

@@ -2,12 +2,12 @@ export type { PageConfigRuntimeSerialized };
 export type { PageConfigGlobalRuntimeSerialized };
 export type { ConfigValueSerialized };
 export type { ValueSerialized };
-import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, PageConfigCommon, PageConfigRuntime } from '../PageConfig.js';
+import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, PageConfigCommon, PageConfigRuntime } from '../../../types/PageConfig.js';
 /** Page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
 type PageConfigRuntimeSerialized = PageConfigCommon & {
     /** Config values that are serializable and loaded eagerly such as config.passToClient */
     configValuesSerialized: Record<string, ConfigValueSerialized>;
-    loadConfigValuesAll: PageConfigRuntime['loadConfigValuesAll'];
+    loadConfigLazy: PageConfigRuntime['loadConfigLazy'];
 };
 type PageConfigGlobalRuntimeSerialized = {
     configValuesSerialized: Record<string, ConfigValueSerialized>;

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.d.ts

@@ -1,6 +1,6 @@
 export { parsePageConfigs };
 export { parseConfigValuesSerialized };
-import type { ConfigValues, PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
+import type { ConfigValues, PageConfigRuntime, PageConfigGlobalRuntime } from '../../../types/PageConfig.js';
 import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
 import type { ConfigValueSerialized } from './PageConfigSerialized.js';
 declare function parsePageConfigs(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.d.ts

@@ -2,7 +2,7 @@ export { serializeConfigValues };
 export { getConfigValuesBase };
 export { isJsonValue };
 export type { FilesEnv };
-import type { ConfigEnvInternal, ConfigValueSource, DefinedAt, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
+import type { ConfigEnvInternal, ConfigValueSource, DefinedAt, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../types/PageConfig.js';
 declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], filesEnv: FilesEnv, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
 declare function isJsonValue(value: unknown): boolean;
 declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, isEager: boolean | null): ConfigValuesBase;

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.js

@@ -2,12 +2,12 @@ export { serializeConfigValues };
 export { getConfigValuesBase };
 export { isJsonValue };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
-import { assert, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation, isImportPathRelative } from '../../../node/plugin/utils.js';
-import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/pointerImports.js';
+import { assert, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation, isImportPathRelative } from '../../../node/vite/utils.js';
+import { parsePointerImportData } from '../../../node/vite/shared/resolveVikeConfigInternal/pointerImports.js';
 import { getConfigValueFilePathToShowToUser } from '../helpers.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import pc from '@brillout/picocolors';
-import { isOverriden } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import { isOverriden } from '../../../node/vite/shared/resolveVikeConfigInternal.js';
 const stringifyOptions = { forbidReactElements: true };
 const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
 const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';

package/dist/esm/shared/preparePageContextForPublicUsage.js

@@ -27,7 +27,7 @@ function preparePageContextForPublicUsage(pageContext) {
     const globalContextPublic = prepareGlobalContextForPublicUsage(pageContext._globalContext);
     const pageContextPublic = getProxyForPublicUsage(pageContext, 'pageContext', 
     // We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
-    // - TODO/now: double check whether that's true
+    // - TODO/now-proxy: double check whether that's true
     true, (prop) => {
         if (prop === 'globalContext') {
             return globalContextPublic;

package/dist/esm/shared/route/executeGuardHook.d.ts

@@ -1,9 +1,8 @@
 export { executeGuardHook };
-import type { PageFile } from '../getPageFiles.js';
-import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
 import { type PageContextExecuteHook } from '../hooks/execHook.js';
+import type { GlobalContextInternal } from '../createGlobalContextShared.js';
 declare function executeGuardHook<PageContext extends {
     pageId: string;
-    _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfigRuntime[];
+} & {
+    _globalContext: GlobalContextInternal;
 } & PageContextExecuteHook>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

package/dist/esm/shared/route/executeGuardHook.js

@@ -5,11 +5,11 @@ import { execHookSingle } from '../hooks/execHook.js';
 const errIntro = 'The guard() hook defined by';
 async function executeGuardHook(pageContext, prepareForPublicUsage) {
     let hook;
-    if (pageContext._pageFilesAll.length > 0) {
+    if (pageContext._globalContext._pageFilesAll.length > 0) {
         // TODO/v1-release: remove
         // V0.4 design
-        assert(pageContext._pageConfigs.length === 0);
-        hook = findPageGuard(pageContext.pageId, pageContext._pageFilesAll);
+        assert(pageContext._globalContext._pageConfigs.length === 0);
+        hook = findPageGuard(pageContext.pageId, pageContext._globalContext._pageFilesAll);
     }
     else {
         // V1 design

package/dist/esm/shared/route/executeOnBeforeRouteHook.js

@@ -7,9 +7,9 @@ import { execHookSync } from '../hooks/execHook.js';
 import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
 async function executeOnBeforeRouteHook(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
-    if (!pageContext._onBeforeRouteHook)
+    if (!pageContext._globalContext._onBeforeRouteHook)
         return null;
-    const pageContextFromHook = await getPageContextFromHook(pageContext._onBeforeRouteHook, pageContext);
+    const pageContextFromHook = await getPageContextFromHook(pageContext._globalContext._onBeforeRouteHook, pageContext);
     if (pageContextFromHook) {
         objectAssign(pageContextFromOnBeforeRouteHook, pageContextFromHook);
         if (hasProp(pageContextFromOnBeforeRouteHook, 'pageId', 'string') ||
@@ -49,7 +49,7 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
     if (hasProp(hookReturn.pageContext, 'pageId') && !hasProp(hookReturn.pageContext, 'pageId', 'null')) {
         const errPrefix2 = `${errPrefix} returned ${pc.cyan('{ pageContext: { pageId } }')} but ${pc.cyan('pageId')} should be`;
         assertUsage(hasProp(hookReturn.pageContext, 'pageId', 'string'), `${errPrefix2} a string or null`);
-        assertUsage(pageContext._allPageIds.includes(hookReturn.pageContext.pageId), `${errPrefix2} ${joinEnglish(pageContext._allPageIds.map((s) => pc.cyan(s)), 'or')}`);
+        assertUsage(pageContext._globalContext._allPageIds.includes(hookReturn.pageContext.pageId), `${errPrefix2} ${joinEnglish(pageContext._globalContext._allPageIds.map((s) => pc.cyan(s)), 'or')}`);
     }
     if (hasProp(hookReturn.pageContext, 'routeParams')) {
         assertRouteParams(hookReturn.pageContext, `${errPrefix} returned ${pc.cyan('{ pageContext: { routeParams } }')} but routeParams should`);

package/dist/esm/shared/route/index.d.ts

@@ -3,18 +3,11 @@ export type { PageContextForRoute };
 export type { PageContextFromRoute };
 export type { PageRoutes };
 export type { RouteMatches };
-import type { PageFile } from '../getPageFiles.js';
 import { type PageContextUrlInternal, type PageContextUrlSource } from '../getPageContextUrlComputed.js';
 import type { PageRoutes, RouteType } from './loadPageRoutes.js';
-import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
-import type { Hook } from '../hooks/getHook.js';
+import type { GlobalContextInternal } from '../createGlobalContextShared.js';
 type PageContextForRoute = PageContextUrlInternal & {
-    _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfigRuntime[];
-    _allPageIds: string[];
-    _pageConfigGlobal: PageConfigGlobalRuntime;
-    _pageRoutes: PageRoutes;
-    _onBeforeRouteHook: Hook | null;
+    _globalContext: GlobalContextInternal;
 } & PageContextUrlSource;
 type PageContextFromRoute = {
     pageId: string | null;