vike 0.4.143-commit-dc6fea0 → 0.4.143-commit-fa295e1

package/dist/cjs/shared/hooks/getHook.js

@@ -11,7 +11,9 @@ function getHook(pageContext, hookName) {
     (0, utils_js_1.assert)(file.exportValue === hookFn);
     if (hookFn === null)
         return null;
-    const hookFilePath = file.exportSource;
+    const hookFilePath = file.filePath;
+    (0, utils_js_1.assert)(hookFilePath);
+    (0, utils_js_1.assert)(!hookFilePath.endsWith(' '));
     assertHookFn(hookFn, { hookName, hookFilePath });
     return { hookFn, hookName, hookFilePath };
 }

package/dist/cjs/shared/page-configs/getExportPath.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExportPath = void 0;
 const utils_js_1 = require("../utils.js");
-// TODO: return null instead of 'export default'
-//  - Also return null insead of 'export *'?
 function getExportPath(fileExportPath) {
+    if (!fileExportPath)
+        return null;
     let prefix = '';
     let suffix = '';
     let [exportName, ...exportObjectPath] = fileExportPath;

package/dist/cjs/shared/page-configs/parseConfigValuesImported.js

@@ -9,15 +9,18 @@ const assertExports_js_1 = require("./assertExports.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function parseConfigValuesImported(configValuesImported) {
     const configValues = {};
-    const addConfigValue = (configName, value, filePath, exportName) => {
+    const addConfigValue = (configName, value, importPath, exportName) => {
         configValues[configName] = {
             value,
-            definedAtInfo: {
-                filePath,
-                fileExportPath: [exportName]
+            definedAt: {
+                source: {
+                    // importPath is always relative the user's root directory (it cannot be relative to the current file since the current file is a virtual file)
+                    filePathToShowToUser: importPath,
+                    fileExportPath: [exportName]
+                }
             }
         };
-        assertIsNotNull(value, configName, filePath);
+        assertIsNotNull(value, configName, importPath);
     };
     configValuesImported.forEach((configValueLoaded) => {
         if (configValueLoaded.isValueFile) {

package/dist/cjs/shared/page-configs/utils.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefinedAtString = exports.getConfigDefinedAtInfo = exports.getConfigDefinedAtString = exports.getPageConfig = exports.getConfigValue = void 0;
+exports.getHookFilePathToShowToUser = exports.getConfigValueFilePathToShowToUser = exports.getDefinedAtString = exports.getConfigDefinedAtString = exports.getPageConfig = exports.getConfigValue = void 0;
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getExportPath_js_1 = require("./getExportPath.js");
@@ -12,33 +12,30 @@ function getConfigValue(pageConfig, configName, type) {
     const configValue = getConfigValueEntry(pageConfig, configName);
     if (configValue === null)
         return null;
-    const { value, definedAtInfo } = configValue;
+    const { value, definedAt } = configValue;
     if (type)
-        assertConfigValueType(value, type, configName, definedAtInfo);
-    return { value };
+        assertConfigValueType(value, type, configName, definedAt);
+    return configValue;
 }
 exports.getConfigValue = getConfigValue;
-function getConfigDefinedAtInfo(pageConfig, configName) {
-    const configValue = getConfigValueEntry(pageConfig, configName);
-    // We assume the caller to have ensured that the config value exists prior to calling getConfigDefinedAtInfo()
-    (0, utils_js_1.assert)(configValue);
-    const { definedAtInfo } = configValue;
-    // definedAtInfo is available only for config values that aren't:
-    //  - computed, nor
-    //  - cumulative
-    (0, utils_js_1.assert)(definedAtInfo);
-    return definedAtInfo;
+function assertConfigValueType(value, type, configName, definedAt) {
+    (0, utils_js_1.assert)(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
+    const problem = valuePrintable !== null ? `value ${picocolors_1.default.cyan(valuePrintable)}` : `type ${picocolors_1.default.cyan(typeActual)}`;
+    const configDefinedAt = getConfigDefinedAtString(configName, { definedAt }, true);
+    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`);
 }
-exports.getConfigDefinedAtInfo = getConfigDefinedAtInfo;
 function getConfigValueEntry(pageConfig, configName) {
     const configValue = pageConfig.configValues[configName];
     if (!configValue)
         return null;
-    const { value, definedAtInfo } = configValue;
     // Enable users to suppress global config values by setting the local config value to null
-    if (value === null)
+    if (configValue.value === null)
         return null;
-    return { value, definedAtInfo };
+    return configValue;
 }
 function getPageConfig(pageId, pageConfigs) {
     const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
@@ -47,34 +44,61 @@ function getPageConfig(pageId, pageConfigs) {
     return pageConfig;
 }
 exports.getPageConfig = getPageConfig;
-function assertConfigValueType(value, type, configName, definedAtInfo) {
-    (0, utils_js_1.assert)(value !== null);
-    const typeActual = typeof value;
-    if (typeActual === type)
-        return;
-    const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
-    const problem = valuePrintable !== null ? `value ${picocolors_1.default.cyan(valuePrintable)}` : `type ${picocolors_1.default.cyan(typeActual)}`;
-    const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo }, true);
-    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`);
-}
-function getConfigDefinedAtString(configName, { definedAtInfo }, sentenceBegin, append) {
-    let configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)}`;
-    if (definedAtInfo !== null) {
-        configDefinedAt = `${configDefinedAt} defined at ${getDefinedAtString(definedAtInfo, append)}`;
-    }
+function getConfigDefinedAtString(configName, { definedAt }, sentenceBegin) {
+    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)} defined ${getSourceString(definedAt)}`;
     return configDefinedAt;
 }
 exports.getConfigDefinedAtString = getConfigDefinedAtString;
-function getDefinedAtString(definedAtInfo, append) {
-    const { filePath, fileExportPath } = definedAtInfo;
-    let definedAt = filePath;
-    const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPath);
-    if (exportPath) {
-        definedAt = `${definedAt} > ${picocolors_1.default.cyan(exportPath)}`;
+function getSourceString(definedAt) {
+    if (definedAt.isComputed) {
+        return 'internally';
     }
-    if (append) {
-        definedAt = `${definedAt} > (${picocolors_1.default.blue(append)})`;
+    let sources;
+    if (definedAt.isCumulative) {
+        sources = definedAt.sources;
     }
-    return definedAt;
+    else {
+        sources = [definedAt.source];
+    }
+    (0, utils_js_1.assert)(sources.length >= 1);
+    const sourceString = sources
+        .map((source) => {
+        const { filePathToShowToUser, fileExportPath } = source;
+        let s = filePathToShowToUser;
+        const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPath);
+        if (exportPath) {
+            s = `${s} > ${picocolors_1.default.cyan(exportPath)}`;
+        }
+        if (definedAt.isEffect) {
+            s = `${s} > (${picocolors_1.default.blue('effect')})`;
+        }
+        return s;
+    })
+        .join(' / ');
+    return `at ${sourceString}`;
+}
+function getDefinedAtString(configValue) {
+    let sourceString = getSourceString(configValue.definedAt);
+    if (sourceString.startsWith('at '))
+        sourceString = sourceString.slice('at '.length);
+    return sourceString;
 }
 exports.getDefinedAtString = getDefinedAtString;
+function getConfigValueFilePathToShowToUser({ definedAt }) {
+    // A unique file path only exists if the config value isn't cumulative nor computed:
+    //  - cumulative config values have multiple file paths
+    //  - computed values don't have any file path
+    if (definedAt.isComputed || definedAt.isCumulative)
+        return null;
+    const { source } = definedAt;
+    const { filePathToShowToUser } = source;
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getConfigValueFilePathToShowToUser = getConfigValueFilePathToShowToUser;
+function getHookFilePathToShowToUser({ definedAt }) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getHookFilePathToShowToUser = getHookFilePathToShowToUser;

package/dist/cjs/shared/route/loadPageRoutes.js

@@ -33,9 +33,8 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                 const configName = 'route';
                 const configValue = (0, utils_js_3.getConfigValue)(pageConfig, configName);
                 if (configValue) {
-                    const definedAtInfo = (0, utils_js_3.getConfigDefinedAtInfo)(pageConfig, configName);
                     const route = configValue.value;
-                    const definedAt = (0, utils_js_3.getDefinedAtString)(definedAtInfo);
+                    const definedAt = (0, utils_js_3.getDefinedAtString)(configValue);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,
@@ -141,10 +140,10 @@ function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
         if (pageConfigGlobal.configValues.onBeforeRoute?.value) {
-            const { value: hookFn, definedAtInfo } = pageConfigGlobal.configValues.onBeforeRoute;
-            // config.onBeforeRoute isn't a computed nor a cumulative config => definedAtInfo should always be defined
-            (0, utils_js_1.assert)(definedAtInfo);
-            const hookFilePath = definedAtInfo.filePath;
+            const configValue = pageConfigGlobal.configValues.onBeforeRoute;
+            const { value: hookFn } = configValue;
+            const hookFilePath = (0, utils_js_3.getHookFilePathToShowToUser)(configValue);
+            // TODO: use getConfigDefinedAtString()
             (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
             const onBeforeRouteHook = {
                 hookFilePath: hookFilePath,

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.143-commit-dc6fea0';
+const PROJECT_VERSION = '0.4.143-commit-fa295e1';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -22,7 +22,7 @@ async function determineOptimizeDeps(config, configVike, isDev) {
     */
     config.optimizeDeps.include = [...include, ...normalizeInclude(config.optimizeDeps.include)];
     config.optimizeDeps.entries = [...entries, ...normalizeEntries(config.optimizeDeps.entries)];
-    // console.log('config.optimizeDeps', config.optimizeDeps)
+    console.log('config.optimizeDeps', config.optimizeDeps);
 }
 async function getPageDeps(config, pageConfigs, isDev) {
     let entries = [];
@@ -32,37 +32,40 @@ async function getPageDeps(config, pageConfigs, isDev) {
         pageConfigs.forEach((pageConfig) => {
             const configValueSourcesRelevant = getConfigValueSourcesRelevant(pageConfig);
             configValueSourcesRelevant.forEach((configValueSource) => {
-                const { valueIsImportedAtRuntime, configEnv, definedAtInfo } = configValueSource;
-                if (!valueIsImportedAtRuntime)
+                if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                const { filePath } = definedAtInfo;
-                assert(filePath);
-                if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
+                if (configValueSource.isComputed)
                     return;
-                if (filePath.startsWith('/')) {
-                    // Is getFilePathAbsolute() really needed? This contradicts the code below that doesn't need getFilePathAbsolute().
-                    entries.push(getFilePathAbsolute(filePath, config));
+                const { definedAtInfo, configEnv } = configValueSource;
+                if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
-                }
-                // getVikeConfig() resolves relative import paths
-                assert(!filePath.startsWith('.'));
-                // We need to differentiate between npm package imports and path aliases.
-                // There are path aliases that cannot be distinguished from npm package names.
-                // We recommend users to use the '#' prefix convention for path aliases, see https://vike.dev/path-aliases#vite and assertResolveAlias()
-                if (isNpmPackageImport(filePath)) {
-                    // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
-                    assert(!filePath.startsWith('#'));
-                    include.push(filePath);
+                if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
+                    const { filePathAbsolute } = definedAtInfo;
+                    assert(filePathAbsolute);
+                    // Surpsingly Vite expects entries to be absolute paths
+                    entries.push(filePathAbsolute);
                 }
                 else {
-                    /* Path aliases, e.g.:
-                     * ```js
-                     * // /renderer/+config.js
-                     * import onRenderClient from '#root/renderer/onRenderClient'
-                     * ```
-                     * Does Vite resolve the path aliases or is getFilePathAbsolute() needed?
-                     */
-                    entries.push(filePath);
+                    // Adding definedAtInfo.filePathAbsolute doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    const { importPathAbsolute } = definedAtInfo;
+                    assert(importPathAbsolute);
+                    // We need to differentiate between npm package imports and path aliases.
+                    // There are path aliases that cannot be distinguished from npm package names.
+                    // We recommend users to use the '#' prefix convention for path aliases, see https://vike.dev/path-aliases#vite and assertResolveAlias()
+                    if (isNpmPackageImport(importPathAbsolute)) {
+                        // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
+                        assert(!importPathAbsolute.startsWith('#'));
+                        include.push(importPathAbsolute);
+                    }
+                    else {
+                        /* Path aliases, e.g.:
+                         * ```js
+                         * // /renderer/+config.js
+                         * import onRenderClient from '#root/renderer/onRenderClient'
+                         * ```
+                         */
+                        entries.push(importPathAbsolute);
+                    }
                 }
             });
         });

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

@@ -340,7 +340,9 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
             assert(!configValueSource.isComputed);
-            assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${configValueSource.definedAtInfo.filePath} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in vike's Vite plugin options instead.`, { onlyOnce: true });
+            const sourceFilePath = getFilePathToShowToUser2(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 });
             globalVikeConfig[configName] = configValueSource.value;
         }
     });
@@ -423,48 +425,48 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
         const configValueSourceWinner = getConfigValueSource(configName, interfaceFileWinner, configDef, userRootDir);
         const configValueSourceLoser = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
-        assertWarning(false, `${getConfigDefinedAtString(configName, configValueSourceLoser, true)} overriden by another ${getConfigDefinedAtString(configName, configValueSourceWinner, false)}, remove one of the two`, { onlyOnce: false });
+        assert(!configValueSourceLoser.isComputed);
+        assert(!configValueSourceWinner.isComputed);
+        assertWarning(false, `${getConfigSourceDefinedAtString(configName, configValueSourceLoser, undefined, true)} overriden by another ${getConfigSourceDefinedAtString(configName, configValueSourceWinner, undefined, false)}, remove one of the two`, { onlyOnce: false });
     });
 }
 function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
 function getConfigValueSource(configName, interfaceFile, configDef, userRootDir) {
-    // TODO: rethink file paths of ConfigElement
-    const filePathToShowToUser = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
     const conf = interfaceFile.configMap[configName];
     assert(conf);
     const configEnv = configDef.env;
-    const definedAtInfoConfigFile = {
-        filePath: filePathToShowToUser,
+    const definedAtConfigFile = {
+        ...interfaceFile.filePath,
         fileExportPath: ['default', configName]
     };
     if (configDef._valueIsFilePath) {
-        let filePath;
+        let definedAtInfo;
+        let valueFilePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
             const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-            const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo: definedAtInfoConfigFile }, true);
+            const configDefinedAt = getConfigSourceDefinedAtString(configName, { definedAtInfo: definedAtConfigFile });
             assertUsage(import_, `${configDefinedAt} should be an import`);
-            filePath = import_.filePathToShowToUser;
+            valueFilePath = import_.filePathRelativeToUserRootDir ?? import_.importPathAbsolute;
+            definedAtInfo = import_;
         }
         else {
             assert(interfaceFile.isValueFile);
-            filePath =
-                interfaceFile.filePath.filePathRelativeToUserRootDir ??
-                    // Experimental: is this needed? Would it work?
-                    interfaceFile.filePath.filePathAbsolute;
+            valueFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir;
+            definedAtInfo = {
+                ...interfaceFile.filePath,
+                fileExportPath: []
+            };
         }
         const configValueSource = {
-            value: filePath,
+            value: valueFilePath,
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
             isComputed: false,
-            definedAtInfo: {
-                filePath,
-                fileExportPath: []
-            }
+            definedAtInfo
         };
         return configValueSource;
     }
@@ -473,15 +475,11 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
         const { configValue } = conf;
         const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
-            const { filePathToShowToUser, fileExportName: exportName } = import_;
             const configValueSource = {
                 configEnv,
                 valueIsImportedAtRuntime: true,
                 isComputed: false,
-                definedAtInfo: {
-                    filePath: filePathToShowToUser,
-                    fileExportPath: [exportName]
-                }
+                definedAtInfo: import_
             };
             return configValueSource;
         }
@@ -491,23 +489,21 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
                 configEnv,
                 valueIsImportedAtRuntime: false,
                 isComputed: false,
-                definedAtInfo: definedAtInfoConfigFile
+                definedAtInfo: definedAtConfigFile
             };
             return configValueSource;
         }
     }
     else if (interfaceFile.isValueFile) {
         // TODO: rethink file paths of ConfigElement
-        const importPath = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
-        const exportName = configName === interfaceFile.configName ? 'default' : configName;
         const valueAlreadyLoaded = 'configValue' in conf;
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             isComputed: false,
             definedAtInfo: {
-                filePath: importPath,
-                fileExportPath: [exportName]
+                ...interfaceFile.filePath,
+                fileExportPath: configName === interfaceFile.configName ? [] : [configName]
             }
         };
         if (valueAlreadyLoaded) {
@@ -556,7 +552,8 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         return null;
     const { importPath, exportName } = importData;
     const filePathAbsolute = resolveImportPath(importData, importerFilePath);
-    let filePathToShowToUser;
+    assertFileEnv(filePathAbsolute ?? importPath, configEnv, configName);
+    const fileExportPath = 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:
         // ```
@@ -564,22 +561,26 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // ```
         assertImportPath(filePathAbsolute, importData, importerFilePath);
         const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, importerFilePath, userRootDir);
-        filePathToShowToUser = filePathRelativeToUserRootDir;
+        return {
+            exportName,
+            fileExportPath,
+            filePathAbsolute,
+            filePathRelativeToUserRootDir,
+            importPathAbsolute: null
+        };
     }
     else {
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        filePathToShowToUser = importPath;
-    }
-    {
-        const filePathForEnvCheck = filePathAbsolute ?? importPath;
-        assertFileEnv(filePathForEnvCheck, configEnv, configName);
+        return {
+            exportName,
+            fileExportPath,
+            filePathAbsolute,
+            filePathRelativeToUserRootDir: null,
+            importPathAbsolute: importPath
+        };
     }
-    return {
-        filePathToShowToUser,
-        fileExportName: exportName
-    };
 }
 function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, configFilePath, userRootDir) {
     assertPosixPath(userRootDir);
@@ -672,24 +673,26 @@ function applyEffects(pageConfig, configDefinitionsRelevant) {
             `Adding an effect to ${pc.cyan(configName)} may not work as expected because ${pc.cyan(configName)} has an ${pc.cyan('env')} that is different than ${pc.cyan('config-only')} (its env is ${pc.cyan(configDef.env)}).`,
             'Reach out to a maintainer if you want to use this in production.'
         ].join(' '), { onlyOnce: true });
-        const configValue = pageConfig.configValueSources[configName]?.[0];
-        if (!configValue)
+        const source = pageConfig.configValueSources[configName]?.[0];
+        if (!source)
             return;
+        assert(!source.isComputed);
         const configModFromEffect = configDef.effect({
-            configValue: configValue.value,
-            configDefinedAt: getConfigDefinedAtString(configName, configValue, true)
+            configValue: source.value,
+            configDefinedAt: getConfigSourceDefinedAtString(configName, source)
         });
         if (!configModFromEffect)
             return;
-        assert(hasProp(configValue, 'value')); // We need to assume that the config value is loaded at build-time
-        applyEffect(configModFromEffect, configValue, pageConfig.configValueSources);
+        assert(hasProp(source, 'value')); // We need to assume that the config value is loaded at build-time
+        applyEffect(configModFromEffect, source, pageConfig.configValueSources);
     });
 }
 function applyEffect(configModFromEffect, configValueEffectSource, configValueSources) {
     const notSupported = `config.meta[configName].effect currently only supports modifying the the ${pc.cyan('env')} of a config. Reach out to a maintainer if you need more capabilities.`;
     objectEntries(configModFromEffect).forEach(([configName, configValue]) => {
         if (configName === 'meta') {
-            assertMetaValue(configValue, getConfigDefinedAtString(configName, configValueEffectSource, true, 'effect'));
+            assert(!configValueEffectSource.isComputed);
+            assertMetaValue(configValue, getConfigSourceDefinedAtString(configName, configValueEffectSource, true));
             objectEntries(configValue).forEach(([configTargetName, configTargetDef]) => {
                 {
                     const keys = Object.keys(configTargetDef);
@@ -1001,11 +1004,13 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     assert('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    const configDefinedAt = getConfigDefinedAtString(configName, configFilesystemRoutingRoot, false);
+    assert(!configFilesystemRoutingRoot.isComputed);
+    const configDefinedAt = getConfigSourceDefinedAtString(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('/')}`);
     assert(!configFilesystemRoutingRoot.isComputed);
-    const before = getFilesystemRouteString(getLocationId(configFilesystemRoutingRoot.definedAtInfo.filePath));
+    assert(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir);
+    const before = getFilesystemRouteString(getLocationId(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
     return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
@@ -1050,10 +1055,11 @@ function getConfigValues(configValueSources, configDefinitionsRelevant) {
         if (!configDef.cumulative) {
             const configValueSource = sources[0];
             if ('value' in configValueSource) {
-                const { value, definedAtInfo } = configValueSource;
+                const { value } = configValueSource;
+                const definedAt = configValueSource.isComputed ? { isComputed: true } : getDefinedAt(configValueSource);
                 configValues[configName] = {
                     value,
-                    definedAtInfo
+                    definedAt
                 };
             }
         }
@@ -1061,7 +1067,10 @@ function getConfigValues(configValueSources, configDefinitionsRelevant) {
             const value = mergeCumulative(configName, sources);
             configValues[configName] = {
                 value,
-                definedAtInfo: null
+                definedAt: {
+                    isCumulative: true,
+                    sources: sources.map((source) => getSourceDefinedAt(source))
+                }
             };
         }
     });
@@ -1073,7 +1082,7 @@ function mergeCumulative(configName, configValueSources) {
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
         assert(!configValueSource.isComputed);
-        const configDefinedAt = getConfigDefinedAtString(configName, configValueSource, true);
+        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.)`);
@@ -1081,7 +1090,7 @@ function mergeCumulative(configName, configValueSources) {
         const explanation = `(Because the values of ${configNameColored} are cumulative and therefore merged together.)` as const
         */
         // Make sure configValueSource.value is serializable
-        getConfigValueSerialized(configValueSource.value, configName, configValueSource.definedAtInfo);
+        getConfigValueSerialized(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';
@@ -1091,7 +1100,8 @@ function mergeCumulative(configName, configValueSources) {
             if (vals2.length === 0)
                 return;
             assert(configValueSourcePrevious);
-            const configPreviousDefinedAt = getConfigDefinedAtString(configName, configValueSourcePrevious, false);
+            assert(!configValueSourcePrevious.isComputed);
+            const configPreviousDefinedAt = getConfigSourceDefinedAtString(configName, configValueSourcePrevious, undefined, true);
             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;
@@ -1122,3 +1132,46 @@ function mergeCumulative(configName, configValueSources) {
     }
     assert(false);
 }
+// TODO: rename
+// TODO: refactor
+function getConfigSourceDefinedAtString(configName, { definedAtInfo }, isEffect = undefined, sentenceBegin = true) {
+    return getConfigDefinedAtString(configName, {
+        definedAt: {
+            isEffect,
+            source: {
+                filePathToShowToUser: getFilePathToShowToUser2(definedAtInfo),
+                fileExportPath: definedAtInfo.fileExportPath
+            }
+        }
+    }, sentenceBegin);
+}
+// TODO: rename
+function getFilePathToShowToUser2(definedAtInfo) {
+    return definedAtInfo.filePathRelativeToUserRootDir ?? definedAtInfo.importPathAbsolute;
+    /*
+    if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
+      return definedAtInfo.filePathRelativeToUserRootDir
+    }
+    if (definedAtInfo.importPathAbsolute !== null) {
+      return definedAtInfo.importPathAbsolute
+    } else {
+      const filePathToShowToUser = definedAtInfo.filePathAbsolute
+      // TypeScript failes to infer that definedAtInfo.filePathAbsolute cannot be null
+      assert(filePathToShowToUser)
+      return filePathToShowToUser
+    }
+    */
+}
+// TODO: rename
+function getSourceDefinedAt(source) {
+    assert(!source.isComputed);
+    return {
+        filePathToShowToUser: getFilePathToShowToUser2(source.definedAtInfo),
+        fileExportPath: source.definedAtInfo.fileExportPath
+    };
+}
+function getDefinedAt(configValueSource) {
+    return {
+        source: getSourceDefinedAt(configValueSource)
+    };
+}