vike 0.4.230 → 0.4.231-commit-a0ca5e4

package/dist/cjs/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig.js → vite/shared/resolveVikeConfigInternal.js}

@@ -3,179 +3,203 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVikeConfig = getVikeConfig;
-exports.getVikeConfigOptional = getVikeConfigOptional;
-exports.getVikeConfig2 = getVikeConfig2;
+exports.getVikeConfigInternal = getVikeConfigInternal;
+exports.getVikeConfigInternalOptional = getVikeConfigInternalOptional;
+exports.getVikeConfigInternalSync = getVikeConfigInternalSync;
+exports.setVikeConfigContext = setVikeConfigContext;
 exports.reloadVikeConfig = reloadVikeConfig;
 exports.isV1Design = isV1Design;
 exports.getConfVal = getConfVal;
 exports.getConfigDefinitionOptional = getConfigDefinitionOptional;
 exports.getVikeConfigFromCliOrEnv = getVikeConfigFromCliOrEnv;
 exports.isOverriden = isOverriden;
-const utils_js_1 = require("../../../utils.js");
-const configDefinitionsBuiltIn_js_1 = require("./getVikeConfig/configDefinitionsBuiltIn.js");
-const filesystemRouting_js_1 = require("./getVikeConfig/filesystemRouting.js");
-const isVikeConfigInvalid_js_1 = require("../../../../runtime/renderPage/isVikeConfigInvalid.js");
-const globalContext_js_1 = require("../../../../runtime/globalContext.js");
-const loggerNotProd_js_1 = require("../../../shared/loggerNotProd.js");
-const removeSuperfluousViteLog_js_1 = require("../../../shared/loggerVite/removeSuperfluousViteLog.js");
+exports.getVikeConfig = getVikeConfig;
+const utils_js_1 = require("../utils.js");
+const configDefinitionsBuiltIn_js_1 = require("./resolveVikeConfigInternal/configDefinitionsBuiltIn.js");
+const filesystemRouting_js_1 = require("./resolveVikeConfigInternal/filesystemRouting.js");
+const globalContext_js_1 = require("../../runtime/globalContext.js");
+const loggerNotProd_js_1 = require("./loggerNotProd.js");
+const removeSuperfluousViteLog_js_1 = require("./loggerVite/removeSuperfluousViteLog.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const getConfigDefinedAt_js_1 = require("../../../../../shared/page-configs/getConfigDefinedAt.js");
-const loadFileAtConfigTime_js_1 = require("./getVikeConfig/loadFileAtConfigTime.js");
-const resolvePointerImport_js_1 = require("./getVikeConfig/resolvePointerImport.js");
-const getFilePath_js_1 = require("../../../shared/getFilePath.js");
-const getConfigValueBuildTime_js_1 = require("../../../../../shared/page-configs/getConfigValueBuildTime.js");
-const assertExtensions_js_1 = require("./getVikeConfig/assertExtensions.js");
-const getUserFriendlyConfigs_js_1 = require("../../../../../shared/page-configs/getUserFriendlyConfigs.js");
-const serializeConfigValues_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValues.js");
-const getPlusFilesAll_js_1 = require("./getVikeConfig/getPlusFilesAll.js");
-const getEnvVarObject_js_1 = require("../../../shared/getEnvVarObject.js");
-const context_js_1 = require("../../../../api/context.js");
-const context_js_2 = require("../../../../cli/context.js");
+const getConfigDefinedAt_js_1 = require("../../../shared/page-configs/getConfigDefinedAt.js");
+const loadFileAtConfigTime_js_1 = require("./resolveVikeConfigInternal/loadFileAtConfigTime.js");
+const resolvePointerImport_js_1 = require("./resolveVikeConfigInternal/resolvePointerImport.js");
+const getFilePath_js_1 = require("./getFilePath.js");
+const getConfigValueBuildTime_js_1 = require("../../../shared/page-configs/getConfigValueBuildTime.js");
+const resolveVikeConfigPublic_js_1 = require("../../../shared/page-configs/resolveVikeConfigPublic.js");
+const serializeConfigValues_js_1 = require("../../../shared/page-configs/serialize/serializeConfigValues.js");
+const getPlusFilesAll_js_1 = require("./resolveVikeConfigInternal/getPlusFilesAll.js");
+const getEnvVarObject_js_1 = require("./getEnvVarObject.js");
+const context_js_1 = require("../../api/context.js");
+const context_js_2 = require("../../cli/context.js");
+const resolvePrerenderConfig_js_1 = require("../../prerender/resolvePrerenderConfig.js");
+const getProxyForPublicUsage_js_1 = require("../../../shared/getProxyForPublicUsage.js");
+const renderPage_js_1 = require("../../runtime/renderPage.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
+// We can simply use global variables since Vike's config is:
+//  - gobal
+//  - independent of Vite (therefore we don't need to tie Vike's config with Vite's `config` object)
 (0, utils_js_1.assertIsSingleModuleInstance)('v1-design/getVikeConfig.ts');
 let restartVite = false;
-let wasConfigInvalid = null;
+let vikeConfigHasBuildError = null;
+let isV1Design_ = null;
 let vikeConfigPromise = null;
-function reloadVikeConfig(config) {
-    const userRootDir = config.root;
-    const vikeVitePluginOptions = config._vikeVitePluginOptions;
+// TODO/v1-release: remove
+let vikeConfigSync = null;
+let vikeConfigCtx = null; // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
+let prerenderContext;
+function reloadVikeConfig() {
+    (0, utils_js_1.assert)(vikeConfigCtx);
+    const { userRootDir, vikeVitePluginOptions } = vikeConfigCtx;
     (0, utils_js_1.assert)(vikeVitePluginOptions);
-    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
-    handleReloadSideEffects();
+    resolveVikeConfigInternal_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
 }
-async function handleReloadSideEffects() {
-    wasConfigInvalid = !!isVikeConfigInvalid_js_1.isVikeConfigInvalid;
-    const vikeConfigPromisePrevious = vikeConfigPromise;
-    try {
-        await vikeConfigPromise;
-    }
-    catch (err) {
-        // handleReloadSideEffects() is only called in dev.
-        // In dev, if loadVikeConfig_withErrorHandling() throws an error, then it's a vike bug.
-        console.error(err);
-        (0, utils_js_1.assert)(false);
-    }
-    if (vikeConfigPromise !== vikeConfigPromisePrevious) {
-        // Let the next handleReloadSideEffects() call handle side effects
-        return;
-    }
-    if (!isVikeConfigInvalid_js_1.isVikeConfigInvalid) {
-        if (wasConfigInvalid) {
-            wasConfigInvalid = false;
-            (0, loggerNotProd_js_1.logConfigErrorRecover)();
-        }
-        if (restartVite) {
-            restartVite = false;
-            const viteDevServer = (0, globalContext_js_1.getViteDevServer)();
-            (0, utils_js_1.assert)(viteDevServer);
-            (0, removeSuperfluousViteLog_js_1.removeSuperfluousViteLog_enable)();
-            await viteDevServer.restart(true);
-            (0, removeSuperfluousViteLog_js_1.removeSuperfluousViteLog_disable)();
-        }
-    }
+async function getVikeConfigInternal(
+// I don't remember the logic behind it — neither why we restart Vite's dev server, nor why we sometimes don't.
+// TO-DO: eventually rethink all that. Some + settings are expected to influence Vite's config (restarting Vite's dev server is needed) while some don't.
+doNotRestartViteOnError = false) {
+    (0, utils_js_1.assert)(vikeConfigCtx);
+    const { userRootDir, isDev, vikeVitePluginOptions } = vikeConfigCtx;
+    const vikeConfig = await getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
+    return vikeConfig;
 }
-// TODO/soon: predominantly use getVikeConfigInternal() instead of getVikeConfig() then maybe refector?
-async function getVikeConfig(config, { doNotRestartViteOnError } = {}) {
-    const userRootDir = config.root;
-    const vikeVitePluginOptions = config._vikeVitePluginOptions;
-    (0, utils_js_1.assert)(vikeVitePluginOptions);
-    const isDev = config._isDev;
-    (0, utils_js_1.assert)(typeof isDev === 'boolean');
-    return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError ?? false);
+// TODO/v1-release: remove
+function getVikeConfigInternalSync() {
+    (0, utils_js_1.assert)(vikeConfigSync);
+    return vikeConfigSync;
 }
-async function getVikeConfig2(userRootDir, isDev, vikeVitePluginOptions) {
-    (0, utils_js_1.assert)(vikeVitePluginOptions);
-    return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, false);
+// TO-DO/eventually: this maybe(/probably?) isn't safe against race conditions upon file changes in development, thus:
+// - Like getGlobalContext() and getGlobalContextSync() — make getVikeConfig() async and provide a getVikeConfigSync() while discourage using it
+// Public usage
+/**
+ * Get all the information Vike knows about the app in your Vite plugin.
+ *
+ * https://vike.dev/getVikeConfig
+ */
+function getVikeConfig(
+// TO-DO/eventually: remove unused arguments (older versions used it and we didn't remove it yet to avoid a TypeScript breaking change)
+// - No rush: we can do it later since it's getVikeConfig() is a beta feature as documented at https://vike.dev/getVikeConfig
+config) {
+    const vikeConfig = getVikeConfigInternalSync();
+    (0, utils_js_1.assertUsage)(vikeConfig, 'getVikeConfig() can only be used when Vite is loaded (i.e. during development or build) — Vite is never loaded in production.');
+    const vikeConfigPublic = (0, getProxyForPublicUsage_js_1.getProxyForPublicUsage)(vikeConfig, 'vikeConfig');
+    return vikeConfigPublic;
+}
+function setVikeConfigContext(vikeConfigCtx_) {
+    // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
+    vikeConfigCtx = vikeConfigCtx_;
 }
-async function getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
+async function getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     if (!vikeConfigPromise) {
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
+        resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     }
-    return await vikeConfigPromise;
+    (0, utils_js_1.assert)(vikeConfigPromise);
+    const vikeConfig = await vikeConfigPromise;
+    return vikeConfig;
 }
-async function getVikeConfigOptional() {
+async function getVikeConfigInternalOptional() {
     if (!vikeConfigPromise)
         return null;
-    return await vikeConfigPromise;
+    const vikeConfig = await vikeConfigPromise;
+    return vikeConfig;
 }
-function isV1Design(config) {
-    const vikeConfig = config._vikeConfigObject;
-    (0, utils_js_1.assert)(vikeConfig);
-    const { pageConfigs } = vikeConfig;
-    const isV1Design = pageConfigs.length > 0;
-    return isV1Design;
+function isV1Design() {
+    (0, utils_js_1.assert)(typeof isV1Design_ === 'boolean');
+    return isV1Design_;
 }
-async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
+async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
+    const { promise, resolve, reject } = (0, utils_js_1.genPromise)();
+    vikeConfigPromise = promise;
+    const esbuildCache = {
+        transpileCache: {},
+        vikeConfigDependencies: new Set()
+    };
     let hasError = false;
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, vikeVitePluginOptions);
+        ret = await resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache);
     }
     catch (err_) {
         hasError = true;
         err = err_;
     }
+    // There is a newer call — let the new call supersede the old one.
+    // We deliberately swallow the intermetidate state (including any potential error) — it's now outdated and has existed only for a very short period of time.
+    if (vikeConfigPromise !== promise) {
+        // vikeConfigPromise.then(resolve).catch(reject)
+        try {
+            resolve(await vikeConfigPromise);
+        }
+        catch (err) {
+            reject(err);
+        }
+        return;
+    }
     if (!hasError) {
         (0, utils_js_1.assert)(ret);
         (0, utils_js_1.assert)(err === undefined);
-        (0, isVikeConfigInvalid_js_1.isVikeConfigInvalid_set)(false);
-        return ret;
+        const hadError = vikeConfigHasBuildError;
+        vikeConfigHasBuildError = false;
+        (0, renderPage_js_1.renderPage_vikeConfigHasError)({ hasBuildError: false });
+        if (hadError) {
+            (0, loggerNotProd_js_1.logConfigErrorRecover)();
+            if (restartVite) {
+                restartVite = false;
+                restartViteDevServer();
+            }
+        }
+        resolve(ret);
     }
     else {
         (0, utils_js_1.assert)(ret === undefined);
         (0, utils_js_1.assert)(err);
-        (0, isVikeConfigInvalid_js_1.isVikeConfigInvalid_set)({ err });
+        vikeConfigHasBuildError = true;
+        (0, renderPage_js_1.renderPage_vikeConfigHasError)({ hasBuildError: { err } });
+        if (!doNotRestartViteOnError)
+            restartVite = true;
         if (!isDev) {
-            (0, utils_js_1.assert)((0, globalContext_js_1.getViteDevServer)() === null);
-            throw err;
+            reject(err);
         }
         else {
             (0, loggerNotProd_js_1.logConfigError)(err);
-            if (!doNotRestartViteOnError) {
-                restartVite = true;
-            }
-            const dummyData = {
-                pageConfigs: [],
-                pageConfigGlobal: {
-                    configDefinitions: {},
-                    configValueSources: {}
-                },
-                global: (0, getUserFriendlyConfigs_js_1.getUserFriendlyConfigsGlobal)({ pageConfigGlobalValues: {} }),
-                pages: {},
-                vikeConfigDependencies: new Set()
-            };
-            return dummyData;
+            resolve(getVikeConfigDummy(esbuildCache));
         }
     }
 }
-async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const esbuildCache = {
-        transpileCache: {},
-        vikeConfigDependencies: new Set()
-    };
+async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache) {
     const plusFilesAll = await (0, getPlusFilesAll_js_1.getPlusFilesAll)(userRootDir, esbuildCache);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
+    if (!isV1Design_)
+        isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
     // global
     const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
-    const userFriendlyConfigsGlobal = (0, getUserFriendlyConfigs_js_1.getUserFriendlyConfigsGlobal)({ pageConfigGlobalValues });
+    const vikeConfigPublicGlobal = (0, resolveVikeConfigPublic_js_1.resolveVikeConfigPublicGlobal)({ pageConfigGlobalValues });
     // pages
-    const userFriendlyConfigsPageEager = (0, utils_js_1.objectFromEntries)(pageConfigs.map((pageConfig) => {
+    const vikeConfigPublicPagesEager = (0, utils_js_1.objectFromEntries)(pageConfigs.map((pageConfig) => {
         const pageConfigValues = getConfigValues(pageConfig, true);
-        return (0, getUserFriendlyConfigs_js_1.getUserFriendlyConfigsPageEager)(pageConfigGlobalValues, pageConfig, pageConfigValues);
+        return (0, resolveVikeConfigPublic_js_1.resolveVikeConfigPublicPageEager)(pageConfigGlobalValues, pageConfig, pageConfigValues);
     }));
-    return {
-        pageConfigs,
-        pageConfigGlobal,
-        global: userFriendlyConfigsGlobal,
-        pages: userFriendlyConfigsPageEager,
-        vikeConfigDependencies: esbuildCache.vikeConfigDependencies
+    const prerenderContext = resolvePrerenderContext({
+        config: vikeConfigPublicGlobal.config,
+        _from: vikeConfigPublicGlobal._from,
+        _pageConfigs: pageConfigs
+    });
+    const vikeConfig = {
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        config: vikeConfigPublicGlobal.config,
+        _from: vikeConfigPublicGlobal._from,
+        pages: vikeConfigPublicPagesEager,
+        prerenderContext,
+        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies
     };
+    vikeConfigSync = vikeConfig;
+    return vikeConfig;
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const plusFilesAllOrdered = Object.values(plusFilesAll)
@@ -327,7 +351,6 @@ function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDef
 }
 function assertPageConfigs(pageConfigs) {
     pageConfigs.forEach((pageConfig) => {
-        (0, assertExtensions_js_1.assertExtensionsRequire)(pageConfig);
         assertOnBeforeRenderEnv(pageConfig);
     });
 }
@@ -710,6 +733,8 @@ function getConfigDefinitions(plusFilesRelevant, filter) {
         assertMetaUsage(meta, `Config ${picocolors_1.default.cyan('meta')} defined at ${plusFile.filePath.filePathToShowToUser}`);
         // Set configDef._userEffectDefinedAtFilePath
         Object.entries(meta).forEach(([configName, configDef]) => {
+            if ('isDefinedByPeerDependency' in configDef)
+                return;
             if (!configDef.effect)
                 return;
             (0, utils_js_1.assert)(plusFile.isConfigFile);
@@ -719,6 +744,12 @@ function getConfigDefinitions(plusFilesRelevant, filter) {
             };
         });
         (0, utils_js_1.objectEntries)(meta).forEach(([configName, configDefinitionUserLand]) => {
+            if ('isDefinedByPeerDependency' in configDefinitionUserLand) {
+                configDefinitionUserLand = {
+                    env: { client: false, server: false, config: false },
+                    ...configDefinitionUserLand
+                };
+            }
             // User can override an existing config definition
             configDefinitions[configName] = {
                 ...configDefinitions[configName],
@@ -741,6 +772,8 @@ function assertMetaUsage(metaVal, metaConfigDefinedAt) {
             (0, utils_js_1.assert)(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
             (0, utils_js_1.assertUsage)(false, `${metaConfigDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}`)} to a value with an invalid type ${picocolors_1.default.cyan(typeof def)}: it should be an object instead.`);
         }
+        if (def.isDefinedByPeerDependency)
+            return;
         // env
         let configEnv;
         {
@@ -851,6 +884,7 @@ function applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEf
         }
         assertMetaUsage(configValue, configDefinedAt);
         (0, utils_js_1.objectEntries)(configValue).forEach(([configTargetName, configTargetDef]) => {
+            (0, utils_js_1.assert)(!('isDefinedByPeerDependency' in configTargetDef));
             {
                 const keys = Object.keys(configTargetDef);
                 (0, utils_js_1.assertUsage)(keys.includes('env'), notSupported);
@@ -1077,3 +1111,56 @@ function isOverriden(source, configName, pageConfig) {
     (0, utils_js_1.assert)(idx >= 0);
     return idx > 0;
 }
+function resolvePrerenderContext(vikeConfig) {
+    const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
+    prerenderContext ?? (prerenderContext = {
+        isPrerenderingEnabled: false,
+        isPrerenderingEnabledForAllPages: false,
+        // Set at runPrerender()
+        output: null,
+        // Set at runPrerender()
+        pageContexts: null
+    });
+    prerenderContext.isPrerenderingEnabled = isPrerenderingEnabled;
+    prerenderContext.isPrerenderingEnabledForAllPages = isPrerenderingEnabledForAllPages;
+    return prerenderContext;
+}
+function restartViteDevServer() {
+    const viteDevServer = (0, globalContext_js_1.getViteDevServer)();
+    (0, utils_js_1.assert)(viteDevServer);
+    (0, removeSuperfluousViteLog_js_1.removeSuperfluousViteLog_enable)();
+    (async () => {
+        try {
+            await viteDevServer.restart(true);
+        }
+        catch (err) {
+            console.error('Vite restart error:');
+            console.error(err);
+        }
+    })();
+    (0, removeSuperfluousViteLog_js_1.removeSuperfluousViteLog_disable)();
+}
+function getVikeConfigDummy(esbuildCache) {
+    const globalDummy = (0, resolveVikeConfigPublic_js_1.resolveVikeConfigPublicGlobal)({ pageConfigGlobalValues: {} });
+    const pageConfigsDummy = [];
+    const prerenderContextDummy = resolvePrerenderContext({
+        config: globalDummy.config,
+        _from: globalDummy._from,
+        _pageConfigs: pageConfigsDummy
+    });
+    const vikeConfigDummy = {
+        _pageConfigs: pageConfigsDummy,
+        _pageConfigGlobal: {
+            configDefinitions: {},
+            configValueSources: {}
+        },
+        config: globalDummy.config,
+        _from: globalDummy._from,
+        pages: {},
+        prerenderContext: prerenderContextDummy,
+        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies
+    };
+    vikeConfigSync = vikeConfigDummy;
+    isV1Design_ = true;
+    return vikeConfigDummy;
+}

package/dist/cjs/shared/createGlobalContextShared.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalContextSyncErrMsg = void 0;
 exports.createGlobalContextShared = createGlobalContextShared;
 const utils_js_1 = require("./utils.js");
-const parseGlobResults_js_1 = require("./getPageFiles/parseGlobResults.js");
-const getUserFriendlyConfigs_js_1 = require("./page-configs/getUserFriendlyConfigs.js");
+const parseVirtualFileExports_js_1 = require("./getPageFiles/parseVirtualFileExports.js");
+const resolveVikeConfigPublic_js_1 = require("./page-configs/resolveVikeConfigPublic.js");
 const execHook_js_1 = require("./hooks/execHook.js");
 const prepareGlobalContextForPublicUsage_js_1 = require("./prepareGlobalContextForPublicUsage.js");
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
@@ -36,7 +36,7 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
     return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExports) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, userFriendlyConfigsGlobal, userFriendlyConfigsPageEager } = getConfigsAll(virtualFileExports);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, vikeConfigPublicGlobal, vikeConfigPublicPagesEager } = getConfigsAll(virtualFileExports);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -50,29 +50,29 @@ function createGlobalContextBase(virtualFileExports) {
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
-        _userFriendlyConfigsGlobal: userFriendlyConfigsGlobal,
-        config: userFriendlyConfigsGlobal.config,
-        pages: userFriendlyConfigsPageEager
+        _vikeConfigPublicGlobal: vikeConfigPublicGlobal,
+        config: vikeConfigPublicGlobal.config,
+        pages: vikeConfigPublicPagesEager
     };
     (0, utils_js_1.changeEnumerable)(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
 function getConfigsAll(virtualFileExports) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = (0, parseGlobResults_js_1.parseGlobResults)(virtualFileExports);
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = (0, parseVirtualFileExports_js_1.parseVirtualFileExports)(virtualFileExports);
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
-    const userFriendlyConfigsGlobal = (0, getUserFriendlyConfigs_js_1.getUserFriendlyConfigsGlobal)({
+    const vikeConfigPublicGlobal = (0, resolveVikeConfigPublic_js_1.resolveVikeConfigPublicGlobal)({
         pageConfigGlobalValues: pageConfigGlobal.configValues
     });
-    const userFriendlyConfigsPageEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        return (0, getUserFriendlyConfigs_js_1.getUserFriendlyConfigsPageEager)(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
+    const vikeConfigPublicPagesEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
+        return (0, resolveVikeConfigPublic_js_1.resolveVikeConfigPublicPageEager)(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
     }));
     return {
         pageFilesAll,
         allPageIds,
         pageConfigs,
         pageConfigGlobal,
-        userFriendlyConfigsGlobal,
-        userFriendlyConfigsPageEager
+        vikeConfigPublicGlobal,
+        vikeConfigPublicPagesEager
     };
 }
 function getAllPageIds(pageFilesAll, pageConfigs) {

package/dist/cjs/shared/createPageContextShared.js

@@ -5,8 +5,8 @@ exports.createPageContextObject = createPageContextObject;
 const execHook_js_1 = require("./hooks/execHook.js");
 const preparePageContextForPublicUsage_js_1 = require("./preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
-async function createPageContextShared(pageContextCreated, pageConfigGlobal, userFriendlyConfigsGlobal) {
-    (0, utils_js_1.objectAssign)(pageContextCreated, userFriendlyConfigsGlobal);
+async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
+    (0, utils_js_1.objectAssign)(pageContextCreated, vikeConfigPublicGlobal);
     await (0, execHook_js_1.execHookGlobal)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     return pageContextCreated;
 }

package/dist/cjs/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -25,6 +25,6 @@ function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtml
 }
 function getVikeClientEntry(isClientRouting) {
     return isClientRouting
-        ? '@@vike/dist/esm/client/client-routing-runtime/entry.js'
-        : '@@vike/dist/esm/client/server-routing-runtime/entry.js';
+        ? '@@vike/dist/esm/client/runtime-client-routing/entry.js'
+        : '@@vike/dist/esm/client/runtime-server-routing/entry.js';
 }

package/dist/cjs/shared/getPageFiles/analyzePageClientSide.js

@@ -34,7 +34,6 @@ async function analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFiles
         if (sharedPageFilesAlreadyLoaded && p.isEnv('CLIENT_AND_SERVER')) {
             return;
         }
-        // TODO: Is `loadExportNames()` cached ? Does it use filesExports if possible? HMR?
         await p.loadExportNames?.();
         /*
         if (pageFile.exportNames) {

package/dist/cjs/shared/getPageFiles/{parseGlobResults.js → parseVirtualFileExports.js}

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseGlobResults = parseGlobResults;
+exports.parseVirtualFileExports = parseVirtualFileExports;
 // TODO/v1-release: remove old design code, and remove all assertions.
 const utils_js_1 = require("../utils.js");
 const assert_exports_old_design_js_1 = require("./assert_exports_old_design.js");
 const getPageFileObject_js_1 = require("./getPageFileObject.js");
 const fileTypes_js_1 = require("./fileTypes.js");
 const parsePageConfigs_js_1 = require("../page-configs/serialize/parsePageConfigs.js");
-// TODO/now: rename
-function parseGlobResults(pageFilesExports) {
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesLazy', 'object'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesEager', 'object'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesExportNamesLazy', 'object'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesExportNamesEager', 'object'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page.client') || (0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page.server'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesList', 'string[]'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigsSerialized'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigGlobalSerialized'));
-    const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
+function parseVirtualFileExports(virtualFileExports) {
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(virtualFileExports, 'pageFilesLazy', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(virtualFileExports, 'pageFilesEager', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(virtualFileExports, 'pageFilesExportNamesLazy', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(virtualFileExports, 'pageFilesExportNamesEager', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(virtualFileExports.pageFilesLazy, '.page'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(virtualFileExports.pageFilesLazy, '.page.client') ||
+        (0, utils_js_1.hasProp)(virtualFileExports.pageFilesLazy, '.page.server'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(virtualFileExports, 'pageFilesList', 'string[]'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(virtualFileExports, 'pageConfigsSerialized'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(virtualFileExports, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExports;
     assertPageConfigsSerialized(pageConfigsSerialized);
     assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
     const { pageConfigs, pageConfigGlobal } = (0, parsePageConfigs_js_1.parsePageConfigs)(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
-    parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const loadModule = globValue;
         assertLoadModule(loadModule);
@@ -34,7 +34,7 @@ function parseGlobResults(pageFilesExports) {
             }
         };
     });
-    parseGlobResult(pageFilesExports.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const loadModule = globValue;
         assertLoadModule(loadModule);
@@ -47,20 +47,20 @@ function parseGlobResults(pageFilesExports) {
         };
     });
     // `pageFilesEager` contains `.page.route.js` files
-    parseGlobResult(pageFilesExports.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const moduleExports = globValue;
         (0, utils_js_1.assert)((0, utils_js_1.isObject)(moduleExports));
         pageFile.fileExports = moduleExports;
     });
-    parseGlobResult(pageFilesExports.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const moduleExports = globValue;
         (0, utils_js_1.assert)((0, utils_js_1.isObject)(moduleExports));
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
         pageFile.exportNames = moduleExports.exportNames;
     });
-    pageFilesExports.pageFilesList.forEach((filePath) => {
+    virtualFileExports.pageFilesList.forEach((filePath) => {
         pageFilesMap[filePath] = pageFilesMap[filePath] ?? (0, getPageFileObject_js_1.getPageFileObject)(filePath);
     });
     const pageFilesAll = Object.values(pageFilesMap);

package/dist/cjs/shared/getProxyForPublicUsage.js

@@ -47,7 +47,7 @@ function onInternalProp(propStr, objName) {
     //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use import.meta.env.SSR
     if ((0, utils_js_1.isBrowser)())
         return;
-    // TODO/now remove this and only warn on built-in access instead
+    // TODO/now-proxy remove this and only warn on built-in access instead
     if (propStr === '_configFromHook')
         return;
     if (propStr.startsWith('_')) {

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

@@ -22,7 +22,7 @@ function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
     const exportDefault = picocolors_1.default.code('export default');
     const exportNamed = picocolors_1.default.code(`export { ${configName} }`);
     if (exportNamesValid.length === 0) {
-        (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} should have ${exportNamed} or ${exportDefault}`);
+        (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} should define ${exportNamed} or ${exportDefault}`);
     }
     if (exportNamesValid.length === 2) {
         (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} is ambiguous: remove ${exportDefault} or ${exportNamed}`);

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

@@ -9,7 +9,7 @@ async function loadConfigValues(pageConfig, isDev) {
         !isDev) {
         return pageConfig;
     }
-    const { moduleId, moduleExports } = pageConfig.loadConfigValuesAll();
+    const { moduleId, moduleExports } = pageConfig.loadConfigLazy();
     const configValuesLoaded = await moduleExports;
     // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
     if (!configValuesLoaded)