vike 0.4.231 → 0.4.232-commit-ec54a7e

package/dist/esm/shared/getProxyForPublicUsage.js

@@ -4,13 +4,13 @@ export { getProxyForPublicUsage };
 //   ```console
 //   TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute, #<Object>
 //   ```
-// - Previous implementation using property getters: https://github.com/vikejs/vike/blob/main/vike/utils/makePublicCopy.ts
+// - Previous implementation using property getters: https://github.com/vikejs/vike/blob/4dbb354b0bcec04e862041fc9183fc4691bb8711/vike/utils/makePublicCopy.ts
 // Show warning when user is accessing internal `_` properties.
 import { NOT_SERIALIZABLE } from './NOT_SERIALIZABLE.js';
 import { assert, assertUsage, assertWarning, getPropAccessNotation, isBrowser } from './utils.js';
 function getProxyForPublicUsage(obj, objName, skipOnInternalProp, fallback) {
     return new Proxy(obj, {
-        get: getTrapGet(obj, objName, skipOnInternalProp, fallback)
+        get: getTrapGet(obj, objName, skipOnInternalProp, fallback),
     });
 }
 function getTrapGet(obj, objName, skipOnInternalProp, fallback) {
@@ -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,17 @@ 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 PageContextPrepareMinimum2 = PageContextPrepareMinimum & VikeConfigPublicPageLazy;
+type PageContextExecuteHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;
@@ -28,8 +29,8 @@ declare function execHookSingle<PageContext extends PageContextExecuteHook>(hook
 declare function execHookSingleWithReturn<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
     hookReturn: unknown;
 }>;
-declare function execHook<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
-declare function execHookErrorHandling<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+declare function execHook<PageContext extends PageContextPrepareMinimum2>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookErrorHandling<PageContext extends PageContextPrepareMinimum2>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
     hooks: HookWithResult[];
     err?: undefined;
 } | {

package/dist/esm/shared/hooks/execHook.js

@@ -14,10 +14,10 @@ import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { humanizeTime } from '../../utils/humanizeTime.js';
 import { isObject } from '../../utils/isObject.js';
 import { getHookFromPageConfigGlobalCumulative, getHookFromPageContextNew } from './getHook.js';
-import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
+import { preparePageContextForPublicUsage, } from '../preparePageContextForPublicUsage.js';
 const globalObject = getGlobalObject('utils/execHook.ts', {
     userHookErrors: new WeakMap(),
-    pageContext: null
+    pageContext: null,
 });
 async function execHookSingle(hook, pageContext, preparePageContextForPublicUsage) {
     const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
@@ -83,7 +83,7 @@ async function execHookWithoutPageContext(hookFnCaller, hook) {
     return hookReturn;
 }
 function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
-    const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
+    const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn }, } = hook;
     let resolve;
     let reject;
     const promise = new Promise((resolve_, reject_) => {

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/hooks/getHook.js

@@ -117,7 +117,7 @@ function getHookTimeout(hooksTimeoutProvidedByUser, hookName) {
         hookTimeout.warning = providedbyUser.warning;
     return hookTimeout;
 }
-// Ideally this should be called only once and at build-time (to avoid bloating the client-side bundle), but we didn't implement any mechanism to valide config values at build-time yet
+// Ideally this should be called only once and at build-time (to avoid bloating the client-side bundle), but we didn't implement any mechanism to valid config values at build-time yet
 function getHooksTimeoutProvidedByUserNormalized(hooksTimeoutProvidedByUser) {
     if (hooksTimeoutProvidedByUser === undefined)
         return {};
@@ -148,13 +148,13 @@ function getHookTimeoutDefault(hookName) {
     if (hookName === 'onBeforeRoute') {
         return {
             error: 5 * 1000,
-            warning: 1 * 1000
+            warning: 1 * 1000,
         };
     }
     if (globalObject.isPrerendering) {
         return {
             error: 2 * 60 * 1000,
-            warning: 30 * 1000
+            warning: 30 * 1000,
         };
     }
     else {
@@ -162,7 +162,7 @@ function getHookTimeoutDefault(hookName) {
     }
     return {
         error: 30 * 1000,
-        warning: 4 * 1000
+        warning: 4 * 1000,
     };
 }
 function getHook_setIsPrerenderering() {

package/dist/esm/shared/modifyUrl.js

@@ -14,7 +14,7 @@ function modifyUrl(url, modify) {
     // Origin
     const originParts = [
         modify.protocol ?? urlParsed.protocol ?? '',
-        modify.hostname ?? urlParsed.hostname ?? ''
+        modify.hostname ?? urlParsed.hostname ?? '',
     ];
     const port = modify.port ?? urlParsed.port;
     if (port || port === 0) {

package/dist/esm/shared/modifyUrlSameOrigin.js

@@ -1,5 +1,5 @@
 export { modifyUrlSameOrigin };
-import { createUrlFromComponents, isNotNullish_keyVal, parseUrl, objectFilter, assertUsageUrlPathnameAbsolute } from './utils.js';
+import { createUrlFromComponents, isNotNullish_keyVal, parseUrl, objectFilter, assertUsageUrlPathnameAbsolute, } from './utils.js';
 function modifyUrlSameOrigin(url, modify) {
     const urlParsed = parseUrl(url, '/');
     // Pathname

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

@@ -5,7 +5,7 @@ const SIDE_EXPORTS_TOLERATE = [
     // vite-plugin-solid adds `export { $$registrations }`
     '$$registrations',
     // @vitejs/plugin-vue adds `export { _rerender_only }`
-    '_rerender_only'
+    '_rerender_only',
 ];
 // Tolerate `export { frontmatter }` in .mdx files
 const SIDE_EXPORTS_DO_NOT_CHECK = ['.md', '.mdx'];
@@ -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}`);
@@ -30,7 +30,7 @@ function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
     if (!SIDE_EXPORTS_DO_NOT_CHECK.some((ext) => filePathToShowToUser.endsWith(ext))) {
         exportNamesInvalid.forEach((exportInvalid) => {
             assertWarning(false, `${filePathToShowToUser} unexpected ${pc.cyan(`export { ${exportInvalid} }`)}, see https://vike.dev/no-side-exports`, {
-                onlyOnce: true
+                onlyOnce: true,
             });
         });
     }

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/getConfigValueBuildTime.js

@@ -16,7 +16,7 @@ function getConfigValue(pageConfig, configName) {
         return {
             type: 'computed',
             value: configValueComputed.value,
-            definedAtData: null
+            definedAtData: null,
         };
     }
     const sources = configValueSources[configName];
@@ -31,7 +31,7 @@ function getConfigValue(pageConfig, configName) {
         return {
             type: 'standard',
             value: configValueSource.value,
-            definedAtData: getDefinedAt(configValueSource)
+            definedAtData: getDefinedAt(configValueSource),
         };
     }
     else {
@@ -40,7 +40,7 @@ function getConfigValue(pageConfig, configName) {
         return {
             type: 'cumulative',
             value,
-            definedAtData
+            definedAtData,
         };
     }
 }
@@ -61,6 +61,6 @@ function getDefinedAt(configValueSource) {
         return definedAt;
     return {
         filePathToShowToUser: definedAt.filePathToShowToUser,
-        fileExportPathToShowToUser: definedAt.fileExportPathToShowToUser
+        fileExportPathToShowToUser: definedAt.fileExportPathToShowToUser,
     };
 }

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;
@@ -26,7 +26,7 @@ type ExportsAll = Record<string, {
     /** @deprecated */
     _filePath: string | null;
 }[]>;
-/** All the config's values (including overriden ones) and where they come from.
+/** All the config's values (including overridden ones) and where they come from.
  *
  * https://vike.dev/pageContext
  */
@@ -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 { 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,
-            route
+            ...vikeConfigPublicPage,
+            route,
         };
     }
     else {
         page = {
-            ...pageConfigUserFriendly,
-            isErrorPage: true
+            ...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 = {};
@@ -64,7 +62,7 @@ pageConfigGlobal) {
                 filePath: pageFile.filePath,
                 _filePath: pageFile.filePath, // TODO/next-major-release: remove
                 _fileType: pageFile.fileType,
-                _isFromDefaultExport: isFromDefaultExport
+                _isFromDefaultExport: isFromDefaultExport,
             });
         });
     });
@@ -72,9 +70,9 @@ pageConfigGlobal) {
     let sources;
     let from;
     if (pageConfig) {
-        const res = getUserFriendlyConfigs_base({
+        const res = resolveVikeConfigPublic_base({
             pageConfigGlobalValues: pageConfigGlobal.configValues,
-            pageConfigValues: pageConfig.configValues
+            pageConfigValues: pageConfig.configValues,
         });
         source = res.source;
         sources = res.sources;
@@ -89,7 +87,7 @@ pageConfigGlobal) {
         from = {
             configsStandard: {},
             configsCumulative: {},
-            configsComputed: {}
+            configsComputed: {},
         };
     }
     const pageExports = {};
@@ -112,10 +110,10 @@ pageConfigGlobal) {
         from,
         source,
         sources,
-        // TODO/eventually: deprecate/remove every prop below
+        // TODO/now-flat-pageContext: deprecate every prop below
         configEntries,
         exports,
-        exportsAll
+        exportsAll,
     };
     // TODO/v1-release: remove
     objectDefineProperty(pageContextExports, 'pageExports', {
@@ -124,18 +122,18 @@ pageConfigGlobal) {
             if (!isBrowser()) {
                 assertWarning(false, 'pageContext.pageExports is outdated, use pageContext.exports instead', {
                     onlyOnce: true,
-                    showStackTrace: true
+                    showStackTrace: true,
                 });
             }
             return pageExports;
         },
         enumerable: false,
-        configurable: true
+        configurable: true,
     });
     return pageContextExports;
 }
 // V1 design
-function getUserFriendlyConfigs_V1Design(pageConfig) {
+function resolveVikeConfigPublic_V1Design(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};
@@ -144,7 +142,7 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
     const from = {
         configsStandard: {},
         configsCumulative: {},
-        configsComputed: {}
+        configsComputed: {},
     };
     const addSrc = (src, configName) => {
         source[configName] = src;
@@ -158,7 +156,7 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
         configEntries[configName].push({
             configValue: value,
             configDefinedAt,
-            configDefinedByFile: configValueFilePathToShowToUser
+            configDefinedByFile: configValueFilePathToShowToUser,
         });
         // TODO/v1-release: remove
         const exportName = configName;
@@ -169,7 +167,7 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
             filePath: configValueFilePathToShowToUser,
             _filePath: configValueFilePathToShowToUser,
             _fileType: null,
-            _isFromDefaultExport: null
+            _isFromDefaultExport: null,
         });
     };
     Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
@@ -179,7 +177,7 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
             const src = {
                 type: 'configsStandard',
                 value: configValue.value,
-                definedAt: getDefinedAtString(configValue.definedAtData, configName)
+                definedAt: getDefinedAtString(configValue.definedAtData, configName),
             };
             addSrc(src, configName);
             from.configsStandard[configName] = src;
@@ -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);
@@ -195,9 +194,9 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
                     addLegacy(configName, value, definedAtFile);
                     return {
                         value,
-                        definedAt
+                        definedAt,
                     };
-                })
+                }),
             };
             addSrc(src, configName);
             from.configsCumulative[configName] = src;
@@ -205,7 +204,8 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
         if (configValue.type === 'computed') {
             const src = {
                 type: 'configsComputed',
-                value: configValue.value
+                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);
             from.configsComputed[configName] = src;
@@ -218,7 +218,7 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
         exportsAll,
         source,
         sources,
-        from
+        from,
     };
 }
 function getExportValues(pageFile) {
@@ -241,7 +241,7 @@ function getExportValues(pageFile) {
                     exportValues.push({
                         exportName: defaultExportName,
                         exportValue: defaultExportValue,
-                        isFromDefaultExport
+                        isFromDefaultExport,
                     });
                 });
                 return;
@@ -250,7 +250,7 @@ function getExportValues(pageFile) {
         exportValues.push({
             exportName,
             exportValue,
-            isFromDefaultExport
+            isFromDefaultExport,
         });
     });
     exportValues.forEach(({ exportName, isFromDefaultExport }) => {