vike 0.4.220 → 0.4.221-commit-ab9e52a

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -2,31 +2,26 @@ export { getVikeConfig };
 export { getVikeConfig2 };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
-export { isVikeConfigFile };
 export { isV1Design };
-export { getConfigValueInterfaceFile };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
-import path from 'path';
-import { configDefinitionsBuiltInAll } from './getVikeConfig/configDefinitionsBuiltIn.js';
+export { getConfVal };
+export { getConfigDefinitionOptional };
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst } from '../../../utils.js';
+import { configDefinitionsBuiltIn } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isTemporaryBuildFile } from './getVikeConfig/transpileAndExecuteFile.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
-import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
-import { getConfigFileExport } from './getConfigFileExport.js';
-import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
-import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
+import { loadPointerImport, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
+import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
+import { assertExtensionsRequire } from './getVikeConfig/assertExtensions.js';
 import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
-const configDefinitionsBuiltIn = getConfigDefinitionsBuiltIn();
-const configDefinitionsBuiltInGlobal = getConfigDefinitionsBuiltInGlobal();
+import { getPlusFilesAll } from './getVikeConfig/getPlusFilesAll.js';
 assertIsNotProductionRuntime();
 let restartVite = false;
 let wasConfigInvalid = null;
@@ -37,7 +32,6 @@ function reloadVikeConfig(config) {
     const vikeVitePluginOptions = config._vikeVitePluginOptions;
     assert(vikeVitePluginOptions);
     vikeConfigDependencies.clear();
-    clearFilesEnvMap();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
     handleReloadSideEffects();
 }
@@ -96,116 +90,6 @@ async function isV1Design(config) {
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir) {
-    const plusFiles = await findPlusFiles(userRootDir, null);
-    const configFiles = [];
-    const valueFiles = [];
-    plusFiles.forEach((f) => {
-        if (getConfigName(f.filePathAbsoluteFilesystem) === 'config') {
-            configFiles.push(f);
-        }
-        else {
-            valueFiles.push(f);
-        }
-    });
-    let interfaceFilesByLocationId = {};
-    await Promise.all([
-        // Config files
-        ...configFiles.map(async (filePath) => {
-            const { filePathAbsoluteUserRootDir } = filePath;
-            assert(filePathAbsoluteUserRootDir);
-            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false);
-            assert(filePath.filePathAbsoluteUserRootDir);
-            const locationId = getLocationId(filePathAbsoluteUserRootDir);
-            const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
-            interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
-            interfaceFilesByLocationId[locationId].push(interfaceFile);
-            extendsConfigs.forEach((extendsConfig) => {
-                /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
-                ```js
-                // /pages/admin/+config.js
-        
-                import vikeVue from 'vike-vue/config'
-                // Should only apply to /pages/admin/**
-                export default { extends: [vikeVue] }
-                ```
-                ```js
-                // /pages/marketing/+config.js
-        
-                import vikeReact from 'vike-react/config'
-                // Should only apply to /pages/marketing/**
-                export default { extends: [vikeReact] }
-                ```
-                */
-                const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
-                assertExtensionsConventions(interfaceFile);
-                interfaceFilesByLocationId[locationId].push(interfaceFile);
-            });
-        }),
-        // Value files
-        ...valueFiles.map(async (filePath) => {
-            const { filePathAbsoluteUserRootDir } = filePath;
-            assert(filePathAbsoluteUserRootDir);
-            const configName = getConfigName(filePathAbsoluteUserRootDir);
-            assert(configName);
-            const locationId = getLocationId(filePathAbsoluteUserRootDir);
-            const interfaceFile = {
-                locationId,
-                filePath,
-                fileExportsByConfigName: {
-                    [configName]: {}
-                },
-                isConfigFile: false,
-                isValueFile: true,
-                configName
-            };
-            {
-                // We don't have access to the custom config definitions defined by the user yet.
-                //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
-                //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
-                const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
-                if (configDef && isLoadableAtBuildTime(configDef)) {
-                    await loadValueFile(interfaceFile, configName, userRootDir);
-                }
-            }
-            {
-                interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
-                interfaceFilesByLocationId[locationId].push(interfaceFile);
-            }
-        })
-    ]);
-    assertAllConfigsAreKnown(interfaceFilesByLocationId);
-    return interfaceFilesByLocationId;
-}
-function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId) {
-    const { fileExports, filePath, extendsFilePaths } = configFile;
-    const interfaceFile = {
-        locationId,
-        filePath,
-        fileExportsByConfigName: {},
-        isConfigFile: true,
-        isValueFile: false,
-        isConfigExtend,
-        extendsFilePaths
-    };
-    const fileExport = getConfigFileExport(fileExports, filePath.filePathToShowToUser);
-    Object.entries(fileExport).forEach(([configName, configValue]) => {
-        interfaceFile.fileExportsByConfigName[configName] = { configValue };
-    });
-    return interfaceFile;
-}
-/** Show error message upon unknown config */
-function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
-    objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
-        interfaceFiles.forEach((interfaceFile) => {
-            Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitions), interfaceFile.filePath.filePathToShowToUser);
-            });
-        });
-    });
-}
 async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     let hasError = false;
     let ret;
@@ -242,7 +126,6 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
                 global: getPageConfigUserFriendlyNew({ configValues: {} })
             };
             return dummyData;
@@ -250,149 +133,156 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
     }
 }
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir);
-    const importedFilesLoaded = {};
-    const [globalConfigs, pageConfigs] = await Promise.all([
-        getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions),
-        getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded)
-    ]);
-    return { pageConfigs, ...globalConfigs };
-}
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
-    const locationIds = objectKeys(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
-        return isGlobalLocation(locationId, locationIds);
+    const esbuildCache = {};
+    const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
+    assertKnownConfigs(plusFilesAll);
+    const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
+    const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
+    // interop vike(options) in vite.config.js
+    temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
+    // global
+    const configValues = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigUserFriendlyNew({ configValues });
+    return { pageConfigs, pageConfigGlobal, global };
+}
+async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
+    const configDefinitionsGlobal = getConfigDefinitions(
+    // We use `plusFilesAll` in order to allow local Vike extensions to create global configs.
+    sortForGlobal(plusFilesAll), (configDef) => !!configDef.global);
+    await loadCustomConfigBuildTimeFiles(plusFilesAll, configDefinitionsGlobal, userRootDir, esbuildCache);
+    const configDefinitionsLocal = {};
+    await Promise.all(objectEntries(plusFilesAll).map(async ([locationId, plusFiles]) => {
+        const plusFilesRelevant = getPlusFilesRelevant(plusFilesAll, locationId);
+        const configDefinitions = getConfigDefinitions(plusFilesRelevant, (configDef) => configDef.global !== true);
+        await loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache);
+        configDefinitionsLocal[locationId] = { configDefinitions, plusFiles, plusFilesRelevant };
     }));
-    // Validate that global configs live in global interface files
-    {
-        const interfaceFilesGlobalPaths = [];
-        objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
-            assert(isGlobalLocation(locationId, locationIds));
-            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
-                if (filePathAbsoluteUserRootDir) {
-                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
-                }
-            });
-        });
-        const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))));
-        objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-            interfaceFiles.forEach((interfaceFile) => {
-                Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                    if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
-                        assertUsage(false, [
-                            `${interfaceFile.filePath.filePathToShowToUser} defines the config ${pc.cyan(configName)} which is global:`,
-                            globalPaths.length
-                                ? `define ${pc.cyan(configName)} in ${joinEnglish(globalPaths, 'or')} instead`
-                                : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead`
-                        ].join(' '));
-                    }
-                });
-            });
-        });
-    }
-    const pageConfigGlobalValues = {};
-    const pageConfigGlobal = {
-        configDefinitions: configDefinitionsBuiltInGlobal,
-        configValueSources: {}
+    const configDefinitionsResolved = {
+        configDefinitionsGlobal,
+        configDefinitionsLocal
     };
-    await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
-        const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir, importedFilesLoaded);
-        const configValueSource = sources[0];
-        if (!configValueSource)
-            return;
-        pageConfigGlobal.configValueSources[configName] = sources;
-        // TODO/now
-        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
-            assert(!('value' in configValueSource));
+    return configDefinitionsResolved;
+}
+// Load value files (with `env.config===true`) of *custom* configs.
+// - The value files of *built-in* configs are already loaded at `getPlusFilesAll()`.
+async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache) {
+    const plusFileList = Object.values(plusFiles).flat(1);
+    await Promise.all(plusFileList.map(async (plusFile) => {
+        if (!plusFile.isConfigFile) {
+            await loadValueFile(plusFile, configDefinitions, userRootDir, esbuildCache);
         }
         else {
-            assert('value' in configValueSource);
-            // TODO/now
-            if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
-                return;
-            pageConfigGlobalValues[configName] = configValueSource.value;
+            await Promise.all(Object.entries(plusFile.pointerImportsByConfigName).map(async ([configName, pointerImport]) => {
+                await loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache);
+            }));
         }
     }));
-    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
-    {
-        assert(isObject(vikeVitePluginOptions));
-        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
-            var _a;
-            assert(includes(objectKeys(configDefinitionsBuiltInGlobal), configName));
-            const configDef = configDefinitionsBuiltInGlobal[configName];
-            const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
-            sources.push({
-                value,
-                configEnv: configDef.env,
-                definedAtFilePath: {
-                    ...getFilePathResolved({
-                        userRootDir,
-                        filePathAbsoluteUserRootDir: '/vite.config.js'
-                    }),
-                    fileExportPathToShowToUser: null
-                },
-                locationId: '/',
-                isOverriden: configDef.cumulative ? false : sources.length > 0,
-                valueIsImportedAtRuntime: false,
-                valueIsDefinedByPlusFile: false
-            });
-        });
-    }
-    const configValues = getConfigValues(pageConfigGlobal);
-    const global = getPageConfigUserFriendlyNew({ configValues });
-    return { pageConfigGlobal, vikeConfigGlobal, global };
 }
-async function getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
-    const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
-        .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
-        .map(async ([locationId]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const interfaceFilesRelevantList = Object.values(interfaceFilesRelevant).flat(1);
-        assertExtensionsPeerDependencies(interfaceFilesRelevantList);
-        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
-        // Load value files of custom config-only configs
-        await Promise.all(interfaceFilesRelevantList.map(async (interfaceFile) => {
-            if (!interfaceFile.isValueFile)
-                return;
-            const { configName } = interfaceFile;
-            if (isGlobalConfig(configName))
-                return;
-            const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (!isLoadableAtBuildTime(configDef))
-                return;
-            const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
-            if (isAlreadyLoaded)
-                return;
-            // Value files of built-in configs should have already been loaded at loadInterfaceFiles()
-            assert(!(configName in configDefinitionsBuiltIn));
-            await loadValueFile(interfaceFile, configName, userRootDir);
-        }));
-        let configValueSources = {};
-        await Promise.all(objectEntries(configDefinitions)
-            .filter(([configName]) => !isGlobalConfig(configName))
-            .map(async ([configName, configDef]) => {
-            const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded);
+function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir) {
+    const pageConfigGlobal = {
+        configDefinitions: configDefinitionsResolved.configDefinitionsGlobal,
+        configValueSources: {}
+    };
+    objectEntries(configDefinitionsResolved.configDefinitionsGlobal).forEach(([configName, configDef]) => {
+        const sources = resolveConfigValueSources(configName, configDef, 
+        // We use `plusFilesAll` in order to allow local Vike extensions to set the value of global configs (e.g. `vite`).
+        sortForGlobal(plusFilesAll), userRootDir, true);
+        if (sources.length === 0)
+            return;
+        pageConfigGlobal.configValueSources[configName] = sources;
+    });
+    assertPageConfigGlobal(pageConfigGlobal, plusFilesAll);
+    const pageConfigs = objectEntries(configDefinitionsResolved.configDefinitionsLocal)
+        .filter(([_locationId, { plusFiles }]) => isDefiningPage(plusFiles))
+        .map(([locationId, { configDefinitions, plusFilesRelevant }]) => {
+        const configDefinitionsLocal = configDefinitions;
+        const configValueSources = {};
+        objectEntries(configDefinitionsLocal)
+            .filter(([_configName, configDef]) => configDef.global !== true)
+            .forEach(([configName, configDef]) => {
+            const sources = resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, false);
+            // sortConfigValueSources(sources, locationId)
             if (sources.length === 0)
                 return;
             configValueSources[configName] = sources;
-        }));
-        configValueSources = sortConfigValueSources(configValueSources, locationId);
+        });
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
-        applyEffectsAll(configValueSources, configDefinitions);
-        const configValuesComputed = getComputed(configValueSources, configDefinitions);
-        assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions, interfaceFilesByLocationId);
+        applyEffectsAll(configValueSources, configDefinitionsLocal);
+        const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
             routeFilesystem,
-            configDefinitions,
+            configDefinitions: configDefinitionsLocal,
+            plusFiles: plusFilesRelevant,
             configValueSources,
             configValuesComputed
         };
         return pageConfig;
-    }));
+    });
     assertPageConfigs(pageConfigs);
-    return pageConfigs;
+    return { pageConfigs, pageConfigGlobal };
+}
+function assertPageConfigGlobal(pageConfigGlobal, plusFilesAll) {
+    Object.entries(pageConfigGlobal.configValueSources).forEach(([configName, sources]) => {
+        assertGlobalConfigLocation(configName, sources, plusFilesAll, pageConfigGlobal.configDefinitions);
+    });
+}
+function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDefinitionsGlobal) {
+    const locationIdsAll = objectKeys(plusFilesAll);
+    // Determine existing global +config.js files
+    const configFilePathsGlobal = [];
+    const plusFilesGlobal = Object.values(objectFromEntries(objectEntries(plusFilesAll).filter(([locationId]) => isGlobalLocation(locationId, locationIdsAll)))).flat();
+    plusFilesGlobal
+        .filter((i) => i.isConfigFile)
+        .forEach((plusFile) => {
+        const { filePathAbsoluteUserRootDir } = plusFile.filePath;
+        if (filePathAbsoluteUserRootDir) {
+            configFilePathsGlobal.push(filePathAbsoluteUserRootDir);
+        }
+    });
+    // Call assertWarning()
+    sources.forEach((source) => {
+        const { plusFile } = source;
+        // It's `null` when the config is defined by `vike(options)` in vite.config.js
+        assert(plusFile);
+        const { filePathAbsoluteUserRootDir } = plusFile.filePath;
+        // Allow local Vike extensions to set gloabl configs (`filePathAbsoluteUserRootDir===null` for Vike extension)
+        if (!filePathAbsoluteUserRootDir)
+            return;
+        assert(!plusFile.isExtensionConfig);
+        if (!isGlobalLocation(source.locationId, locationIdsAll)) {
+            const configDef = configDefinitionsGlobal[configName];
+            assert(configDef);
+            const isConditionallyGlobal = isCallable(configDef.global);
+            const errBeg = `${filePathAbsoluteUserRootDir} (which is a local config file) sets the config ${pc.cyan(configName)}`;
+            const errMid = !isConditionallyGlobal
+                ? "but it's a global config"
+                : 'to a value that is global';
+            const what = isConditionallyGlobal ? 'global values' : pc.cyan(configName);
+            const errEnd = configFilePathsGlobal.length > 0
+                ? `define ${what} at a global config file such as ${joinEnglish(configFilePathsGlobal, 'or')} instead`
+                : `create a global config file (e.g. /pages/+config.js) and define ${what} there instead`;
+            // When updating this error message => also update error message at https://vike.dev/warning/global-config
+            const errMsg = `${errBeg} ${errMid}: ${errEnd} (https://vike.dev/warning/global-config).`;
+            assertWarning(false, errMsg, { onlyOnce: true });
+        }
+    });
+}
+function assertPageConfigs(pageConfigs) {
+    pageConfigs.forEach((pageConfig) => {
+        assertExtensionsRequire(pageConfig);
+        assertOnBeforeRenderEnv(pageConfig);
+    });
+}
+function assertOnBeforeRenderEnv(pageConfig) {
+    const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
+    if (!onBeforeRenderConfig)
+        return;
+    const onBeforeRenderEnv = onBeforeRenderConfig.configEnv;
+    const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean');
+    // 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) {
     const configValues = {};
@@ -422,178 +312,150 @@ function getConfigValues(pageConfig) {
     });
     return configValues;
 }
-// TODO/now: refactor
-//  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
-//    - This assertUsage() message is slightly better: use this one for getGlobalConfigs()
-// Global configs should be defined at global locations
-function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions, interfaceFilesByLocationId) {
-    interfaceFilesRelevantList.forEach((interfaceFile) => {
-        const configNames = [];
-        if (interfaceFile.isValueFile) {
-            configNames.push(interfaceFile.configName);
-        }
-        else {
-            configNames.push(...Object.keys(interfaceFile.fileExportsByConfigName));
-        }
-        configNames.forEach((configName) => {
-            if (isGlobalConfig(configName))
-                return;
-            const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (configDef.global === true) {
-                const locationIds = objectKeys(interfaceFilesByLocationId);
-                if (!isGlobalLocation(interfaceFile.locationId, locationIds)) {
-                    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
-                        return isGlobalLocation(locationId, locationIds);
-                    }));
-                    const configFilesGlobal = [];
-                    objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
-                        assert(isGlobalLocation(locationId, locationIds));
-                        interfaceFiles.forEach((interfaceFile) => {
-                            if (!interfaceFile.isConfigFile)
-                                return;
-                            const { filePath: { filePathAbsoluteUserRootDir } } = interfaceFile;
-                            if (filePathAbsoluteUserRootDir) {
-                                configFilesGlobal.push(filePathAbsoluteUserRootDir);
-                            }
-                        });
-                    });
-                    assertUsage(false, [
-                        `${interfaceFile.filePath.filePathToShowToUser} sets the config ${pc.cyan(configName)} but it's a global config:`,
-                        configFilesGlobal.length > 0
-                            ? `define ${pc.cyan(configName)} at ${joinEnglish(configFilesGlobal, 'or')} instead.`
-                            : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead.`
-                    ].join(' '));
-                }
-            }
+function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir) {
+    assert(isObject(vikeVitePluginOptions));
+    assertWarning(Object.keys(vikeVitePluginOptions).length === 0, `Define Vike settings in +config.js instead of vite.config.js ${pc.underline('https://vike.dev/migration/settings')}`, { onlyOnce: true });
+    Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+        var _a;
+        assert(includes(objectKeys(configDefinitionsBuiltIn), configName));
+        const configDef = configDefinitionsBuiltIn[configName];
+        const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+        sources.push({
+            valueIsLoaded: true,
+            value,
+            configEnv: configDef.env,
+            definedAtFilePath: {
+                ...getFilePathResolved({
+                    userRootDir,
+                    filePathAbsoluteUserRootDir: '/vite.config.js'
+                }),
+                fileExportPathToShowToUser: null
+            },
+            locationId: '/',
+            plusFile: null,
+            isOverriden: configDef.cumulative ? false : sources.length > 0,
+            valueIsImportedAtRuntime: false,
+            valueIsDefinedByPlusFile: false
         });
     });
 }
-function assertPageConfigs(pageConfigs) {
-    pageConfigs.forEach((pageConfig) => {
-        assertOnBeforeRenderEnv(pageConfig);
-    });
-}
-function assertOnBeforeRenderEnv(pageConfig) {
-    const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
-    if (!onBeforeRenderConfig)
-        return;
-    const onBeforeRenderEnv = onBeforeRenderConfig.configEnv;
-    const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean');
-    // 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 interfacefileIsAlreaydLoaded(interfaceFile) {
-    const configMapValues = Object.values(interfaceFile.fileExportsByConfigName);
-    const isAlreadyLoaded = configMapValues.some((conf) => 'configValue' in conf);
-    if (isAlreadyLoaded) {
-        assert(configMapValues.every((conf) => 'configValue' in conf));
-    }
-    return isAlreadyLoaded;
-}
-function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesByLocationId)
+function getPlusFilesRelevant(plusFilesAll, locationIdPage) {
+    const plusFilesRelevant = Object.fromEntries(objectEntries(plusFilesAll)
         .filter(([locationId]) => {
         return isInherited(locationId, locationIdPage);
     })
+        // Sort after config inheritance.
+        // - Together with getPlusFilesOrdered() this implements the whole order of config inheritance.
+        // - See sortForGlobal() for global configs order.
         .sort(([locationId1], [locationId2]) => sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)));
-    return interfaceFilesRelevant;
+    return plusFilesRelevant;
+}
+function sortForGlobal(plusFilesAll) {
+    const locationIdsAll = objectKeys(plusFilesAll);
+    const plusFilesAllSorted = Object.fromEntries(objectEntries(plusFilesAll)
+        .sort(lowerFirst(([locationId]) => locationId.split('/').length))
+        .sort(makeFirst(([locationId]) => isGlobalLocation(locationId, locationIdsAll))));
+    return plusFilesAllSorted;
+}
+function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal) {
+    const plusFilesOrdered = getPlusFilesOrdered(configName, plusFilesRelevant);
+    let sources = plusFilesOrdered.map((plusFile, i) => {
+        const isHighestInheritancePrecedence = i === 0;
+        const configValueSource = getConfigValueSource(configName, plusFile, configDef, userRootDir, isHighestInheritancePrecedence);
+        return configValueSource;
+    });
+    if (isCallable(configDef.global)) {
+        const isGlobalValue = configDef.global;
+        assert(configDef.env.config);
+        sources = sources.filter((source) => {
+            assert(source.configEnv.config);
+            assert(source.valueIsLoaded);
+            const valueIsGlobal = isGlobalValue(source.value);
+            return isGlobal ? valueIsGlobal : !valueIsGlobal;
+        });
+    }
+    return sources;
 }
-async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
-    const sourcesInfo = [];
-    // interfaceFilesRelevant is sorted by sortAfterInheritanceOrder()
-    for (const interfaceFiles of Object.values(interfaceFilesRelevant)) {
-        const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => interfaceFile.fileExportsByConfigName[configName]);
-        if (interfaceFilesDefiningConfig.length === 0)
-            continue;
-        const visited = new WeakSet();
-        const add = (interfaceFile) => {
-            assert(!visited.has(interfaceFile));
-            visited.add(interfaceFile);
-            const isHighestInheritancePrecedence = sourcesInfo.length === 0;
-            sourcesInfo.push([
-                configName,
-                interfaceFile,
-                configDef,
-                userRootDir,
-                importedFilesLoaded,
-                isHighestInheritancePrecedence
-            ]);
+// Together with sortAfterInheritanceOrder() this implements the whole order of config inheritance.
+function getPlusFilesOrdered(configName, plusFilesRelevant) {
+    const plusFilesOrdered = [];
+    // `plusFilesRelevant` is already sorted by sortAfterInheritanceOrder() at getPlusFilesRelevant()
+    // `plusFilesAtLocationId` is already sorted by sortMakeDeterministic() at getPlusFilesAll()
+    for (const plusFilesAtLocationId of Object.values(plusFilesRelevant)) {
+        const plusFilesForConfigName = plusFilesAtLocationId.filter((plusFile) => getDefiningConfigNames(plusFile).includes(configName));
+        // We populate `plusFilesOrdered` with inheritance order.
+        const populate = (plusFile) => {
+            assert(!visited.has(plusFile));
+            visited.add(plusFile);
+            plusFilesOrdered.push(plusFile);
         };
-        // Main resolution logic
+        const visited = new WeakSet();
+        // ========================
+        // User-land config (first)
+        // ========================
         {
-            const interfaceValueFiles = interfaceFilesDefiningConfig
-                .filter((interfaceFile) => interfaceFile.isValueFile &&
+            const plusFilesValue = plusFilesForConfigName.filter((plusFile) => !plusFile.isConfigFile &&
                 // We consider side-effect configs (e.g. `export { frontmatter }` of .mdx files) later (i.e. with less priority)
-                interfaceFile.configName === configName)
-                .sort(makeOrderDeterministic);
-            const interfaceConfigFiles = interfaceFilesDefiningConfig
-                .filter((interfaceFile) => interfaceFile.isConfigFile &&
-                // We consider value from extended configs (e.g. vike-react) later (i.e. with less priority)
-                !interfaceFile.isConfigExtend)
-                .sort(makeOrderDeterministic);
-            const interfaceValueFile = interfaceValueFiles[0];
-            const interfaceConfigFile = interfaceConfigFiles[0];
+                plusFile.configName === configName);
+            const plusFilesConfig = plusFilesForConfigName.filter((plusFile) => plusFile.isConfigFile &&
+                // We consider extensions (e.g. vike-react) later (i.e. with less priority)
+                !plusFile.isExtensionConfig);
             // Make this value:
             //   /pages/some-page/+{configName}.js > `export default`
             // override that value:
             //   /pages/some-page/+config.js > `export default { someConfig }`
-            const interfaceFileWinner = interfaceValueFile ?? interfaceConfigFile;
-            if (interfaceFileWinner) {
-                const interfaceFilesOverriden = [...interfaceValueFiles, ...interfaceConfigFiles].filter((f) => f !== interfaceFileWinner);
-                // A user-land conflict of interfaceFiles with the same locationId means that the user has superfluously defined the config twice; the user should remove such redundancy making things unnecessarily ambiguous
-                warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName);
-                [interfaceFileWinner, ...interfaceFilesOverriden].forEach((interfaceFile) => {
-                    add(interfaceFile);
+            const plusFileWinner = plusFilesValue[0] ?? plusFilesConfig[0];
+            if (plusFileWinner) {
+                const plusFilesOverriden = [...plusFilesValue, ...plusFilesConfig].filter((f) => f !== plusFileWinner);
+                // A user-land conflict of plusFiles with the same `locationId` (we are iterating over `plusFilesRelevant: PlusFilesByLocationId`) means that the user has superfluously defined the config twice; the user should remove such redundancy as it makes things unnecessarily ambiguous.
+                assertOverwrittenConfigFile(plusFileWinner, plusFilesOverriden, configName);
+                [plusFileWinner, ...plusFilesOverriden].forEach((plusFile) => {
+                    assert(plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it's a user-land plus file
+                    populate(plusFile);
                 });
             }
         }
-        // Side-effect configs such as `export { frontmatter }` in .mdx files
-        interfaceFilesDefiningConfig
-            .filter((interfaceFile) => interfaceFile.isValueFile &&
+        // ==========================
+        // Side-effect configs (next)
+        // ==========================
+        // - For example `export { frontmatter }` of `.mdx` files.
+        // - This only considers side-effect configs that are already loaded at build-time. (E.g. it actually doesn't consider `export { frontmatter }` of .mdx files since .mdx files are loaded only at runtime.)
+        plusFilesForConfigName
+            .filter((plusFile) => !plusFile.isConfigFile &&
             // Is side-effect config
-            interfaceFile.configName !== configName)
-            .forEach((interfaceValueFileSideEffect) => {
-            add(interfaceValueFileSideEffect);
+            plusFile.configName !== configName)
+            .forEach((plusFile) => {
+            assert(plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it's a user-land plus file
+            populate(plusFile);
         });
-        // extends
-        interfaceFilesDefiningConfig
-            .filter((interfaceFile) => interfaceFile.isConfigFile && interfaceFile.isConfigExtend)
-            // extended config files are already sorted by inheritance order
-            .forEach((interfaceFile) => {
-            add(interfaceFile);
+        // ========================
+        // Extensions config (last)
+        // ========================
+        plusFilesForConfigName
+            .filter((plusFile) => plusFile.isConfigFile && plusFile.isExtensionConfig)
+            // Extension config files are already sorted by inheritance order
+            .forEach((plusFile) => {
+            assert(!plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it isn't a user-land plus file
+            populate(plusFile);
         });
-        interfaceFilesDefiningConfig.forEach((interfaceFile) => {
-            assert(visited.has(interfaceFile));
+        // ======
+        // Assert we didn't miss any config.
+        // ======
+        plusFilesForConfigName.forEach((plusFile) => {
+            assert(visited.has(plusFile));
         });
     }
-    const sources = await Promise.all(sourcesInfo.map(async (args) => await getConfigValueSource(...args)));
-    return sources;
-}
-function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
-    return lowerFirst((interfaceFile) => {
-        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
-        assert(isInterfaceFileUserLand(interfaceFile));
-        assert(filePathAbsoluteUserRootDir);
-        return filePathAbsoluteUserRootDir.length;
-    })(interfaceFile1, interfaceFile2);
-}
-function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName) {
-    interfaceFilesOverriden.forEach((interfaceFileLoser) => {
-        const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser;
-        const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser;
-        const confName = pc.cyan(configName);
-        assertWarning(false, `The value of the config ${confName} defined at ${loserFilePath} is always overwritten by the value defined at ${winnerFilePath}, remove the superfluous value defined at ${loserFilePath}`, { onlyOnce: true });
-    });
-}
-function isInterfaceFileUserLand(interfaceFile) {
-    return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
-}
-async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded, isHighestInheritancePrecedence) {
-    const conf = interfaceFile.fileExportsByConfigName[configName];
-    assert(conf);
-    const { locationId } = interfaceFile;
+    return plusFilesOrdered;
+}
+function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHighestInheritancePrecedence) {
+    const confVal = getConfVal(plusFile, configName);
+    assert(confVal);
+    const configValueSourceCommon = {
+        locationId: plusFile.locationId,
+        plusFile
+    };
     const definedAtFilePath_ = {
-        ...interfaceFile.filePath,
+        ...plusFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
     };
     const isOverriden = configDef.cumulative ? false : !isHighestInheritancePrecedence;
@@ -601,25 +463,27 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     if (configDef._valueIsFilePath) {
         let definedAtFilePath;
         let valueFilePath;
-        if (interfaceFile.isConfigFile) {
+        if (plusFile.isConfigFile) {
             // Defined over pointer import
-            const resolved = resolvePointerImportOfConfig(conf.configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
+            assert(confVal.configValueLoaded);
+            const pointerImport = resolvePointerImport(confVal.configValue, plusFile.filePath, userRootDir, configName);
             const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtFilePath_);
-            assertUsage(resolved, `${configDefinedAt} should be an import`);
-            valueFilePath = resolved.pointerImport.filePathAbsoluteVite;
-            definedAtFilePath = resolved.pointerImport;
+            assertUsage(pointerImport, `${configDefinedAt} should be an import`);
+            valueFilePath = pointerImport.fileExportPath.filePathAbsoluteVite;
+            definedAtFilePath = pointerImport.fileExportPath;
         }
         else {
             // Defined by value file, i.e. +{configName}.js
-            assert(interfaceFile.isValueFile);
-            valueFilePath = interfaceFile.filePath.filePathAbsoluteVite;
+            assert(!plusFile.isConfigFile);
+            valueFilePath = plusFile.filePath.filePathAbsoluteVite;
             definedAtFilePath = {
-                ...interfaceFile.filePath,
+                ...plusFile.filePath,
                 fileExportPathToShowToUser: []
             };
         }
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
+            valueIsLoaded: true,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv: configDef.env,
@@ -631,38 +495,35 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         return configValueSource;
     }
     // +config.js
-    if (interfaceFile.isConfigFile) {
-        assert('configValue' in conf);
-        const { configValue } = conf;
+    if (plusFile.isConfigFile) {
+        assert(confVal.configValueLoaded);
+        const { configValue } = confVal;
         // Defined over pointer import
-        const resolved = resolvePointerImportOfConfig(configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
-        if (resolved) {
+        const pointerImport = plusFile.pointerImportsByConfigName[configName];
+        if (pointerImport) {
+            const value = pointerImport.fileExportValueLoaded
+                ? {
+                    valueIsLoaded: true,
+                    value: pointerImport.fileExportValue
+                }
+                : {
+                    valueIsLoaded: false
+                };
             const configValueSource = {
-                locationId,
-                configEnv: resolved.configEnvResolved,
+                ...configValueSourceCommon,
+                ...value,
+                configEnv: resolveConfigEnv(configDef.env, pointerImport.fileExportPath),
                 valueIsImportedAtRuntime: true,
                 valueIsDefinedByPlusFile: false,
                 isOverriden,
-                definedAtFilePath: resolved.pointerImport
+                definedAtFilePath: pointerImport.fileExportPath
             };
-            // Load pointer import
-            if (isLoadableAtBuildTime(configDef) &&
-                // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
-                configName !== 'extends') {
-                if (resolved.pointerImport.filePathAbsoluteFilesystem) {
-                    const fileExport = await loadImportedFile(resolved.pointerImport, userRootDir, importedFilesLoaded);
-                    configValueSource.value = fileExport;
-                }
-                else {
-                    const configDefinedAt = getConfigDefinedAt('Config', configName, configValueSource.definedAtFilePath);
-                    assertUsage(!configDef.cumulative, `${configDefinedAt} cannot be defined over an aliased import`);
-                }
-            }
             return configValueSource;
         }
         // Defined inside +config.js
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
+            valueIsLoaded: true,
             value: configValue,
             configEnv: configDef.env,
             valueIsImportedAtRuntime: false,
@@ -673,34 +534,48 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         return configValueSource;
     }
     // Defined by value file, i.e. +{configName}.js
-    if (interfaceFile.isValueFile) {
-        const configEnvResolved = resolveConfigEnvWithFileName(configDef.env, interfaceFile.filePath);
-        const valueAlreadyLoaded = 'configValue' in conf;
+    if (!plusFile.isConfigFile) {
+        const configEnvResolved = resolveConfigEnv(configDef.env, plusFile.filePath);
+        const valueAlreadyLoaded = confVal.configValueLoaded;
         assert(valueAlreadyLoaded === !!configEnvResolved.config);
+        const value = valueAlreadyLoaded
+            ? {
+                valueIsLoaded: true,
+                value: confVal.configValue
+            }
+            : {
+                valueIsLoaded: false
+            };
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
+            ...value,
             configEnv: configEnvResolved,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByPlusFile: true,
             isOverriden,
             definedAtFilePath: {
-                ...interfaceFile.filePath,
-                fileExportPathToShowToUser: configName === interfaceFile.configName
+                ...plusFile.filePath,
+                fileExportPathToShowToUser: configName === plusFile.configName
                     ? []
                     : // Side-effect config (e.g. `export { frontmatter }` of .md files)
                         [configName]
             }
         };
-        if (valueAlreadyLoaded) {
-            configValueSource.value = conf.configValue;
-        }
         return configValueSource;
     }
     assert(false);
 }
-function isDefiningPage(interfaceFiles) {
-    for (const interfaceFile of interfaceFiles) {
-        const configNames = Object.keys(interfaceFile.fileExportsByConfigName);
+function assertOverwrittenConfigFile(plusFileWinner, plusFilesOverriden, configName) {
+    plusFilesOverriden.forEach((plusFileLoser) => {
+        const loserFilePath = plusFileLoser.filePath.filePathToShowToUser;
+        const winnerFilePath = plusFileWinner.filePath.filePathToShowToUser;
+        const confName = pc.cyan(configName);
+        assertWarning(false, `The value of the config ${confName} defined at ${loserFilePath} is always overwritten by the value defined at ${winnerFilePath}, remove the superfluous value defined at ${loserFilePath}`, { onlyOnce: true });
+    });
+}
+function isDefiningPage(plusFiles) {
+    for (const plusFile of plusFiles) {
+        const configNames = getDefiningConfigNames(plusFile);
         if (configNames.some((configName) => isDefiningPageConfig(configName))) {
             return true;
         }
@@ -710,37 +585,52 @@ function isDefiningPage(interfaceFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function getConfigDefinitions(interfaceFilesRelevant) {
-    const configDefinitionsMerged = { ...configDefinitionsBuiltIn };
-    Object.entries(interfaceFilesRelevant)
+function getDefiningConfigNames(plusFile) {
+    let configNames = [];
+    if (!plusFile.isConfigFile) {
+        configNames.push(plusFile.configName);
+    }
+    if (!plusFile.isNotLoaded) {
+        configNames.push(...Object.keys(plusFile.fileExportsByConfigName));
+    }
+    configNames = unique(configNames);
+    return configNames;
+}
+function getConfigDefinitions(plusFilesRelevant, filter) {
+    let configDefinitions = { ...configDefinitionsBuiltIn };
+    // Add user-land meta configs
+    Object.entries(plusFilesRelevant)
         .reverse()
-        .forEach(([_locationId, interfaceFiles]) => {
-        interfaceFiles.forEach((interfaceFile) => {
-            const configMeta = interfaceFile.fileExportsByConfigName['meta'];
-            if (!configMeta)
+        .forEach(([_locationId, plusFiles]) => {
+        plusFiles.forEach((plusFile) => {
+            const confVal = getConfVal(plusFile, 'meta');
+            if (!confVal)
                 return;
-            const meta = configMeta.configValue;
-            assertMetaUsage(meta, `Config ${pc.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
+            assert(confVal.configValueLoaded);
+            const meta = confVal.configValue;
+            assertMetaUsage(meta, `Config ${pc.cyan('meta')} defined at ${plusFile.filePath.filePathToShowToUser}`);
             // Set configDef._userEffectDefinedAtFilePath
             Object.entries(meta).forEach(([configName, configDef]) => {
                 if (!configDef.effect)
                     return;
-                assert(interfaceFile.isConfigFile);
+                assert(plusFile.isConfigFile);
                 configDef._userEffectDefinedAtFilePath = {
-                    ...interfaceFile.filePath,
+                    ...plusFile.filePath,
                     fileExportPathToShowToUser: ['default', 'meta', configName, 'effect']
                 };
             });
-            objectEntries(meta).forEach(([configName, configDefinition]) => {
+            objectEntries(meta).forEach(([configName, configDefinitionUserLand]) => {
                 // User can override an existing config definition
-                configDefinitionsMerged[configName] = {
-                    ...configDefinitionsMerged[configName],
-                    ...configDefinition
+                configDefinitions[configName] = {
+                    ...configDefinitions[configName],
+                    ...configDefinitionUserLand
                 };
             });
         });
     });
-    const configDefinitions = configDefinitionsMerged;
+    if (filter) {
+        configDefinitions = Object.fromEntries(Object.entries(configDefinitions).filter(([_configName, configDef]) => filter(configDef)));
+    }
     return configDefinitions;
 }
 function assertMetaUsage(metaVal, metaConfigDefinedAt) {
@@ -857,47 +747,35 @@ function getComputed(configValueSources, configDefinitions) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, outDirRoot) {
-    const files = await crawlPlusFiles(userRootDir, outDirRoot);
-    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
-    return plusFiles;
-}
-function getConfigName(filePath) {
-    assertPosixPath(filePath);
-    if (isTemporaryBuildFile(filePath))
-        return null;
-    const fileName = path.posix.basename(filePath);
-    // assertNoUnexpectedPlusSign(filePath, fileName)
-    const basename = fileName.split('.')[0];
-    if (!basename.startsWith('+')) {
-        return null;
-    }
-    else {
-        const configName = basename.slice(1);
-        assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
-        return configName;
-    }
-}
-/* https://github.com/vikejs/vike/issues/1407
-function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
-  const dirs = path.posix.dirname(filePath).split('/')
-  dirs.forEach((dir, i) => {
-    const dirPath = dirs.slice(0, i + 1).join('/')
-    assertUsage(
-      !dir.includes('+'),
-      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
-    )
-  })
-  assertUsage(
-    !fileName.slice(1).includes('+'),
-    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
-  )
+// Show error message upon unknown config
+function assertKnownConfigs(plusFilesAll) {
+    const configDefinitionsAll = getConfigDefinitions(plusFilesAll);
+    const configNamesKnownAll = Object.keys(configDefinitionsAll);
+    objectEntries(plusFilesAll).forEach(([locationId, plusFiles]) => {
+        const plusFilesRelevant = getPlusFilesRelevant(plusFilesAll, locationId);
+        const configDefinitionsLocal = getConfigDefinitions(plusFilesRelevant);
+        const configNamesKnownLocal = Object.keys(configDefinitionsLocal);
+        plusFiles.forEach((plusFile) => {
+            const configNames = getDefiningConfigNames(plusFile);
+            configNames.forEach((configName) => {
+                assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, plusFile);
+                assert(configNamesKnownLocal.includes(configName));
+                assert(configNamesKnownAll.includes(configName));
+            });
+        });
+    });
 }
-*/
-function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
+function assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, plusFile) {
+    if (configNamesKnownLocal.includes(configName))
+        return;
     const configNameColored = pc.cyan(configName);
-    let errMsg = `${filePathToShowToUser} sets an unknown config ${configNameColored}.`;
-    // vike-{react,vue,solid} hint
+    const { locationId, filePath: { filePathToShowToUser } } = plusFile;
+    const errMsg = `${filePathToShowToUser} sets an unknown config ${configNameColored}`;
+    // Inheritance issue: config is known but isn't defined at `locationId`
+    if (configNamesKnownAll.includes(configName)) {
+        assertUsage(false, `${filePathToShowToUser} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`);
+    }
+    // Missing vike-{react,vue,solid} installation
     {
         const ui = ['vike-react', 'vike-vue', 'vike-solid'];
         const knownVikeExntensionConfigs = {
@@ -912,15 +790,11 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
             Wrapper: ui
         };
         if (configName in knownVikeExntensionConfigs) {
-            const requiredVikeExtension = knownVikeExntensionConfigs[configName];
-            assertUsage(false, [
-                errMsg,
-                `If you want to use the configuration documented at https://vike.dev/${configName} then make sure to install the Vike extension ${requiredVikeExtension
-                    .map((e) => pc.bold(e))
-                    .join('/')}.`,
-                `Also make sure it applies to ${filePathToShowToUser} (see https://vike.dev/extends#inheritance).`,
-                `Alternatively, if you don't want to use the aforementioned Vike extension, define it yourself by using ${pc.cyan('meta')} (https://vike.dev/meta).`
-            ].join(' '));
+            const requiredVikeExtension = knownVikeExntensionConfigs[configName]
+                .map((e) => pc.bold(e))
+                .join('/');
+            const errMsgEnhanced = `${errMsg}. If you want to use the configuration ${configNameColored} documented at ${pc.underline(`https://vike.dev/${configName}`)} then make sure to install ${requiredVikeExtension}. (Alternatively, you can define ${configNameColored} yourself by using ${pc.cyan('meta')}, see ${pc.underline('https://vike.dev/meta')} for more information.)`;
+            assertUsage(false, errMsgEnhanced);
         }
     }
     // Similarity hint
@@ -929,18 +803,15 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
         configNameSimilar = 'Page';
     }
     else {
-        configNameSimilar = getMostSimilar(configName, configNames);
+        configNameSimilar = getMostSimilar(configName, configNamesKnownAll);
     }
     if (configNameSimilar) {
         assert(configNameSimilar !== configName);
-        errMsg += ` Did you mean to set ${pc.cyan(configNameSimilar)} instead?`;
+        let errMsgEnhanced = `${errMsg}. Did you mean ${pc.cyan(configNameSimilar)} instead?`;
         if (configName === 'page') {
-            errMsg += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.cyan('P')} because it defines a UI component: a ubiquitous JavaScript convention is that the name of UI components start with a capital letter.)`;
+            errMsgEnhanced += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.cyan('P')} because it defines a UI component: a ubiquitous JavaScript convention is that the name of UI components start with a capital letter.)`;
         }
-    }
-    // `meta` hint
-    if (!configNameSimilar) {
-        errMsg += ` Make sure to define ${configNameColored} by using ${pc.cyan('meta')} (https://vike.dev/meta), and also make sure the meta configuration applies to ${filePathToShowToUser} (see https://vike.dev/config#inheritance).`;
+        assertUsage(false, errMsgEnhanced);
     }
     assertUsage(false, errMsg);
 }
@@ -988,9 +859,6 @@ function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function isVikeConfigFile(filePath) {
-    return !!getConfigName(filePath);
-}
 function getConfigEnvValue(val, errMsgIntro) {
     const errInvalidValue = `${errMsgIntro} an invalid value ${pc.cyan(JSON.stringify(val))}`;
     // Legacy outdated values
@@ -1027,89 +895,34 @@ function getConfigEnvValue(val, errMsgIntro) {
     */
     return val;
 }
-function getConfigDefinition(configDefinitions, configName, filePathToShowToUser) {
-    const configDef = configDefinitions[configName];
-    assertConfigExists(configName, Object.keys(configDefinitions), filePathToShowToUser);
-    assert(configDef);
-    return configDef;
-}
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-function isLoadableAtBuildTime(configDef) {
-    return !!configDef.env.config && !configDef._valueIsFilePath;
-}
-function isGlobalConfig(configName) {
-    // TODO/now
-    if (configName === 'prerender')
-        return false;
-    const configNamesGlobal = getConfigNamesGlobal();
-    return includes(configNamesGlobal, configName);
-}
-function getConfigNamesGlobal() {
-    return Object.keys(configDefinitionsBuiltInGlobal);
-}
-function getConfigDefinitionsBuiltInGlobal() {
-    return objectFromEntries(objectEntries(configDefinitionsBuiltInAll).filter(([_configName, configDef]) => configDef.global !== undefined));
-}
-function getConfigDefinitionsBuiltIn() {
-    return objectFromEntries(objectEntries(configDefinitionsBuiltInAll).filter(([_configName, configDef]) => configDef.global !== true));
-}
-function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
-    const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
-    if (configNames.includes(configName))
-        return;
-    handleUnknownConfig(configName, configNames, filePathToShowToUser);
-    assert(false);
-}
-function sortConfigValueSources(configValueSources, locationIdPage) {
-    return Object.fromEntries(Object.entries(configValueSources)
-        // Make order deterministic (no other purpose)
-        .sort(([, [source1]], [, [source2]]) => source1.definedAtFilePath.filePathAbsoluteVite < source2.definedAtFilePath.filePathAbsoluteVite ? -1 : 1)
-        // Sort after whether the config value was defined by an npm package
-        .sort(makeFirst(([, [source]]) => {
-        const { importPathAbsolute } = source.definedAtFilePath;
-        return (!!importPathAbsolute &&
-            isNpmPackageImport(importPathAbsolute, {
-                // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
-                cannotBePathAlias: true
-            }));
-    }))
-        // Sort after the filesystem inheritance of the config value
-        .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));
-}
-function getConfigValueInterfaceFile(interfaceFile, configName) {
-    return interfaceFile.fileExportsByConfigName[configName]?.configValue;
-}
-// TODO/now: refactor code below
-function resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues) {
-    const configs = [vikeVitePluginOptions, pageConfigGlobalValues];
-    const vikeConfigGlobal = {
-        disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
-        prerender: resolvePrerenderOptions(configs),
-        includeAssetsImportedByServer: pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
-        baseServer: pickFirst(configs.map((c) => c.baseServer)) ?? null,
-        baseAssets: pickFirst(configs.map((c) => c.baseAssets)) ?? null,
-        disableUrlNormalization: pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
-        trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false
-    };
-    return vikeConfigGlobal;
-}
-function resolvePrerenderOptions(configs) {
-    if (!configs.some((c) => c.prerender)) {
-        return false;
+function getConfVal(plusFile, configName) {
+    const configNames = getDefiningConfigNames(plusFile);
+    if (!configNames.includes(configName))
+        return null;
+    if (plusFile.isNotLoaded)
+        return { configValueLoaded: false };
+    const confVal = { configValue: plusFile.fileExportsByConfigName[configName], configValueLoaded: true };
+    return confVal;
+}
+function resolveConfigEnv(configEnv, filePath) {
+    const configEnvResolved = { ...configEnv };
+    if (filePath.filePathAbsoluteFilesystem) {
+        const { fileName } = filePath;
+        if (fileName.includes('.server.')) {
+            configEnvResolved.server = true;
+            configEnvResolved.client = false;
+        }
+        else if (fileName.includes('.client.')) {
+            configEnvResolved.client = true;
+            configEnvResolved.server = false;
+        }
+        else if (fileName.includes('.shared.')) {
+            configEnvResolved.server = true;
+            configEnvResolved.client = true;
+        }
     }
-    const configsPrerender = configs.map((c) => c.prerender).filter(isObject2);
-    return {
-        partial: pickFirst(configsPrerender.map((c) => c.partial)) ?? false,
-        noExtraDir: pickFirst(configsPrerender.map((c) => c.noExtraDir)) ?? false,
-        parallel: pickFirst(configsPrerender.map((c) => c.parallel)) ?? true,
-        disableAutoRun: pickFirst(configsPrerender.map((c) => c.disableAutoRun)) ?? false
-    };
-}
-function isObject2(p) {
-    return typeof p === 'object';
-}
-function pickFirst(arr) {
-    return arr.filter((v) => v !== undefined)[0];
+    return configEnvResolved;
 }