vike 0.4.142-commit-acfc159 → 0.4.143-commit-f03b42d

package/dist/cjs/node/plugin/index.js

@@ -54,7 +54,7 @@ function plugin(vikeConfig) {
 }
 exports.plugin = plugin;
 exports.ssr = plugin;
-// Enable `const ssr = require('vike/plugin')`.
+// Enable `const vike = require('vike/plugin')`.
 //  - This lives at the end of the file to ensure it happens after all assignments to `exports`.
 //  - This is only used for the CJS build; we wrap it in a try-catch for the ESM build.
 try {
@@ -65,6 +65,6 @@ catch { }
 Object.defineProperty(plugin, 'apply', {
     enumerable: true,
     get: () => {
-        (0, utils_js_1.assertUsage)(false, `Add ${picocolors_1.default.cyan('ssr()')} instead of ${picocolors_1.default.cyan('ssr')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
+        (0, utils_js_1.assertUsage)(false, `Add ${picocolors_1.default.cyan('vike()')} instead of ${picocolors_1.default.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });

package/dist/cjs/node/plugin/plugins/buildConfig.js

@@ -53,8 +53,10 @@ function buildConfig() {
         },
         async writeBundle(options, bundle) {
             const manifestEntry = bundle[manifestTempFile];
-            if (generateManifest) {
-                (0, utils_js_1.assert)(manifestEntry);
+            /* Fails with @vitejs/plugin-legacy because writeBundle() is called twice during the client build (once for normal client assets and a second time for legacy assets), see reproduction at https://github.com/vikejs/vike/issues/1154
+            assert(generateManifest === !!manifestEntry)
+            */
+            if (manifestEntry) {
                 const { dir } = options;
                 (0, utils_js_1.assert)(dir);
                 const manifestFilePathOld = path_1.default.join(dir, manifestEntry.fileName);
@@ -64,9 +66,6 @@ function buildConfig() {
                 const manifestFilePathNew = path_1.default.join(dir, '..', 'assets.json');
                 await promises_1.default.rename(manifestFilePathOld, manifestFilePathNew);
             }
-            else {
-                (0, utils_js_1.assert)(!manifestEntry);
-            }
         }
     };
 }

package/dist/cjs/node/plugin/plugins/commonConfig.js

@@ -19,12 +19,7 @@ function commonConfig() {
         {
             name: 'vike-commonConfig-1',
             config: () => ({
-                appType: 'custom',
-                ssr: {
-                    // Needed as long as Vike is published as CJS.
-                    // TODO: can we remove this once Vike is published as ESM?
-                    external: ['vike', 'vike/server']
-                }
+                appType: 'custom'
             }),
             configResolved(config) {
                 (0, require_shim_1.installRequireShim_setUserRootDir)(config.root);

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

@@ -4,7 +4,7 @@ exports.determineOptimizeDeps = void 0;
 const findPageFiles_js_1 = require("../../shared/findPageFiles.js");
 const utils_js_1 = require("../../utils.js");
 const getVikeConfig_js_1 = require("../importUserCode/v1-design/getVikeConfig.js");
-const getConfigValueSource_js_1 = require("../../shared/getConfigValueSource.js");
+const getConfigValueSourcesRelevant_js_1 = require("../../shared/getConfigValueSourcesRelevant.js");
 const buildConfig_js_1 = require("../buildConfig.js");
 const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
 async function determineOptimizeDeps(config, configVike, isDev) {
@@ -33,7 +33,7 @@ async function getPageDeps(config, pageConfigs, isDev) {
     // V1 design
     {
         pageConfigs.forEach((pageConfig) => {
-            const configValueSourcesRelevant = (0, getConfigValueSource_js_1.getConfigValueSourcesRelevant)(pageConfig);
+            const configValueSourcesRelevant = (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(pageConfig);
             configValueSourcesRelevant.forEach((configValueSource) => {
                 const { valueIsImportedAtRuntime, configEnv, definedAtInfo } = configValueSource;
                 if (!valueIsImportedAtRuntime)

package/dist/cjs/node/plugin/plugins/importUserCode/generateEagerImport.js

@@ -2,20 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateEagerImport = void 0;
 let varCounterGlobal = 0;
-function generateEagerImport(importPath, varCounter, importName) {
+/**
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ * We discard the information that the import variable is called `someImport` because we don't need it.
+ */
+function generateEagerImport(importPath, varCounter, exportName) {
     if (varCounter === undefined)
         varCounter = varCounterGlobal++;
-    const importVar = `import_${varCounter}`;
+    const importName = `import_${varCounter}`;
     const importLiteral = (() => {
-        if (!importName || importName === '*') {
-            return `* as ${importVar}`;
+        if (!exportName || exportName === '*') {
+            return `* as ${importName}`;
         }
-        if (importName === 'default') {
-            return importVar;
+        if (exportName === 'default') {
+            return importName;
         }
-        return `{ ${importName} as ${importVar} }`;
+        return `{ ${exportName} as ${importName} }`;
     })();
     const importStatement = `import ${importLiteral} from '${importPath}';`;
-    return { importVar, importStatement };
+    return { importName, importStatement };
 }
 exports.generateEagerImport = generateEagerImport;

package/dist/cjs/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -127,9 +127,9 @@ function addImport(importPath, fileType, exportNames, isBuild) {
             return `() => import('${importPath}${query}')`;
         }
         else {
-            const { importVar, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(`${importPath}${query}`);
+            const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(`${importPath}${query}`);
             fileContent += importStatement + '\n';
-            return importVar;
+            return importName;
         }
     })();
     fileContent += `${mapVar}['${importPath}'] = ${value};\n`;

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

@@ -18,16 +18,18 @@ const removeSuperfluousViteLog_js_1 = require("../../../shared/loggerVite/remove
 const getFilePathToShowToUser_js_1 = require("./getFilePathToShowToUser.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
+const assertExports_js_1 = require("../../../../../shared/page-configs/assertExports.js");
+const getVirtualFilePageConfigs_js_1 = require("./getVirtualFilePageConfigs.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
 exports.vikeConfigDependencies = vikeConfigDependencies;
-const codeFilesEnv = new Map();
+const filesEnv = new Map();
 function reloadVikeConfig(userRootDir, extensions) {
     vikeConfigDependencies.clear();
-    codeFilesEnv.clear();
+    filesEnv.clear();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, extensions, true);
     handleReloadSideEffects();
 }
@@ -101,27 +103,27 @@ async function loadInterfaceFiles(userRootDir, isDev, extensions) {
     }));
     // Value files
     await Promise.all(valueFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
-        const configNameDefault = getConfigName(filePathRelativeToUserRootDir);
-        (0, utils_js_1.assert)(configNameDefault);
+        const configName = getConfigName(filePathRelativeToUserRootDir);
+        (0, utils_js_1.assert)(configName);
         const interfaceFile = {
             filePath: {
                 filePathRelativeToUserRootDir,
                 filePathAbsolute
             },
             configMap: {
-                [configNameDefault]: {}
+                [configName]: {}
             },
             isConfigFile: false,
             isValueFile: true,
-            configNameDefault
+            configName
         };
         {
             // We don't have access to custom config definitions yet
-            //  - We load +someCustomConifg.js later
+            //  - We load +{configName}.js later
             //  - But we do need to eagerly load +meta.js (to get all the custom config definitions)
-            const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn, configNameDefault);
+            const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn, configName);
             if (configDef?.env === 'config-only') {
-                await loadValueFile(interfaceFile, configNameDefault, userRootDir);
+                await loadValueFile(interfaceFile, configName, userRootDir);
             }
         }
         {
@@ -141,14 +143,13 @@ function getConfigDefinition(configDefinitionsRelevant, configName, definedByFil
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-async function loadValueFile(interfaceValueFile, configNameDefault, userRootDir) {
+async function loadValueFile(interfaceValueFile, configName, userRootDir) {
     const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(interfaceValueFile.filePath, true, userRootDir);
-    (0, utils_js_1.assertDefaultExportUnknown)(fileExports, (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(interfaceValueFile.filePath));
-    Object.entries(fileExports).forEach(([configName, configValue]) => {
-        if (configName === 'default') {
-            configName = configNameDefault;
-        }
-        interfaceValueFile.configMap[configName] = { configValue };
+    const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(interfaceValueFile.filePath);
+    (0, assertExports_js_1.assertExportsOfValueFile)(fileExports, filePathToShowToUser, configName);
+    Object.entries(fileExports).forEach(([exportName, configValue]) => {
+        const configName_ = exportName === 'default' ? configName : exportName;
+        interfaceValueFile.configMap[configName_] = { configValue };
     });
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
@@ -161,8 +162,8 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
         isConfigExtend,
         extendsFilePaths
     };
-    const interfaceFilePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(filePath);
-    (0, utils_js_1.assertDefaultExportObject)(fileExports, interfaceFilePathToShowToUser);
+    const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(filePath);
+    (0, assertExports_js_1.assertExportsOfConfigFile)(fileExports, filePathToShowToUser);
     Object.entries(fileExports.default).forEach(([configName, configValue]) => {
         interfaceFile.configMap[configName] = { configValue };
     });
@@ -201,8 +202,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, extensions,
             const dummyData = {
                 pageConfigs: [],
                 pageConfigGlobal: {
-                    onPrerenderStart: null,
-                    onBeforeRoute: null
+                    configValueSources: {}
                 },
                 globalVikeConfig: {}
             };
@@ -222,18 +222,18 @@ async function loadVikeConfig(userRootDir, isDev, extensions) {
         await Promise.all(getInterfaceFileList(interfaceFilesRelevant).map(async (interfaceFile) => {
             if (!interfaceFile.isValueFile)
                 return;
-            const { configNameDefault } = interfaceFile;
-            if (isGlobalConfig(configNameDefault))
+            const { configName } = interfaceFile;
+            if (isGlobalConfig(configName))
                 return;
-            const configDef = getConfigDefinition(configDefinitionsRelevant, configNameDefault, (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(interfaceFile.filePath));
+            const configDef = getConfigDefinition(configDefinitionsRelevant, configName, (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(interfaceFile.filePath));
             if (configDef.env !== 'config-only')
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
             if (isAlreadyLoaded)
                 return;
             // Value files for built-in confg-only configs should have already been loaded at loadInterfaceFiles()
-            (0, utils_js_1.assert)(!(configNameDefault in configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn));
-            await loadValueFile(interfaceFile, configNameDefault, userRootDir);
+            (0, utils_js_1.assert)(!(configName in configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn));
+            await loadValueFile(interfaceFile, configName, userRootDir);
         }));
         const configValueSources = {};
         (0, utils_js_1.objectEntries)(configDefinitionsRelevant)
@@ -327,17 +327,16 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
     }
     const globalVikeConfig = {};
     const pageConfigGlobal = {
-        onBeforeRoute: null,
-        onPrerenderStart: null
+        configValueSources: {}
     };
     (0, utils_js_1.objectEntries)(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltInGlobal).forEach(([configName, configDef]) => {
         const sources = resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir);
         const configValueSource = sources?.[0];
         if (!configValueSource)
             return;
-        if ((0, utils_js_1.arrayIncludes)((0, utils_js_1.objectKeys)(pageConfigGlobal), configName)) {
+        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
             (0, utils_js_1.assert)(!('value' in configValueSource));
-            pageConfigGlobal[configName] = configValueSource;
+            pageConfigGlobal.configValueSources[configName] = [configValueSource];
         }
         else {
             (0, utils_js_1.assert)('value' in configValueSource);
@@ -370,7 +369,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             const interfaceValueFiles = interfaceFilesDefiningConfig
                 .filter((interfaceFile) => interfaceFile.isValueFile &&
                 // We consider side-effect exports (e.g. `export { frontmatter }` of .mdx files) later (i.e. with less priority)
-                interfaceFile.configNameDefault === configName)
+                interfaceFile.configName === configName)
                 .sort(makeOrderDeterministic);
             const interfaceConfigFiles = interfaceFilesDefiningConfig
                 .filter((interfaceFile) => interfaceFile.isConfigFile &&
@@ -380,9 +379,9 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             const interfaceValueFile = interfaceValueFiles[0];
             const interfaceConfigFile = interfaceConfigFiles[0];
             // Make this value:
-            //   /pages/some-page/+someConfig.js > `export default`
+            //   /pages/some-page/+{configName}.js > `export default`
             // override that value:
-            //   /pages/some-page/+config > `export default { someConfig }`
+            //   /pages/some-page/+config.h.js > `export default { someConfig }`
             const interfaceFileWinner = interfaceValueFile ?? interfaceConfigFile;
             if (interfaceFileWinner) {
                 const interfaceFilesOverriden = [...interfaceValueFiles, ...interfaceConfigFiles].filter((f) => f !== interfaceFileWinner);
@@ -397,7 +396,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
         interfaceFilesDefiningConfig
             .filter((interfaceFile) => interfaceFile.isValueFile &&
             // Is side-effect export
-            interfaceFile.configNameDefault !== configName)
+            interfaceFile.configName !== configName)
             .forEach((interfaceValueFileSideEffect) => {
             add(interfaceValueFileSideEffect);
         });
@@ -435,22 +434,22 @@ function isInterfaceFileUserLand(interfaceFile) {
 }
 function getConfigValueSource(configName, interfaceFile, configDef, userRootDir) {
     // TODO: rethink file paths of ConfigElement
-    const configFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
+    const filePathToShowToUser = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
     const conf = interfaceFile.configMap[configName];
     (0, utils_js_1.assert)(conf);
     const configEnv = configDef.env;
     const definedAtInfoConfigFile = {
-        filePath: configFilePath,
+        filePath: filePathToShowToUser,
         fileExportPath: ['default', configName]
     };
     if (configDef._valueIsFilePath) {
         let filePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
-            const import_ = getImport(configValue, interfaceFile.filePath, userRootDir);
+            const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
             const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, { definedAtInfo: definedAtInfoConfigFile }, true);
             (0, utils_js_1.assertUsage)(import_, `${configDefinedAt} should be an import`);
-            filePath = import_.importFilePath;
+            filePath = import_.filePathToShowToUser;
         }
         else {
             (0, utils_js_1.assert)(interfaceFile.isValueFile);
@@ -475,17 +474,16 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
     if (interfaceFile.isConfigFile) {
         (0, utils_js_1.assert)('configValue' in conf);
         const { configValue } = conf;
-        const import_ = getImport(configValue, interfaceFile.filePath, userRootDir);
+        const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
-            const { importFilePath, importFileExportName } = import_;
-            assertCodeFileEnv(importFilePath, configEnv, configName);
+            const { filePathToShowToUser, fileExportName: exportName } = import_;
             const configValueSource = {
                 configEnv,
                 valueIsImportedAtRuntime: true,
                 isComputed: false,
                 definedAtInfo: {
-                    filePath: importFilePath,
-                    fileExportPath: [importFileExportName]
+                    filePath: filePathToShowToUser,
+                    fileExportPath: [exportName]
                 }
             };
             return configValueSource;
@@ -503,16 +501,16 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
     }
     else if (interfaceFile.isValueFile) {
         // TODO: rethink file paths of ConfigElement
-        const importFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
-        const importFileExportName = configName === interfaceFile.configNameDefault ? 'default' : configName;
+        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: importFilePath,
-                fileExportPath: [importFileExportName]
+                filePath: importPath,
+                fileExportPath: [exportName]
             }
         };
         if (valueAlreadyLoaded) {
@@ -525,16 +523,17 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
     }
     (0, utils_js_1.assert)(false);
 }
-function assertCodeFileEnv(importFilePath, configEnv, configName) {
-    if (!codeFilesEnv.has(importFilePath)) {
-        codeFilesEnv.set(importFilePath, []);
+function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
+    (0, utils_js_1.assertPosixPath)(filePathForEnvCheck);
+    if (!filesEnv.has(filePathForEnvCheck)) {
+        filesEnv.set(filePathForEnvCheck, []);
     }
-    const codeFileEnv = codeFilesEnv.get(importFilePath);
-    codeFileEnv.push({ configEnv, configName });
-    const configDifferentEnv = codeFileEnv.filter((c) => c.configEnv !== configEnv)[0];
+    const fileEnv = filesEnv.get(filePathForEnvCheck);
+    fileEnv.push({ configEnv, configName });
+    const configDifferentEnv = fileEnv.filter((c) => c.configEnv !== configEnv)[0];
     if (configDifferentEnv) {
         (0, utils_js_1.assertUsage)(false, [
-            `${importFilePath} defines the value of configs living in different environments:`,
+            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
             ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.cyan(c.configEnv)}`),
             'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file/import-from-same-file'
         ].join('\n'));
@@ -552,53 +551,60 @@ function isDefiningPage(interfaceFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function getImport(configValue, configFilePath, userRootDir) {
+function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
         return null;
     const importData = (0, replaceImportStatements_js_1.parseImportData)(configValue);
     if (!importData)
         return null;
-    let { importFilePath, importFileExportName } = importData;
-    if (importFilePath.startsWith('.')) {
+    const { importPath, exportName } = importData;
+    const filePathAbsolute = resolveImportPath(importData, importerFilePath);
+    let filePathToShowToUser;
+    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?
         // ```
-        importFilePath = resolveRelativeCodeFilePath(importData, configFilePath, userRootDir);
+        assertImportPath(filePathAbsolute, importData, importerFilePath);
+        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, importerFilePath, userRootDir);
+        filePathToShowToUser = filePathRelativeToUserRootDir;
     }
     else {
-        // importFilePath can be:
+        // importPath can be:
         //  - an npm package import
         //  - a path alias
+        filePathToShowToUser = importPath;
+    }
+    {
+        const filePathForEnvCheck = filePathAbsolute ?? importPath;
+        assertFileEnv(filePathForEnvCheck, configEnv, configName);
     }
     return {
-        importFilePath,
-        importFileExportName
+        filePathToShowToUser,
+        fileExportName: exportName
     };
 }
-function resolveRelativeCodeFilePath(importData, configFilePath, userRootDir) {
-    let importFilePath = resolveImport(importData, configFilePath);
-    // Make it a Vite path
+function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, configFilePath, userRootDir) {
     (0, utils_js_1.assertPosixPath)(userRootDir);
-    (0, utils_js_1.assertPosixPath)(importFilePath);
-    if (importFilePath.startsWith(userRootDir)) {
-        importFilePath = getVitePathFromAbsolutePath(importFilePath, userRootDir);
+    let filePathRelativeToUserRootDir;
+    if (filePathAbsolute.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsolute, userRootDir);
     }
     else {
-        (0, utils_js_1.assertUsage)(false, `${(0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(configFilePath)} imports from a relative path ${picocolors_1.default.cyan(importData.importFilePath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
+        (0, utils_js_1.assertUsage)(false, `${(0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(configFilePath)} imports from a relative path ${picocolors_1.default.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(importFilePath.startsWith('/'))
-        // importFilePath = `/@fs${importFilePath}`
+        // assert(filePathAbsolute.startsWith('/'))
+        // filePath = `/@fs${filePathAbsolute}`
         // /*/
-        // importFilePath = path.posix.relative(userRootDir, importFilePath)
-        // assert(importFilePath.startsWith('../'))
-        // importFilePath = '/' + importFilePath
+        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute)
+        // assert(filePathRelativeToUserRootDir.startsWith('../'))
+        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
         // //*/
     }
-    (0, utils_js_1.assertPosixPath)(importFilePath);
-    (0, utils_js_1.assert)(importFilePath.startsWith('/'));
-    return importFilePath;
+    (0, utils_js_1.assertPosixPath)(filePathRelativeToUserRootDir);
+    (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));
+    return filePathRelativeToUserRootDir;
 }
 function getVitePathFromAbsolutePath(filePathAbsolute, root) {
     (0, utils_js_1.assertPosixPath)(filePathAbsolute);
@@ -710,10 +716,9 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
 function applyComputed(pageConfig, configDefinitionsRelevant) {
     (0, utils_js_1.objectEntries)(configDefinitionsRelevant).forEach(([configName, configDef]) => {
         var _a;
-        const computed = configDef._computed;
-        if (!computed)
+        if (!configDef._computed)
             return;
-        const value = computed(pageConfig);
+        const value = configDef._computed(pageConfig);
         if (value === undefined)
             return;
         const configValueSource = {
@@ -826,10 +831,11 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsImportData.map((importData) => {
-        const { importFilePath: importPath } = importData;
+        const { importPath: importPath } = importData;
         // TODO
         //  - validate extends configs
-        const filePathAbsolute = resolveImport(importData, configFilePath);
+        const filePathAbsolute = resolveImportPath(importData, configFilePath);
+        assertImportPath(filePathAbsolute, importData, configFilePath);
         assertExtendsImportPath(importPath, filePathAbsolute, configFilePath);
         extendsConfigFiles.push({
             filePathAbsolute,
@@ -875,7 +881,7 @@ function assertExtendsImportPath(importPath, filePath, configFilePath) {
 }
 function getExtendsImportData(configFileExports, configFilePath) {
     const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(configFilePath);
-    (0, utils_js_1.assertDefaultExportObject)(configFileExports, filePathToShowToUser);
+    (0, assertExports_js_1.assertExportsOfConfigFile)(configFileExports, filePathToShowToUser);
     const defaultExports = configFileExports.default;
     const wrongUsage = `${filePathToShowToUser} sets the config 'extends' to an invalid value, see https://vike.dev/extends`;
     let extendList;
@@ -973,7 +979,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
     const configFilesystemRoutingRoot = configValueSources[configName]?.[0];
     let filesystemRouteString = (0, filesystemRouting_js_1.getFilesystemRouteString)(locationId);
     if (determineIsErrorPage(filesystemRouteString)) {
-        return { isErrorPage: true, routeFilesystem: null };
+        return { isErrorPage: true, routeFilesystem: undefined };
     }
     let filesystemRouteDefinedBy = (0, filesystemRouting_js_1.getFilesystemRouteDefinedBy)(locationId); // for log404()
     if (configFilesystemRoutingRoot) {
@@ -991,7 +997,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
         routeString: filesystemRouteString,
         definedBy: filesystemRouteDefinedBy
     };
-    return { routeFilesystem, isErrorPage: false };
+    return { routeFilesystem, isErrorPage: undefined };
 }
 function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName) {
     (0, utils_js_1.assert)(configFilesystemRoutingRoot.configEnv === 'config-only');
@@ -1011,22 +1017,22 @@ function determineIsErrorPage(routeFilesystem) {
     (0, utils_js_1.assertPosixPath)(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function resolveImport(importData, importerFilePath) {
-    const { filePathAbsolute } = importerFilePath;
-    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
-    const plusConfigFilDirPathAbsolute = path_1.default.posix.dirname(filePathAbsolute);
-    const importedFile = (0, utils_js_1.resolve)(importData.importFilePath, plusConfigFilDirPathAbsolute);
-    assertImport(importedFile, importData, importerFilePath);
-    return importedFile;
+function resolveImportPath(importData, importerFilePath) {
+    const importerFilePathAbsolute = importerFilePath.filePathAbsolute;
+    (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
+    const cwd = path_1.default.posix.dirname(importerFilePathAbsolute);
+    // filePathAbsolute is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsolute = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
+    return filePathAbsolute;
 }
-function assertImport(importedFile, importData, importerFilePath) {
-    const { importFilePath: importPath, importWasGenerated, importDataString } = importData;
+function assertImportPath(filePathAbsolute, importData, importerFilePath) {
+    const { importPath: importPath, importStringWasGenerated, importString } = importData;
     const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(importerFilePath);
-    if (!importedFile) {
+    if (!filePathAbsolute) {
         const importPathString = picocolors_1.default.cyan(`'${importPath}'`);
-        const errIntro = importWasGenerated
+        const errIntro = importStringWasGenerated
             ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${picocolors_1.default.cyan(importDataString)} defined in ${filePathToShowToUser}`;
+            : `The import ${picocolors_1.default.cyan(importString)} defined in ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
         if (importPath.startsWith('.')) {
             (0, utils_js_1.assertUsage)(false, `${errIntro2} point to an existing file?`);
@@ -1078,6 +1084,8 @@ function mergeCumulative(configName, configValueSources) {
         /* 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
         */
+        // Make sure configValueSource.value is serializable
+        (0, getVirtualFilePageConfigs_js_1.getConfigValueSerialized)(configValueSource.value, configName, configValueSource.definedAtInfo);
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';