vike 0.4.238 → 0.4.239-commit-050a4a3

package/dist/esm/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js

@@ -1,5 +1,5 @@
 export { generateVirtualFileGlobalEntryWithOldDesign };
-import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionOrAbove, assertWarning, } from '../../utils.js';
+import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionMatch, assertWarning, } from '../../utils.js';
 import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
 import { version as viteVersion } from 'vite';
 import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
@@ -139,7 +139,7 @@ function getGlobs(globRoots, isBuild, fileType, query, isV1Design) {
             const globExcludePath = globRoot.excludeDir ? `'!${getGlobPath(globRoot.excludeDir, fileType)}'` : null;
             const globOptions = { eager: isEager };
             if (query) {
-                const isNewViteInterface = isVersionOrAbove(viteVersion, '5.1.0');
+                const isNewViteInterface = isVersionMatch(viteVersion, ['5.1.0']);
                 if (isNewViteInterface &&
                     // When used for the old design, the new syntax breaks Vike's CI (surprinsigly so). I couldn't reproduce locally (I didn't dig much).
                     isV1Design) {

package/dist/esm/node/vite/plugins/pluginVirtualFiles.js

@@ -8,7 +8,7 @@ import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
-import { updateUserFiles } from '../../runtime/globalContext.js';
+import { isRunnable, updateUserFiles } from '../../runtime/globalContext.js';
 import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { getVikeConfigError } from '../../shared/getVikeConfigError.js';
@@ -16,47 +16,57 @@ function pluginVirtualFiles() {
     let config;
     return {
         name: 'vike:pluginVirtualFiles',
-        async configResolved(config_) {
-            config = config_;
-            // TO-DO/next-major-release: remove
-            if (!isV1Design())
-                config.experimental.importGlobRestoreExtension = true;
+        configResolved: {
+            async handler(config_) {
+                config = config_;
+                // TO-DO/next-major-release: remove
+                if (!isV1Design())
+                    config.experimental.importGlobRestoreExtension = true;
+            },
         },
-        resolveId(id) {
-            if (isVirtualFileId(id)) {
-                return addVirtualFileIdPrefix(id);
-            }
-        },
-        async handleHotUpdate(ctx) {
-            try {
-                return await handleHotUpdate(ctx, config);
-            }
-            catch (err) {
-                // Vite swallows errors thrown by handleHotUpdate()
-                console.error(err);
-                throw err;
-            }
+        resolveId: {
+            handler(id) {
+                if (isVirtualFileId(id)) {
+                    return addVirtualFileIdPrefix(id);
+                }
+            },
         },
-        async load(id, options) {
-            if (!isVirtualFileId(id))
-                return undefined;
-            id = removeVirtualFileIdPrefix(id);
-            const isDev = config._isDev;
-            assert(typeof isDev === 'boolean');
-            const idParsed = parseVirtualFileId(id);
-            if (idParsed) {
-                if (idParsed.type === 'page-entry') {
-                    const code = await generateVirtualFilePageEntry(id, isDev);
-                    return code;
+        handleHotUpdate: {
+            async handler(ctx) {
+                try {
+                    return await handleHotUpdate(ctx, config);
                 }
-                if (idParsed.type === 'global-entry') {
-                    const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
-                    return code;
+                catch (err) {
+                    // Vite swallows errors thrown by handleHotUpdate()
+                    console.error(err);
+                    throw err;
                 }
-            }
+            },
+        },
+        load: {
+            async handler(id, options) {
+                if (!isVirtualFileId(id))
+                    return undefined;
+                id = removeVirtualFileIdPrefix(id);
+                const isDev = config._isDev;
+                assert(typeof isDev === 'boolean');
+                const idParsed = parseVirtualFileId(id);
+                if (idParsed) {
+                    if (idParsed.type === 'page-entry') {
+                        const code = await generateVirtualFilePageEntry(id, isDev);
+                        return code;
+                    }
+                    if (idParsed.type === 'global-entry') {
+                        const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
+                        return code;
+                    }
+                }
+            },
         },
-        configureServer(server) {
-            handleFileAddRemove(server, config);
+        configureServer: {
+            handler(server) {
+                handleFileAddRemove(server, config);
+            },
         },
     };
 }
@@ -125,7 +135,10 @@ async function handleHotUpdate(ctx, config) {
             // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
             // Vite already invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
             ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
-            updateUserFiles();
+            if (isRunnable(server)) {
+                // TODO/now: await
+                updateUserFiles();
+            }
         }
     }
 }

package/dist/esm/node/vite/plugins/pluginWorkaroundCssModuleHmr.js

@@ -2,12 +2,14 @@ export { pluginWorkaroundCssModuleHmr };
 function pluginWorkaroundCssModuleHmr() {
     return {
         name: 'vike:pluginWorkaroundCssModuleHmr',
-        handleHotUpdate(ctx) {
-            // prevent full reload due to non self-accepting css module.
-            // here only "?direct" module should be filtered out as it doesn't have a parent module.
-            if (ctx.file.includes('module.css')) {
-                return ctx.modules.filter((m) => !m.id?.includes('?direct'));
-            }
+        handleHotUpdate: {
+            handler(ctx) {
+                // prevent full reload due to non self-accepting css module.
+                // here only "?direct" module should be filtered out as it doesn't have a parent module.
+                if (ctx.file.includes('module.css')) {
+                    return ctx.modules.filter((m) => !m.id?.includes('?direct'));
+                }
+            },
         },
     };
 }

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -171,6 +171,9 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true,
     },
+    csp: {
+        env: { server: true },
+    },
     injectScriptsAt: {
         env: { server: true },
     },

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/crawlPlusFiles.js

@@ -1,7 +1,7 @@
 export { crawlPlusFiles };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
-import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, getGlobalObject, } from '../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsNotProductionRuntime, isVersionMatch, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, getGlobalObject, } from '../../utils.js';
 import path from 'node:path';
 import { glob } from 'tinyglobby';
 import { exec } from 'node:child_process';
@@ -147,7 +147,7 @@ async function isGitNotUsable(userRootDir) {
         //    - We didn't bother test which is the earliest version that works.
         //  - Git 2.32.0 doesn't seem to work: https://github.com/vikejs/vike/discussions/1549
         //    - Maybe it's because of StackBlitz: looking at the release notes, Git 2.32.0 should be working.
-        if (!isVersionOrAbove(gitVersion, '2.43.1'))
+        if (!isVersionMatch(gitVersion, ['2.43.1']))
             return true;
     }
     // Is userRootDir inside a Git repository?

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -1,3 +1,5 @@
+export { getVikeConfig };
+export type { VikeConfig };
 export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { getVikeConfigInternalSync };
@@ -9,11 +11,9 @@ export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 export type { VikeConfigInternal };
 export type { PageConfigBuildTimeBeforeComputed };
-export { getVikeConfig };
-export type { VikeConfig };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../types/PageConfig.js';
 import { type ConfigDefinitionsInternal, type ConfigDefinitionInternal } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
-import { type VikeConfigPublicGlobal, type VikeConfigPublicPageEagerLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { type GlobalConfigPublic } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { type PlusFile } from './resolveVikeConfigInternal/getPlusFilesAll.js';
 import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
 import type { ResolvedConfig, UserConfig } from 'vite';
@@ -28,13 +28,9 @@ type PrerenderContext = {
 } & ({
     [K in keyof PrerenderContextPublic]: null;
 } | PrerenderContextPublic);
-type VikeConfigInternal = {
+type VikeConfigInternal = GlobalConfigPublic & {
     _pageConfigs: PageConfigBuildTime[];
     _pageConfigGlobal: PageConfigGlobalBuildTime;
-    config: VikeConfigPublicGlobal['config'];
-    _from: VikeConfigPublicGlobal['_from'];
-    pages: Record<string, // pageId
-    VikeConfigPublicPageEagerLoaded>;
     _vikeConfigDependencies: Set<string>;
     prerenderContext: PrerenderContext;
 };

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.js

@@ -1,3 +1,5 @@
+// Public usage
+export { getVikeConfig };
 // Internal usage
 export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
@@ -8,8 +10,6 @@ export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
-// Public usage
-export { getVikeConfig };
 import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, genPromise, checkType, objectAssign, getGlobalObject, } from '../utils.js';
 import { configDefinitionsBuiltIn, } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect, } from './resolveVikeConfigInternal/filesystemRouting.js';
@@ -22,7 +22,7 @@ import { loadPointerImport, loadValueFile } from './resolveVikeConfigInternal/lo
 import { resolvePointerImport } from './resolveVikeConfigInternal/resolvePointerImport.js';
 import { getFilePathResolved } from './getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
-import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEagerLoaded, } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { resolveGlobalConfigPublic, } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { getConfigValuesBase, isJsonValue } from '../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { getPlusFilesAll, } from './resolveVikeConfigInternal/getPlusFilesAll.js';
 import { getEnvVarObject } from './getEnvVarObject.js';
@@ -170,31 +170,26 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
-    // global
-    const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
-    const vikeConfigPublicGlobal = resolveVikeConfigPublicGlobal({ pageConfigGlobalValues });
-    // pages
-    const vikeConfigPublicPagesEager = objectFromEntries(pageConfigs.map((pageConfig) => {
-        const pageConfigValues = getConfigValues(pageConfig, true);
-        return resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobalValues, pageConfig, pageConfigValues);
-    }));
+    const globalConfigPublic = resolveGlobalConfig(pageConfigGlobal, pageConfigs);
     const prerenderContext = resolvePrerenderContext({
-        config: vikeConfigPublicGlobal.config,
-        _from: vikeConfigPublicGlobal._from,
+        config: globalConfigPublic.config,
+        _from: globalConfigPublic._from,
         _pageConfigs: pageConfigs,
     });
     const vikeConfig = {
+        ...globalConfigPublic,
+        prerenderContext,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
-        config: vikeConfigPublicGlobal.config,
-        _from: vikeConfigPublicGlobal._from,
-        pages: vikeConfigPublicPagesEager,
-        prerenderContext,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };
     globalObject.vikeConfigSync = vikeConfig;
     return vikeConfig;
 }
+function resolveGlobalConfig(pageConfigGlobal, pageConfigs) {
+    const globalConfigPublic = resolveGlobalConfigPublic(pageConfigs, pageConfigGlobal, getConfigValues);
+    return globalConfigPublic;
+}
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const plusFilesAllOrdered = Object.values(plusFilesAll)
         .flat()
@@ -358,7 +353,8 @@ function assertOnBeforeRenderEnv(pageConfig) {
     // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
     assertUsage(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
 }
-function getConfigValues(pageConfig, tolerateMissingValue) {
+function getConfigValues(pageConfig, isGlobalConfig) {
+    const tolerateMissingValue = !isGlobalConfig;
     const configValues = {};
     getConfigValuesBase(pageConfig, { isForConfig: true }, null).forEach((entry) => {
         if (entry.configValueBase.type === 'computed') {
@@ -1125,11 +1121,15 @@ function restartViteDevServer() {
     removeSuperfluousViteLog_disable();
 }
 function getVikeConfigDummy(esbuildCache) {
-    const globalDummy = resolveVikeConfigPublicGlobal({ pageConfigGlobalValues: {} });
     const pageConfigsDummy = [];
+    const pageConfigGlobalDummy = {
+        configValueSources: {},
+        configDefinitions: {},
+    };
+    const globalConfigPublicDummy = resolveGlobalConfig(pageConfigGlobalDummy, pageConfigsDummy);
     const prerenderContextDummy = resolvePrerenderContext({
-        config: globalDummy.config,
-        _from: globalDummy._from,
+        config: globalConfigPublicDummy.config,
+        _from: globalConfigPublicDummy._from,
         _pageConfigs: pageConfigsDummy,
     });
     const vikeConfigDummy = {
@@ -1138,9 +1138,7 @@ function getVikeConfigDummy(esbuildCache) {
             configDefinitions: {},
             configValueSources: {},
         },
-        config: globalDummy.config,
-        _from: globalDummy._from,
-        pages: {},
+        ...globalConfigPublicDummy,
         prerenderContext: prerenderContextDummy,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };

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[];