vike 0.4.144 → 0.4.145-commit-2520555

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

@@ -2,7 +2,7 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import { assertPosixPath, assert, isObject, assertUsage, toPosixPath, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, scriptFileExtensions, mergeCumulativeValues, requireResolve } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, toPosixPath, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, scriptFileExtensions, mergeCumulativeValues, requireResolve, getOutDirs } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import glob from 'fast-glob';
@@ -13,11 +13,11 @@ import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/render
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
-import { getFilePathToShowToUser } from './getFilePathToShowToUser.js';
 import pc from '@brillout/picocolors';
-import { getConfigDefinedAtString } from '../../../../../shared/page-configs/utils.js';
+import { getConfigDefinedAtString } from '../../../../../shared/page-configs/helpers.js';
 import { assertExportsOfConfigFile, assertExportsOfValueFile } from '../../../../../shared/page-configs/assertExports.js';
 import { getConfigValueSerialized } from './getVirtualFilePageConfigs.js';
+import { getConfigVike } from '../../../../shared/getConfigVike.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -61,9 +61,11 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(userRootDir, outDirRoot, isDev, extensions, tolerateInvalidConfig = false) {
+async function getVikeConfig(config, isDev, tolerateInvalidConfig = false, extensions) {
+    const { outDirRoot } = getOutDirs(config);
+    const userRootDir = config.root;
     if (!vikeConfigPromise) {
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, extensions, tolerateInvalidConfig);
+        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, extensions ?? (await getConfigVike(config)).extensions, tolerateInvalidConfig);
     }
     return await vikeConfigPromise;
 }
@@ -72,7 +74,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
-        if (getConfigName(f.filePathRelativeToUserRootDir) === 'config') {
+        if (getConfigName(f.filePathAbsoluteFilesystem) === 'config') {
             configFiles.push(f);
         }
         else {
@@ -81,15 +83,10 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
     });
     let interfaceFilesByLocationId = {};
     // Config files
-    await Promise.all(configFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
-        const configFilePath = {
-            filePathAbsolute: filePathAbsolute,
-            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
-            importPathAbsolute: null
-        };
-        const { configFile, extendsConfigs } = await loadConfigFile(configFilePath, userRootDir, []);
+    await Promise.all(configFiles.map(async (filePath) => {
+        const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, []);
         const interfaceFile = getInterfaceFileFromConfigFile(configFile, false);
-        const locationId = getLocationId(filePathRelativeToUserRootDir);
+        const locationId = getLocationId(filePath.filePathAbsoluteVite);
         interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
         interfaceFilesByLocationId[locationId].push(interfaceFile);
         extendsConfigs.forEach((extendsConfig) => {
@@ -98,15 +95,11 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
         });
     }));
     // Value files
-    await Promise.all(valueFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
-        const configName = getConfigName(filePathRelativeToUserRootDir);
+    await Promise.all(valueFiles.map(async (filePath) => {
+        const configName = getConfigName(filePath.filePathAbsoluteVite);
         assert(configName);
         const interfaceFile = {
-            filePath: {
-                filePathRelativeToUserRootDir,
-                filePathAbsolute,
-                importPathAbsolute: null
-            },
+            filePath,
             configMap: {
                 [configName]: {}
             },
@@ -115,25 +108,25 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
             configName
         };
         {
-            // We don't have access to custom config definitions yet
-            //  - We load +{configName}.js later
-            //  - But we do need to eagerly load +meta.js (to get all the custom config definitions)
+            // 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?.env === 'config-only') {
+            if (configDef && isConfigEnv(configDef, configName)) {
                 await loadValueFile(interfaceFile, configName, userRootDir);
             }
         }
         {
-            const locationId = getLocationId(filePathRelativeToUserRootDir);
+            const locationId = getLocationId(filePath.filePathAbsoluteVite);
             interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
             interfaceFilesByLocationId[locationId].push(interfaceFile);
         }
     }));
     return interfaceFilesByLocationId;
 }
-function getConfigDefinition(configDefinitionsRelevant, configName, definedByFile) {
+function getConfigDefinition(configDefinitionsRelevant, configName, filePathToShowToUser) {
     const configDef = configDefinitionsRelevant[configName];
-    assertConfigExists(configName, Object.keys(configDefinitionsRelevant), definedByFile);
+    assertConfigExists(configName, Object.keys(configDefinitionsRelevant), filePathToShowToUser);
     assert(configDef);
     return configDef;
 }
@@ -142,13 +135,29 @@ function getConfigDefinitionOptional(configDefinitions, configName) {
 }
 async function loadValueFile(interfaceValueFile, configName, userRootDir) {
     const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, true, userRootDir);
-    const filePathToShowToUser = getFilePathToShowToUser(interfaceValueFile.filePath);
+    const { filePathToShowToUser } = interfaceValueFile.filePath;
     assertExportsOfValueFile(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
         const configName_ = exportName === 'default' ? configName : exportName;
         interfaceValueFile.configMap[configName_] = { configValue };
     });
 }
+async function loadImportedFile(filePath, userRootDir, importedFilesLoaded) {
+    const f = filePath.filePathAbsoluteFilesystem;
+    if (!importedFilesLoaded[f]) {
+        importedFilesLoaded[f] = transpileAndExecuteFile(filePath, true, userRootDir).then((r) => r.fileExports);
+    }
+    const fileExports = await importedFilesLoaded[f];
+    return fileExports;
+}
+function isConfigEnv(configDef, configName) {
+    if (configDef.cumulative)
+        return true;
+    if (configDef.env === 'config-only')
+        return true;
+    // TODO: replace with proper `env: { config: boolean }` implementation
+    return configName === 'clientRouting';
+}
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
     const interfaceFile = {
@@ -159,7 +168,7 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
         isConfigExtend,
         extendsFilePaths
     };
-    const filePathToShowToUser = getFilePathToShowToUser(filePath);
+    const { filePathToShowToUser } = filePath;
     assertExportsOfConfigFile(fileExports, filePathToShowToUser);
     Object.entries(fileExports.default).forEach(([configName, configValue]) => {
         interfaceFile.configMap[configName] = { configValue };
@@ -209,7 +218,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
 }
 async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
     const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions);
-    const { globalVikeConfig, pageConfigGlobal } = getGlobalConfigs(interfaceFilesByLocationId, userRootDir);
+    const importedFilesLoaded = {};
+    const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all(Object.entries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
@@ -222,25 +232,25 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
             const { configName } = interfaceFile;
             if (isGlobalConfig(configName))
                 return;
-            const configDef = getConfigDefinition(configDefinitionsRelevant, configName, getFilePathToShowToUser(interfaceFile.filePath));
-            if (configDef.env !== 'config-only')
+            const configDef = getConfigDefinition(configDefinitionsRelevant, configName, interfaceFile.filePath.filePathToShowToUser);
+            if (!isConfigEnv(configDef, configName))
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
             if (isAlreadyLoaded)
                 return;
-            // Value files for built-in confg-only configs should have already been loaded at loadInterfaceFiles()
+            // Value files of built-in configs should have already been loaded at loadInterfaceFiles()
             assert(!(configName in configDefinitionsBuiltIn));
             await loadValueFile(interfaceFile, configName, userRootDir);
         }));
         const configValueSources = {};
-        objectEntries(configDefinitionsRelevant)
+        await Promise.all(objectEntries(configDefinitionsRelevant)
             .filter(([configName]) => !isGlobalConfig(configName))
-            .forEach(([configName, configDef]) => {
-            const sources = resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir);
-            if (!sources)
+            .map(async ([configName, configDef]) => {
+            const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded);
+            if (sources.length === 0)
                 return;
             configValueSources[configName] = sources;
-        });
+        }));
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsAll(configValueSources, configDefinitionsRelevant);
         const configValuesComputed = getComputed(configValueSources, configDefinitionsRelevant);
@@ -261,7 +271,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
         const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
         interfaceFiles.forEach((interfaceFile) => {
             Object.keys(interfaceFile.configMap).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), getFilePathToShowToUser(interfaceFile.filePath));
+                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
             });
         });
     });
@@ -290,7 +300,7 @@ function getInterfaceFileList(interfaceFilesByLocationId) {
     });
     return interfaceFiles;
 }
-function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
+async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
     const locationIds = Object.keys(interfaceFilesByLocationId);
     const interfaceFilesGlobal = Object.fromEntries(Object.entries(interfaceFilesByLocationId).filter(([locationId]) => {
         return isGlobalLocation(locationId, locationIds);
@@ -312,7 +322,7 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
                 Object.keys(interfaceFile.configMap).forEach((configName) => {
                     if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
                         assertUsage(false, [
-                            `${getFilePathToShowToUser(interfaceFile.filePath)} defines the config ${pc.cyan(configName)} which is global:`,
+                            `${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`
@@ -326,9 +336,9 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
     const pageConfigGlobal = {
         configValueSources: {}
     };
-    objectEntries(configDefinitionsBuiltInGlobal).forEach(([configName, configDef]) => {
-        const sources = resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir);
-        const configValueSource = sources?.[0];
+    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;
         if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
@@ -339,28 +349,25 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
             assert('value' in configValueSource);
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
-            const sourceFilePath = getDefinedAtFilePathToShowToUser(configValueSource.definedAtInfo);
-            assert(sourceFilePath);
-            assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${sourceFilePath} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
+            const { filePathToShowToUser } = configValueSource.definedAt;
+            assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
             globalVikeConfig[configName] = configValueSource.value;
         }
-    });
+    }));
     return { pageConfigGlobal, globalVikeConfig };
 }
-function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir) {
-    let sources = null;
+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.configMap[configName]);
         if (interfaceFilesDefiningConfig.length === 0)
             continue;
-        sources = sources ?? [];
         const visited = new WeakSet();
         const add = (interfaceFile) => {
             assert(!visited.has(interfaceFile));
             visited.add(interfaceFile);
-            const configValueSource = getConfigValueSource(configName, interfaceFile, configDef, userRootDir);
-            sources.push(configValueSource);
+            sourcesInfo.push([configName, interfaceFile, configDef, userRootDir, importedFilesLoaded]);
         };
         // Main resolution logic
         {
@@ -384,7 +391,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             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, configDef, userRootDir);
+                warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName);
                 [interfaceFileWinner, ...interfaceFilesOverriden].forEach((interfaceFile) => {
                     add(interfaceFile);
                 });
@@ -409,7 +416,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             assert(visited.has(interfaceFile));
         });
     }
-    assert(sources === null || sources.length > 0);
+    const sources = await Promise.all(sourcesInfo.map(async (args) => await getConfigValueSource(...args)));
     return sources;
 }
 function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
@@ -420,41 +427,41 @@ function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
         return filePathRelativeToUserRootDir.length;
     })(interfaceFile1, interfaceFile2);
 }
-function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName, configDef, userRootDir) {
+function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName) {
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
-        const configValueSourceWinner = getConfigValueSource(configName, interfaceFileWinner, configDef, userRootDir);
-        const configValueSourceLoser = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
-        assertWarning(false, `${getConfigSourceDefinedAtString(configName, configValueSourceLoser, undefined, true)} overriden by another ${getConfigSourceDefinedAtString(configName, configValueSourceWinner, undefined, false)}, remove one of the two`, { onlyOnce: false });
+        const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser;
+        const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser;
+        assertWarning(false, `Config ${configName} defined at ${loserFilePath} is always overwritten by ${configName} defined at ${winnerFilePath}, remove the superfluous ${configName} value defined at ${interfaceFileLoser}`, { onlyOnce: false });
     });
 }
 function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
-function getConfigValueSource(configName, interfaceFile, configDef, userRootDir) {
+async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded) {
     const conf = interfaceFile.configMap[configName];
     assert(conf);
     const configEnv = configDef.env;
     const definedAtConfigFile = {
         ...interfaceFile.filePath,
-        fileExportPath: ['default', configName]
+        fileExportPathToShowToUser: ['default', configName]
     };
     if (configDef._valueIsFilePath) {
-        let definedAtInfo;
+        let definedAt;
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
             const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-            const configDefinedAt = getConfigSourceDefinedAtString(configName, { definedAtInfo: definedAtConfigFile });
+            const configDefinedAt = getConfigDefinedAtString('Config', configName, { definedAt: definedAtConfigFile });
             assertUsage(import_, `${configDefinedAt} should be an import`);
-            valueFilePath = import_.filePathRelativeToUserRootDir ?? import_.importPathAbsolute;
-            definedAtInfo = import_;
+            valueFilePath = import_.filePathAbsoluteVite;
+            definedAt = import_;
         }
         else {
             assert(interfaceFile.isValueFile);
-            valueFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir;
-            definedAtInfo = {
+            valueFilePath = interfaceFile.filePath.filePathAbsoluteVite;
+            definedAt = {
                 ...interfaceFile.filePath,
-                fileExportPath: []
+                fileExportPathToShowToUser: []
             };
         }
         const configValueSource = {
@@ -462,7 +469,7 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
-            definedAtInfo
+            definedAt
         };
         return configValueSource;
     }
@@ -474,8 +481,20 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
             const configValueSource = {
                 configEnv,
                 valueIsImportedAtRuntime: true,
-                definedAtInfo: import_
+                definedAt: import_
             };
+            // Load config value
+            if (isConfigEnv(configDef, configName)) {
+                if (import_.filePathAbsoluteFilesystem) {
+                    assert(hasProp(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
+                    const fileExports = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
+                    configValueSource.value = fileExports[import_.fileExportName];
+                }
+                else {
+                    const configDefinedAt = getConfigDefinedAtString('Config', configName, configValueSource);
+                    assertUsage(!configDef.cumulative, `${configDefinedAt} cannot be defined over an aliased import`);
+                }
+            }
             return configValueSource;
         }
         else {
@@ -483,7 +502,7 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
                 value: configValue,
                 configEnv,
                 valueIsImportedAtRuntime: false,
-                definedAtInfo: definedAtConfigFile
+                definedAt: definedAtConfigFile
             };
             return configValueSource;
         }
@@ -493,9 +512,9 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
-            definedAtInfo: {
+            definedAt: {
                 ...interfaceFile.filePath,
-                fileExportPath: configName === interfaceFile.configName
+                fileExportPathToShowToUser: configName === interfaceFile.configName
                     ? []
                     : // Side-effect config (e.g. `export { frontmatter }` of .md files)
                         [configName]
@@ -546,51 +565,61 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
     if (!importData)
         return null;
     const { importPath, exportName } = importData;
-    const filePathAbsolute = resolveImportPath(importData, importerFilePath);
-    assertFileEnv(filePathAbsolute ?? importPath, configEnv, configName);
-    const fileExportPath = exportName === 'default' || exportName === configName ? [] : [exportName];
+    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
+    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
+    const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
     if (importPath.startsWith('.')) {
         // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
         // ```
         // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
         // ```
-        assertImportPath(filePathAbsolute, importData, importerFilePath);
-        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, importerFilePath, userRootDir);
-        return {
-            exportName,
-            fileExportPath,
-            filePathAbsolute,
+        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
+        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
+        const filePath = {
+            filePathAbsoluteFilesystem,
             filePathRelativeToUserRootDir,
+            filePathAbsoluteVite: filePathRelativeToUserRootDir,
+            filePathToShowToUser: filePathRelativeToUserRootDir,
             importPathAbsolute: null
         };
+        return {
+            ...filePath,
+            fileExportName: exportName,
+            fileExportPathToShowToUser
+        };
     }
     else {
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        return {
-            exportName,
-            fileExportPath,
-            filePathAbsolute,
+        const filePath = {
+            filePathAbsoluteFilesystem,
             filePathRelativeToUserRootDir: null,
+            filePathAbsoluteVite: importPath,
+            filePathToShowToUser: importPath,
             importPathAbsolute: importPath
         };
+        return {
+            ...filePath,
+            fileExportName: exportName,
+            fileExportPathToShowToUser
+        };
     }
 }
-function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, configFilePath, userRootDir) {
+function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
     assertPosixPath(userRootDir);
     let filePathRelativeToUserRootDir;
-    if (filePathAbsolute.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsolute, userRootDir);
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
     }
     else {
-        assertUsage(false, `${getFilePathToShowToUser(configFilePath)} imports from a relative path ${pc.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
+        assertUsage(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${pc.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
         // None of the following works. Seems to be a Vite bug?
         // /*
-        // assert(filePathAbsolute.startsWith('/'))
-        // filePath = `/@fs${filePathAbsolute}`
+        // assert(filePathAbsoluteFilesystem.startsWith('/'))
+        // filePath = `/@fs${filePathAbsoluteFilesystem}`
         // /*/
-        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute)
+        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
         // assert(filePathRelativeToUserRootDir.startsWith('../'))
         // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
         // //*/
@@ -599,11 +628,11 @@ function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, c
     assert(filePathRelativeToUserRootDir.startsWith('/'));
     return filePathRelativeToUserRootDir;
 }
-function getVitePathFromAbsolutePath(filePathAbsolute, root) {
-    assertPosixPath(filePathAbsolute);
+function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
+    assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(root);
-    assert(filePathAbsolute.startsWith(root));
-    let vitePath = path.posix.relative(root, filePathAbsolute);
+    assert(filePathAbsoluteFilesystem.startsWith(root));
+    let vitePath = path.posix.relative(root, filePathAbsoluteFilesystem);
     assert(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
     vitePath = '/' + vitePath;
     return vitePath;
@@ -616,9 +645,17 @@ function getConfigDefinitions(interfaceFilesRelevant) {
             if (!configMeta)
                 return;
             const meta = configMeta.configValue;
-            assertMetaValue(meta, 
-            // Maybe we should use the getConfigDefinedAtString() helper?
-            `Config ${pc.cyan('meta')} defined at ${getFilePathToShowToUser(interfaceFile.filePath)}`);
+            assertMetaValue(meta, `Config ${pc.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
+            // Set configDef._userEffectDefinedAt
+            Object.entries(meta).forEach(([configName, configDef]) => {
+                if (!configDef.effect)
+                    return;
+                assert(interfaceFile.isConfigFile);
+                configDef._userEffectDefinedAt = {
+                    ...interfaceFile.filePath,
+                    fileExportPathToShowToUser: ['default', 'meta', configName, 'effect']
+                };
+            });
             objectEntries(meta).forEach(([configName, configDefinition]) => {
                 // User can override an existing config definition
                 configDefinitions[configName] = {
@@ -631,9 +668,15 @@ function getConfigDefinitions(interfaceFilesRelevant) {
     return configDefinitions;
 }
 function assertMetaValue(metaVal, configMetaDefinedAt) {
-    assertUsage(isObject(metaVal), `${configMetaDefinedAt} has an invalid type ${pc.cyan(typeof metaVal)}: it should be an object instead.`);
+    if (!isObject(metaVal)) {
+        assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
+        assertUsage(false, `${configMetaDefinedAt} has an invalid type ${pc.cyan(typeof metaVal)}: it should be an object instead.`);
+    }
     objectEntries(metaVal).forEach(([configName, def]) => {
-        assertUsage(isObject(def), `${configMetaDefinedAt} sets meta.${configName} to a value with an invalid type ${pc.cyan(typeof def)}: it should be an object instead.`);
+        if (!isObject(def)) {
+            assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
+            assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}`)} to a value with an invalid type ${pc.cyan(typeof def)}: it should be an object instead.`);
+        }
         // env
         {
             const envValues = [
@@ -642,19 +685,34 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
                 'server-and-client',
                 'config-only'
             ];
-            const hint = [
-                `Set the value of ${pc.cyan('env')} to `,
+            const fix = [
+                `Set the value of ${pc.cyan(`meta.${configName}.env`)} to `,
                 joinEnglish(envValues.map((s) => pc.cyan(`'${s}'`)), 'or'),
                 '.'
             ].join('');
-            assertUsage('env' in def, `${configMetaDefinedAt} doesn't set meta.${configName}.env but it's required. ${hint}`);
-            assertUsage(hasProp(def, 'env', 'string'), `${configMetaDefinedAt} sets meta.${configName}.env to an invalid type ${pc.cyan(typeof def.env)}. ${hint}`);
-            assertUsage(envValues.includes(def.env), `${configMetaDefinedAt} sets meta.${configName}.env to an invalid value ${pc.cyan(`'${def.env}'`)}. ${hint}`);
+            if (!('env' in def)) {
+                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
+                assertUsage(false, `${configMetaDefinedAt} doesn't set ${pc.cyan(`meta.${configName}.env`)} but it's required. ${fix}`);
+            }
+            if (!hasProp(def, 'env', 'string')) {
+                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
+                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.env`)} to an invalid type ${pc.cyan(typeof def.env)}. ${fix}`);
+            }
+            if (!envValues.includes(def.env)) {
+                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
+                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.env`)} to an unknown value ${pc.cyan(`'${def.env}'`)}. ${fix}`);
+            }
         }
         // effect
         if ('effect' in def) {
-            assertUsage(hasProp(def, 'effect', 'function'), `${configMetaDefinedAt} sets meta.${configName}.effect to an invalid type ${pc.cyan(typeof def.effect)}: it should be a function instead`);
-            assertUsage(def.env === 'config-only', `${configMetaDefinedAt} sets meta.${configName}.effect but it's only supported if meta.${configName}.env is ${pc.cyan('config-only')} (but it's ${pc.cyan(def.env)} instead)`);
+            if (!hasProp(def, 'effect', 'function')) {
+                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
+                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} to an invalid type ${pc.cyan(typeof def.effect)}: it should be a function instead`);
+            }
+            if (def.env !== 'config-only') {
+                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
+                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env is ${pc.cyan('config-only')} (but it's ${pc.cyan(def.env)} instead)`);
+            }
         }
     });
 }
@@ -665,7 +723,7 @@ function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
         // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
         // (We could support effect for non config-only by always loading its value at config time, regardless of the config's `env` value.)
         assertUsage(configDef.env === 'config-only', [
-            `Cannot add effect to ${pc.cyan(configName)} because its ${pc.cyan('env')} is ${pc.cyan(configDef.env)}: effects can only be added to configs with an env that is ${pc.cyan('config-only')}.`
+            `Cannot add effect to ${pc.cyan(configName)} because its ${pc.cyan('env')} is ${pc.cyan(configDef.env)}: effects can only be added to configs with an ${pc.cyan('env')} value of ${pc.cyan('config-only')}.`
         ].join(' '));
         const source = configValueSources[configName]?.[0];
         if (!source)
@@ -675,19 +733,28 @@ function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
         // Call effect
         const configModFromEffect = configDef.effect({
             configValue: source.value,
-            configDefinedAt: getConfigSourceDefinedAtString(configName, source)
+            configDefinedAt: getConfigDefinedAtString('Config', configName, source)
         });
         if (!configModFromEffect)
             return;
         assert(hasProp(source, 'value')); // We need to assume that the config value is loaded at build-time
-        applyEffect(configModFromEffect, source, configValueSources);
+        applyEffect(configModFromEffect, configValueSources, configDef);
     });
 }
-function applyEffect(configModFromEffect, configValueEffectSource, configValueSources) {
+function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
     const notSupported = `Effects currently only supports modifying the the ${pc.cyan('env')} of a config.`;
     objectEntries(configModFromEffect).forEach(([configName, configValue]) => {
         if (configName === 'meta') {
-            assertMetaValue(configValue, getConfigSourceDefinedAtString(configName, configValueEffectSource, true));
+            let configDefinedAtString;
+            if (configDefEffect._userEffectDefinedAt) {
+                configDefinedAtString = getConfigDefinedAtString('Config', configName, {
+                    definedAt: configDefEffect._userEffectDefinedAt
+                });
+            }
+            else {
+                configDefinedAtString = null;
+            }
+            assertMetaValue(configValue, configDefinedAtString);
             objectEntries(configValue).forEach(([configTargetName, configTargetDef]) => {
                 {
                     const keys = Object.keys(configTargetDef);
@@ -705,7 +772,7 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
         else {
             assertUsage(false, notSupported);
             // If we do end implementing being able to set the value of a config:
-            //  - For setting definedAtInfo: we could take the definedAtInfo of the effect config while appending '(effect)' to definedAtInfo.fileExportPath
+            //  - For setting definedAt: we could take the definedAt of the effect config while appending '(effect)' to definedAt.fileExportPathToShowToUser
         }
     });
 }
@@ -756,20 +823,29 @@ async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
     const plusFiles = result.map((p) => {
         p = toPosixPath(p);
         const filePathRelativeToUserRootDir = path.posix.join('/', p);
-        const filePathAbsolute = path.posix.join(userRootDir, p);
-        return { filePathRelativeToUserRootDir, filePathAbsolute };
+        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, p);
+        return {
+            filePathRelativeToUserRootDir,
+            filePathAbsoluteVite: filePathRelativeToUserRootDir,
+            filePathAbsoluteFilesystem,
+            filePathToShowToUser: filePathRelativeToUserRootDir,
+            importPathAbsolute: null
+        };
     });
+    // TODO/v1-release: remove
     extensions.forEach((extension) => {
         extension.pageConfigsDistFiles?.forEach((pageConfigDistFile) => {
-            // TODO/v1-release: remove
             if (!pageConfigDistFile.importPath.includes('+'))
                 return;
             assert(pageConfigDistFile.importPath.includes('+'));
             assert(path.posix.basename(pageConfigDistFile.importPath).startsWith('+'));
             const { importPath, filePath } = pageConfigDistFile;
             plusFiles.push({
-                filePathRelativeToUserRootDir: importPath,
-                filePathAbsolute: filePath
+                filePathRelativeToUserRootDir: null,
+                filePathAbsoluteVite: importPath,
+                filePathAbsoluteFilesystem: filePath,
+                filePathToShowToUser: importPath,
+                importPathAbsolute: importPath
             });
         });
     });
@@ -799,12 +875,12 @@ function assertNoUnexpectedPlusSign(filePath, fileName) {
     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`);
 }
 async function loadConfigFile(configFilePath, userRootDir, visited) {
-    const { filePathAbsolute } = configFilePath;
-    assertNoInfiniteLoop(visited, filePathAbsolute);
+    const { filePathAbsoluteFilesystem } = configFilePath;
+    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
     const { fileExports } = await transpileAndExecuteFile(configFilePath, false, userRootDir);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
         ...visited,
-        filePathAbsolute
+        filePathAbsoluteFilesystem
     ]);
     const configFile = {
         fileExports,
@@ -813,31 +889,31 @@ async function loadConfigFile(configFilePath, userRootDir, visited) {
     };
     return { configFile, extendsConfigs };
 }
-function assertNoInfiniteLoop(visited, filePathAbsolute) {
-    const idx = visited.indexOf(filePathAbsolute);
+function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
+    const idx = visited.indexOf(filePathAbsoluteFilesystem);
     if (idx === -1)
         return;
     const loop = visited.slice(idx);
-    assert(loop[0] === filePathAbsolute);
-    assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsolute].join('>')}`);
+    assert(loop[0] === filePathAbsoluteFilesystem);
+    assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
 }
 async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
     const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsImportData.map((importData) => {
         const { importPath: importPath } = importData;
-        // TODO
-        //  - validate extends configs
-        const filePathAbsolute = resolveImportPath(importData, configFilePath);
-        assertImportPath(filePathAbsolute, importData, configFilePath);
-        assertExtendsImportPath(importPath, filePathAbsolute, configFilePath);
+        const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
+        assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
+        assertExtendsImportPath(importPath, filePathAbsoluteFilesystem, configFilePath);
         // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsolute for added clarity
-        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir);
+        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
+        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
+        const filePathAbsoluteVite = filePathRelativeToUserRootDir ?? importPath;
         extendsConfigFiles.push({
-            filePathAbsolute,
-            // TODO: fix type cast
-            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
+            filePathAbsoluteFilesystem,
+            filePathAbsoluteVite,
+            filePathRelativeToUserRootDir,
+            filePathToShowToUser: filePathAbsoluteVite,
             importPathAbsolute: importPath
         });
     });
@@ -847,16 +923,16 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         extendsConfigs.push(result.configFile);
         extendsConfigs.push(...result.extendsConfigs);
     }));
-    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsolute);
+    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }
-function determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir) {
-    assertPosixPath(filePathAbsolute);
+function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
+    assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(userRootDir);
-    if (!filePathAbsolute.startsWith(userRootDir)) {
+    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         return null;
     }
-    let filePathRelativeToUserRootDir = filePathAbsolute.slice(userRootDir.length);
+    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
     if (!filePathRelativeToUserRootDir.startsWith('/'))
         filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
     return filePathRelativeToUserRootDir;
@@ -873,14 +949,14 @@ function assertExtendsImportPath(importPath, filePath, configFilePath) {
         });
     }
     else {
-        assertWarning(false, `${getFilePathToShowToUser(configFilePath)} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this feature.`, { onlyOnce: true });
+        assertWarning(false, `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this feature.`, { onlyOnce: true });
     }
 }
 function getExtendsImportData(configFileExports, configFilePath) {
-    const filePathToShowToUser = getFilePathToShowToUser(configFilePath);
+    const { filePathToShowToUser } = configFilePath;
     assertExportsOfConfigFile(configFileExports, filePathToShowToUser);
     const defaultExports = configFileExports.default;
-    const wrongUsage = `${filePathToShowToUser} sets the config 'extends' to an invalid value, see https://vike.dev/extends`;
+    const wrongUsage = `${filePathToShowToUser} sets the config ${pc.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
     let extendList;
     if (!('extends' in defaultExports)) {
         return [];
@@ -901,38 +977,6 @@ function getExtendsImportData(configFileExports, configFilePath) {
     });
     return extendsImportData;
 }
-// TODO: re-use this
-function handleUserFileError(err, isDev) {
-    // Properly handle error during transpilation so that we can use assertUsage() during transpilation
-    if (isDev) {
-        throw err;
-    }
-    else {
-        // Avoid ugly error format:
-        // ```
-        // [vike:importUserCode] Could not load virtual:vike:importUserCode:server: [vike@0.4.70][Wrong Usage] /pages/+config.ts sets the config 'onRenderHtml' to the value './+config/onRenderHtml-i-dont-exist.js' but no file was found at /home/rom/code/vike/examples/v1/pages/+config/onRenderHtml-i-dont-exist.js
-        // Error: [vike@0.4.70][Wrong Usage] /pages/+config.ts sets the config 'onRenderHtml' to the value './+config/onRenderHtml-i-dont-exist.js' but no file was found at /home/rom/code/vike/examples/v1/pages/+config/onRenderHtml-i-dont-exist.js
-        //     at ...
-        //     at ...
-        //     at ...
-        //     at ...
-        //     at ...
-        //     at ...
-        //   code: 'PLUGIN_ERROR',
-        //   plugin: 'vike:importUserCode',
-        //   hook: 'load',
-        //   watchFiles: [
-        //     '/home/rom/code/vike/vike/dist/esm/node/importBuild.js',
-        //     '\x00virtual:vike:importUserCode:server'
-        //   ]
-        // }
-        //  ELIFECYCLE  Command failed with exit code 1.
-        // ```
-        console.log('');
-        console.error(err);
-        process.exit(1);
-    }
-}
 function isGlobalConfig(configName) {
     if (configName === 'prerender')
         return false;
@@ -942,15 +986,15 @@ function isGlobalConfig(configName) {
 function getConfigNamesGlobal() {
     return Object.keys(configDefinitionsBuiltInGlobal);
 }
-function assertConfigExists(configName, configNamesRelevant, definedByFile) {
+function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
     const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
     if (configNames.includes(configName))
         return;
-    handleUnknownConfig(configName, configNames, definedByFile);
+    handleUnknownConfig(configName, configNames, filePathToShowToUser);
     assert(false);
 }
-function handleUnknownConfig(configName, configNames, definedByFile) {
-    let errMsg = `${definedByFile} defines an unknown config ${pc.cyan(configName)}`;
+function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
+    let errMsg = `${filePathToShowToUser} defines an unknown config ${pc.cyan(configName)}`;
     let configNameSimilar = null;
     if (configName === 'page') {
         configNameSimilar = 'Page';
@@ -982,11 +1026,11 @@ function determineRouteFilesystem(locationId, configValueSources) {
     if (configFilesystemRoutingRoot) {
         const routingRoot = getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName);
         if (routingRoot) {
-            const { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt } = routingRoot;
+            const { filesystemRoutingRootEffect /*, filesystemRoutingRootDefinedAt*/ } = routingRoot;
             const debugInfo = { locationId, routeFilesystem: filesystemRouteString, configFilesystemRoutingRoot };
             assert(filesystemRouteString.startsWith(filesystemRoutingRootEffect.before), debugInfo);
             filesystemRouteString = applyFilesystemRoutingRootEffect(filesystemRouteString, filesystemRoutingRootEffect);
-            filesystemRouteDefinedBy = `${filesystemRouteDefinedBy} (with ${filesystemRoutingRootDefinedAt})`;
+            // filesystemRouteDefinedBy = `${filesystemRouteDefinedBy} (with ${filesystemRoutingRootDefinedAt})`
         }
     }
     assert(filesystemRouteString.startsWith('/'));
@@ -1001,10 +1045,10 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     assert('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    const configDefinedAt = getConfigSourceDefinedAtString(configName, configFilesystemRoutingRoot);
+    const configDefinedAt = getConfigDefinedAtString('Config', configName, configFilesystemRoutingRoot);
     assertUsage(typeof value === 'string', `${configDefinedAt} should be a string`);
     assertUsage(value.startsWith('/'), `${configDefinedAt} is ${pc.cyan(value)} but it should start with a leading slash ${pc.cyan('/')}`);
-    const { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAtInfo;
+    const { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAt;
     assert(filePathRelativeToUserRootDir);
     const before = getFilesystemRouteString(getLocationId(filePathRelativeToUserRootDir));
     const after = value;
@@ -1016,17 +1060,17 @@ function determineIsErrorPage(routeFilesystem) {
     return routeFilesystem.split('/').includes('_error');
 }
 function resolveImportPath(importData, importerFilePath) {
-    const importerFilePathAbsolute = importerFilePath.filePathAbsolute;
+    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     assertPosixPath(importerFilePathAbsolute);
     const cwd = path.posix.dirname(importerFilePathAbsolute);
-    // filePathAbsolute is expected to be null when importData.importPath is a Vite path alias
-    const filePathAbsolute = requireResolve(importData.importPath, cwd);
-    return filePathAbsolute;
+    // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
+    return filePathAbsoluteFilesystem;
 }
-function assertImportPath(filePathAbsolute, importData, importerFilePath) {
+function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
     const { importPath: importPath, importStringWasGenerated, importString } = importData;
-    const filePathToShowToUser = getFilePathToShowToUser(importerFilePath);
-    if (!filePathAbsolute) {
+    const { filePathToShowToUser } = importerFilePath;
+    if (!filePathAbsoluteFilesystem) {
         const importPathString = pc.cyan(`'${importPath}'`);
         const errIntro = importStringWasGenerated
             ? `The import path ${importPathString} in ${filePathToShowToUser}`
@@ -1068,7 +1112,6 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
             configValues[configName] = {
                 value,
                 definedAt: {
-                    isCumulative: true,
                     files: sources.map((source) => getDefinedAtFile(source))
                 }
             };
@@ -1076,18 +1119,23 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
     });
     return configValues;
 }
+function getDefinedAtFile(configValueSource) {
+    return {
+        filePathToShowToUser: configValueSource.definedAt.filePathToShowToUser,
+        fileExportPathToShowToUser: configValueSource.definedAt.fileExportPathToShowToUser
+    };
+}
+function getDefinedAt(configValueSource) {
+    return getDefinedAtFile(configValueSource);
+}
 function mergeCumulative(configName, configValueSources) {
     const valuesArr = [];
     const valuesSet = [];
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
-        const configDefinedAt = getConfigSourceDefinedAtString(configName, configValueSource);
-        const configNameColored = pc.cyan(configName);
-        // We could, in principle, also support cumulative values to be defined in +${configName}.js but it ins't completely trivial to implement
-        assertUsage('value' in configValueSource, `${configDefinedAt} is only allowed to be defined in a +config.h.js file. (Because the values of ${configNameColored} are cumulative.)`);
-        /* This is more confusing than adding value. For example, this explanation shouldn't be shown for the passToClient config.
-        const explanation = `(Because the values of ${configNameColored} are cumulative and therefore merged together.)` as const
-        */
+        const configDefinedAt = getConfigDefinedAtString('Config', configName, configValueSource);
+        // We could, in principle, also support cumulative for values that aren't loaded at config-time but it isn't completely trivial to implement.
+        assert('value' in configValueSource);
         // Make sure configValueSource.value is serializable
         getConfigValueSerialized(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {
@@ -1099,7 +1147,7 @@ function mergeCumulative(configName, configValueSources) {
             if (vals2.length === 0)
                 return;
             assert(configValueSourcePrevious);
-            const configPreviousDefinedAt = getConfigSourceDefinedAtString(configName, configValueSourcePrevious, undefined, false);
+            const configPreviousDefinedAt = getConfigDefinedAtString('Config', configName, configValueSourcePrevious);
             assertUsage(false, `${configDefinedAt} sets ${t1} but another ${configPreviousDefinedAt} sets ${t2} which is forbidden: the values must be all arrays or all sets (you cannot mix).`);
         };
         const { value } = configValueSource;
@@ -1130,30 +1178,3 @@ function mergeCumulative(configName, configValueSources) {
     }
     assert(false);
 }
-// TODO: rename
-// TODO: refactor
-function getConfigSourceDefinedAtString(configName, { definedAtInfo }, isEffect = undefined, sentenceBegin = true) {
-    return getConfigDefinedAtString(configName, {
-        definedAt: {
-            isEffect,
-            file: {
-                filePathToShowToUser: getDefinedAtFilePathToShowToUser(definedAtInfo),
-                fileExportPath: definedAtInfo.fileExportPath
-            }
-        }
-    }, sentenceBegin);
-}
-function getDefinedAtFilePathToShowToUser(definedAtInfo) {
-    return definedAtInfo.filePathRelativeToUserRootDir ?? definedAtInfo.importPathAbsolute;
-}
-function getDefinedAtFile(source) {
-    return {
-        filePathToShowToUser: getDefinedAtFilePathToShowToUser(source.definedAtInfo),
-        fileExportPath: source.definedAtInfo.fileExportPath
-    };
-}
-function getDefinedAt(configValueSource) {
-    return {
-        file: getDefinedAtFile(configValueSource)
-    };
-}