vike 0.4.238 → 0.4.239

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

@@ -14,6 +14,44 @@ declare function createGlobalContextShared<GlobalContextAdded extends Record<str
     onCreateGlobalContextHooks?: Hook[];
     previousCreateGlobalContextPromise?: Promise<void>;
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                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;
+            } & ({
+                route: import("../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        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;
+    };
+    pages: {
+        [k: string]: {
+            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;
+        } & ({
+            route: import("../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    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;
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -26,20 +64,48 @@ declare function createGlobalContextShared<GlobalContextAdded extends Record<str
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _vikeConfigPublicGlobal: {
+} & GlobalContextAdded & GlobalContextAddedAsync>;
+type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
+type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
+declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                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;
+            } & ({
+                route: import("../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
         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/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
+        [k: string]: {
+            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;
+        } & ({
+            route: import("../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
     };
-} & GlobalContextAdded & GlobalContextAddedAsync>;
-type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
-type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
-declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {
+    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;
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -52,14 +118,4 @@ declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown)
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _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/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
-    };
 };

package/dist/esm/shared/createGlobalContextShared.js

@@ -2,7 +2,7 @@ export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
 import { assert, changeEnumerable, genPromise, objectAssign, objectReplace, unique } from './utils.js';
 import { parseVirtualFileExportsGlobalEntry } from './getPageFiles/parseVirtualFileExportsGlobalEntry.js';
-import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEagerLoaded, } from './page-configs/resolveVikeConfigPublic.js';
+import { resolveGlobalContextConfig } from './page-configs/resolveVikeConfigPublic.js';
 import { execHookGlobal } from './hooks/execHook.js';
 import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
 import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
@@ -70,7 +70,9 @@ addGlobalContextTmp, addGlobalContextAsync) {
     return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExportsGlobalEntry) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, vikeConfigPublicGlobal, vikeConfigPublicPagesEager, } = getConfigsAll(virtualFileExportsGlobalEntry);
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    const globalContextAddendum = resolveGlobalContextConfig(pageConfigs, pageConfigGlobal);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -84,31 +86,11 @@ function createGlobalContextBase(virtualFileExportsGlobalEntry) {
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
-        _vikeConfigPublicGlobal: vikeConfigPublicGlobal,
-        config: vikeConfigPublicGlobal.config,
-        pages: vikeConfigPublicPagesEager,
+        ...globalContextAddendum,
     };
     changeEnumerable(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
-function getConfigsAll(virtualFileExportsGlobalEntry) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
-    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
-    const vikeConfigPublicGlobal = resolveVikeConfigPublicGlobal({
-        pageConfigGlobalValues: pageConfigGlobal.configValues,
-    });
-    const vikeConfigPublicPagesEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        return resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
-    }));
-    return {
-        pageFilesAll,
-        allPageIds,
-        pageConfigs,
-        pageConfigGlobal,
-        vikeConfigPublicGlobal,
-        vikeConfigPublicPagesEager,
-    };
-}
 function getAllPageIds(pageFilesAll, pageConfigs) {
     const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
     const allPageIds = unique(fileIds);

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

@@ -1,13 +1,8 @@
 export { createPageContextShared };
 export { createPageContextObject };
-import type { VikeConfigPublicGlobal } from './page-configs/resolveVikeConfigPublic.js';
+import type { GlobalConfigPublic } from './page-configs/resolveVikeConfigPublic.js';
 import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
-declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, vikeConfigPublicGlobal: VikeConfigPublicGlobal): 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 createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, globalConfigPublic: GlobalConfigPublic): T & GlobalConfigPublic;
 declare function createPageContextObject(): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/esm/shared/createPageContextShared.js

@@ -1,8 +1,8 @@
 export { createPageContextShared };
 export { createPageContextObject };
 import { changeEnumerable, objectAssign } from './utils.js';
-function createPageContextShared(pageContextCreated, vikeConfigPublicGlobal) {
-    objectAssign(pageContextCreated, vikeConfigPublicGlobal);
+function createPageContextShared(pageContextCreated, globalConfigPublic) {
+    objectAssign(pageContextCreated, globalConfigPublic);
     return pageContextCreated;
 }
 function createPageContextObject() {

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

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

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

@@ -11,14 +11,14 @@ export { isUserHookError };
 export type { PageContextExecHook };
 import type { PageContextClient, PageContextServer } from '../../types/PageContext.js';
 import type { Hook, HookLoc } from './getHook.js';
-import type { VikeConfigPublicPageLazyLoaded } from '../getPageFiles.js';
+import type { PageContextConfig } 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 PageContextExecHook = VikeConfigPublicPageLazyLoaded & PageContextForPublicUsage;
+type PageContextExecHook = PageContextConfig & PageContextForPublicUsage;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;

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

@@ -9,7 +9,7 @@ export type { HookLoc };
 export type { HookTimeout };
 export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
-import type { VikeConfigPublicPageLazyLoaded } from '../getPageFiles.js';
+import type { PageContextConfig } 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';
@@ -28,8 +28,8 @@ type HookTimeout = {
     warning: number | false;
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookNameOld, false | Partial<HookTimeout>>>;
-declare function getHookFromPageContext(pageContext: VikeConfigPublicPageLazyLoaded, hookName: HookNameOld): null | Hook;
-declare function getHookFromPageContextNew(hookName: HookName, pageContext: VikeConfigPublicPageLazyLoaded): Hook[];
+declare function getHookFromPageContext(pageContext: PageContextConfig, hookName: HookNameOld): null | Hook;
+declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageContextConfig): 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/resolveVikeConfigPublic.d.ts

@@ -1,9 +1,8 @@
-export { resolveVikeConfigPublicGlobal };
-export { resolveVikeConfigPublicPageEagerLoaded };
-export { resolveVikeConfigPublicPageLazyLoaded };
-export type { VikeConfigPublicGlobal };
-export type { VikeConfigPublicPageEagerLoaded };
-export type { VikeConfigPublicPageLazyLoaded };
+export { resolveGlobalConfigPublic };
+export { resolvePageContextConfig };
+export { resolveGlobalContextConfig };
+export type { PageContextConfig };
+export type { GlobalConfigPublic };
 export type { Source };
 export type { Sources };
 export type { From };
@@ -11,9 +10,9 @@ 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 '../../types/PageConfig.js';
+import type { ConfigValues, PageConfigBuildTime, PageConfigGlobalBuildTime, PageConfigGlobalRuntime, PageConfigRuntime, PageConfigRuntimeLoaded } from '../../types/PageConfig.js';
 import { type ConfigDefinedAtOptional } from './getConfigDefinedAt.js';
-import type { ConfigResolved } from '../../types/Config/PageContextConfig.js';
+import type { ConfigResolved } from '../../types/Config/ConfigResolved.js';
 import type { Route } from '../../types/Config.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
@@ -35,17 +34,6 @@ type ConfigEntries = Record<string, {
     configDefinedAt: ConfigDefinedAtOptional;
     configDefinedByFile: string | null;
 }[]>;
-type VikeConfigPublicPageLazyLoaded = {
-    config: ConfigResolved;
-    source: Source;
-    sources: Sources;
-    from: From;
-    configEntries: ConfigEntries;
-    exports: Record<string, unknown>;
-    exportsAll: ExportsAll;
-    /** @deprecated */
-    pageExports: Record<string, unknown>;
-};
 type From = {
     configsStandard: Record<string, // configName
     SourceConfigsStandard>;
@@ -77,11 +65,34 @@ type SourceConfigsComputed = {
     definedAt: 'Vike';
     value: unknown;
 };
-type VikeConfigPublic = {
+type PageContextConfig = {
+    /** The page's configuration values.
+     *
+     * https://vike.dev/config
+     * https://vike.dev/pageContext#config
+     */
     config: ConfigResolved;
-    _source: Source;
-    _sources: Sources;
-    _from: From;
+    source: Source;
+    sources: Sources;
+    from: From;
+    /** The page's configuration, including the configs origin and overridden configs.
+     *
+     * https://vike.dev/config
+     */
+    configEntries: ConfigEntries;
+    /** Custom Exports/Hooks.
+     *
+     * https://vike.dev/exports
+     */
+    exports: Record<string, unknown>;
+    /**
+     * Same as `pageContext.exports` but cumulative.
+     *
+     * https://vike.dev/exports
+     */
+    exportsAll: ExportsAll;
+    /** @deprecated */
+    pageExports: Record<string, unknown>;
 };
 type WithRoute = {
     route: Route;
@@ -90,12 +101,61 @@ type WithRoute = {
     route?: undefined;
     isErrorPage: true;
 };
-type VikeConfigPublicPageEagerLoaded = VikeConfigPublic & WithRoute;
-type VikeConfigPublicGlobal = VikeConfigPublic;
-declare function resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, VikeConfigPublicPageEagerLoaded];
-declare function resolveVikeConfigPublicGlobal({ pageConfigGlobalValues, }: {
-    pageConfigGlobalValues: ConfigValues;
-}): VikeConfigPublicGlobal;
-declare function resolveVikeConfigPublicPageLazyLoaded(pageFiles: PageFile[], // V0.4 design
+type PageConfigPublicWithRoute = ConfigPublic & WithRoute;
+type ConfigPublic = ReturnType<typeof getPublicCopy>;
+declare function getPublicCopy(configInternal: ReturnType<typeof resolveConfigPublic_V1Design>): {
+    config: ConfigResolved;
+    _source: Source;
+    _sources: Sources;
+    _from: From;
+};
+declare function resolvePageContextConfig(pageFiles: PageFile[], // V0.4 design
 pageConfig: PageConfigRuntimeLoaded | null, // V1 design
-pageConfigGlobal: PageConfigGlobalRuntime): VikeConfigPublicPageLazyLoaded;
+pageConfigGlobal: PageConfigGlobalRuntime): PageContextConfig;
+declare function resolveGlobalContextConfig(pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): {
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: PageConfigPublicWithRoute;
+        };
+        config: ConfigResolved;
+        _source: Source;
+        _sources: Sources;
+        _from: From;
+    };
+    pages: {
+        [k: string]: PageConfigPublicWithRoute;
+    };
+    config: ConfigResolved;
+    _source: Source;
+    _sources: Sources;
+    _from: From;
+};
+type GlobalConfigPublic = Omit<ReturnType<typeof resolveGlobalConfigPublic>, '_globalConfigPublic'>;
+declare function resolveGlobalConfigPublic<PageConfig extends PageConfigRuntime | PageConfigBuildTime, PageConfigGlobal extends PageConfigGlobalRuntime | PageConfigGlobalBuildTime>(pageConfigs: PageConfig[], pageConfigGlobal: PageConfigGlobal, getConfigValues: (config: PageConfig | PageConfigGlobal, isGlobalConfig?: true) => ConfigValues): {
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: PageConfigPublicWithRoute;
+        };
+        config: ConfigResolved;
+        _source: Source;
+        _sources: Sources;
+        _from: From;
+    };
+    pages: {
+        [k: string]: PageConfigPublicWithRoute;
+    };
+    config: ConfigResolved;
+    _source: Source;
+    _sources: Sources;
+    _from: From;
+};
+declare function resolveConfigPublic_V1Design(pageConfig: {
+    configValues: ConfigValues;
+}): {
+    config: ConfigResolved;
+    configEntries: ConfigEntries;
+    exportsAll: ExportsAll;
+    source: Source;
+    sources: Sources;
+    from: From;
+};

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

@@ -1,54 +1,48 @@
-// TO-DO/soon: rename PageConfig names
-// - Use `Internal` suffix, i.e. {Page,Global}ConfigInternal
-//   - While keeping {Page,Global}ConfigPublic or remove Public suffix and rename it to {Page,Global}Config ?
-// - rename EagerLoaded EagerlyLoaded
-// - remove `LazyLoaded` suffix
 // TO-DO/soon/same-api: use public API internally?
 // TO-DO/soon/flat-pageContext: rename definedAt => definedBy
-export { resolveVikeConfigPublicGlobal };
-export { resolveVikeConfigPublicPageEagerLoaded };
-export { resolveVikeConfigPublicPageLazyLoaded };
+export { resolveGlobalConfigPublic };
+export { resolvePageContextConfig };
+export { resolveGlobalContextConfig };
 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 resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobalValues, pageConfig, pageConfigValues) {
-    const vikeConfigPublicPage_ = resolveVikeConfigPublic_base({ pageConfigGlobalValues, pageConfigValues });
-    const vikeConfigPublicPage = getPublicCopy(vikeConfigPublicPage_);
-    let page;
-    if (!pageConfig.isErrorPage) {
-        const route = vikeConfigPublicPage.config.route ?? pageConfig.routeFilesystem.routeString;
-        page = {
-            ...vikeConfigPublicPage,
-            route,
-        };
-    }
-    else {
-        page = {
-            ...vikeConfigPublicPage,
-            isErrorPage: true,
-        };
-    }
+function resolveGlobalConfigPublicPage(pageConfigGlobalValues, pageConfig, pageConfigValues) {
+    const pageConfigPublic_ = resolvePageConfigPublic({ pageConfigGlobalValues, pageConfigValues });
+    const pageConfigPublic = getPublicCopy(pageConfigPublic_);
+    const page = (() => {
+        if (!pageConfig.isErrorPage) {
+            const route = pageConfigPublic.config.route ?? pageConfig.routeFilesystem.routeString;
+            return {
+                ...pageConfigPublic,
+                route,
+            };
+        }
+        else {
+            return {
+                ...pageConfigPublic,
+                isErrorPage: true,
+            };
+        }
+    })();
     return [pageConfig.pageId, page];
 }
-function getPublicCopy(vikeConfigPublic) {
-    return {
-        config: vikeConfigPublic.config,
-        _source: vikeConfigPublic.source,
-        _sources: vikeConfigPublic.sources,
-        _from: vikeConfigPublic.from,
+function getPublicCopy(configInternal) {
+    const configPublic = {
+        config: configInternal.config,
+        // TO-DO/soon/flat-pageContext: expose publicly?
+        _source: configInternal.source,
+        _sources: configInternal.sources,
+        _from: configInternal.from,
     };
+    return configPublic;
 }
-function resolveVikeConfigPublic_base({ pageConfigGlobalValues, pageConfigValues, }) {
+function resolvePageConfigPublic({ pageConfigGlobalValues, pageConfigValues, }) {
     const configValues = { ...pageConfigGlobalValues, ...pageConfigValues };
-    return resolveVikeConfigPublic_V1Design({ configValues });
+    return resolveConfigPublic_V1Design({ configValues });
 }
-function resolveVikeConfigPublicGlobal({ pageConfigGlobalValues, }) {
-    const vikeConfigPublicGlobal = resolveVikeConfigPublic_V1Design({ configValues: pageConfigGlobalValues });
-    return getPublicCopy(vikeConfigPublicGlobal);
-}
-function resolveVikeConfigPublicPageLazyLoaded(pageFiles, // V0.4 design
+function resolvePageContextConfig(pageFiles, // V0.4 design
 pageConfig, // V1 design
 pageConfigGlobal) {
     const config = {};
@@ -75,7 +69,7 @@ pageConfigGlobal) {
     let sources;
     let from;
     if (pageConfig) {
-        const res = resolveVikeConfigPublic_base({
+        const res = resolvePageConfigPublic({
             pageConfigGlobalValues: pageConfigGlobal.configValues,
             pageConfigValues: pageConfig.configValues,
         });
@@ -110,7 +104,7 @@ pageConfigGlobal) {
     });
     assert(!('default' in exports));
     assert(!('default' in exportsAll));
-    const configPublicPageLazy = {
+    const pageContextAddendum = {
         config: config,
         from,
         source,
@@ -121,7 +115,7 @@ pageConfigGlobal) {
         exportsAll,
     };
     // TO-DO/next-major-release: remove
-    objectDefineProperty(configPublicPageLazy, 'pageExports', {
+    objectDefineProperty(pageContextAddendum, 'pageExports', {
         get: () => {
             // We only show the warning in Node.js because when using Client Routing Vue integration uses `Object.assign(pageContextReactive, pageContext)` which will wrongully trigger the warning. There is no cross-browser way to catch whether the property accessor was initiated by an `Object.assign()` call.
             if (!isBrowser()) {
@@ -135,10 +129,33 @@ pageConfigGlobal) {
         enumerable: false,
         configurable: true,
     });
-    return configPublicPageLazy;
+    return pageContextAddendum;
+}
+function resolveGlobalContextConfig(pageConfigs, pageConfigGlobal) {
+    const globalContextAddendum = resolveGlobalConfigPublic(pageConfigs, pageConfigGlobal, (c) => c.configValues);
+    return globalContextAddendum;
+}
+function resolveGlobalConfigPublic(pageConfigs, pageConfigGlobal, getConfigValues) {
+    // global
+    const pageConfigGlobalValues = getConfigValues(pageConfigGlobal, true);
+    const globalConfigPublicBase_ = resolveConfigPublic_V1Design({ configValues: pageConfigGlobalValues });
+    const globalConfigPublicBase = getPublicCopy(globalConfigPublicBase_);
+    // pages
+    const pages = Object.fromEntries(pageConfigs.map((pageConfig) => {
+        const pageConfigValues = getConfigValues(pageConfig);
+        return resolveGlobalConfigPublicPage(pageConfigGlobalValues, pageConfig, pageConfigValues);
+    }));
+    const globalConfigPublic = {
+        ...globalConfigPublicBase,
+        pages,
+    };
+    return {
+        ...globalConfigPublic,
+        _globalConfigPublic: globalConfigPublic,
+    };
 }
 // V1 design
-function resolveVikeConfigPublic_V1Design(pageConfig) {
+function resolveConfigPublic_V1Design(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};
@@ -226,6 +243,8 @@ function resolveVikeConfigPublic_V1Design(pageConfig) {
         from,
     };
 }
+// V0.4 design
+// TO-DO/next-major-release: remove
 function getExportValues(pageFile) {
     const { filePath, fileExports } = pageFile;
     assert(fileExports); // assume pageFile.loadFile() was called

package/dist/esm/types/Config/ConfigResolved.d.ts

@@ -0,0 +1,8 @@
+export type { ConfigResolved };
+import type { ConfigBuiltIn, ConfigBuiltInResolved, ImportString } from '../Config.js';
+type ConfigUnresolved = WithoutImportString<ConfigBuiltIn & Vike.Config>;
+type ConfigResolvedOnly = ConfigBuiltInResolved & Vike.ConfigResolved;
+type ConfigResolved = ConfigResolvedOnly & Omit<ConfigUnresolved, keyof ConfigResolvedOnly>;
+type WithoutImportString<T> = {
+    [K in keyof T]: Exclude<T[K], ImportString>;
+};

package/dist/esm/types/Config.d.ts

@@ -37,14 +37,14 @@ export type { RouteAsync };
 export type { RouteSync };
 import type { PrefetchSetting, PrefetchStaticAssets } from '../client/runtime-client-routing/prefetch/PrefetchSetting.js';
 import type { ConfigDefinition } from '../node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
-import type { DocumentHtml } from '../node/runtime/html/renderHtml.js';
+import type { DocumentHtml } from '../node/runtime/renderPage/html/renderHtml.js';
 import type { InjectFilterEntry } from './index.js';
 import type { VikeVitePluginOptions } from '../node/vite/index.js';
-import type { Vike, VikePackages } from './VikeNamespace.js';
+import type { Vike } from './VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../shared/hooks/getHook.js';
 import type { GlobalContext, PageContextClient, PageContextServer } from './PageContext.js';
 import type { InlineConfig } from 'vite';
-import type { PassToClientPublic } from '../node/runtime/html/serializeContext.js';
+import type { PassToClientPublic } from '../node/runtime/renderPage/html/serializeContext.js';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
@@ -52,7 +52,7 @@ type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContex
 type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
 type ConfigNameBuiltIn = Exclude<keyof ConfigBuiltIn, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'serverOnlyHooks' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
-type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte | VikePackages.ConfigVikeAngular);
+type Config = ConfigBuiltIn & Vike.Config;
 /** @deprecated This type is deprecated, see https://vike.dev/data */
 type DataAsync<Data = unknown> = (pageContext: PageContextServer) => Promise<Data>;
 /** @deprecated This type is deprecated, see https://vike.dev/data */
@@ -445,7 +445,7 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/headers#response
      */
-    headersResponse?: HeadersInit;
+    headersResponse?: HeadersInit | ((pageContext: PageContextServer) => HeadersInit | Promise<HeadersInit>);
     /**
      * Make development/preview server available over LAN and public addresses.
      *
@@ -468,6 +468,14 @@ type ConfigBuiltIn = {
      * https://vike.dev/mode
      */
     mode?: string;
+    /**
+     * Content Security Policy (CSP).
+     *
+     * https://vike.dev/csp
+     */
+    csp?: {
+        nonce: boolean | ((pageContext: PageContextServer) => string | Promise<string>);
+    };
     /** Where scripts are injected in the HTML.
      *
      * https://vike.dev/injectScriptsAt
@@ -499,7 +507,7 @@ type ConfigBuiltInResolved = {
     redirects?: Record<string, string>[];
     prerender?: Exclude<Config['prerender'], ImportString | undefined>[];
     middleware?: Function[];
-    headersResponse?: HeadersInit[];
+    headersResponse?: Exclude<Config['headersResponse'], ImportString | undefined>[];
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;