vike 0.4.171-commit-f9548df → 0.4.171-commit-3b2cb88

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

@@ -14,12 +14,12 @@ import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNot
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
-import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
 import { clearFilesEnvMap, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
+import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -166,7 +166,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
                 //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
                 //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
                 const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
-                if (configDef && isConfigEnv(configDef, configName)) {
+                if (configDef && isLoadableAtBuildTime(configDef)) {
                     await loadValueFile(interfaceFile, configName, userRootDir);
                 }
             }
@@ -241,6 +241,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
             const dummyData = {
                 pageConfigs: [],
                 pageConfigGlobal: {
+                    configDefinitions: {},
                     configValueSources: {}
                 },
                 globalVikeConfig: {}
@@ -266,7 +267,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev) {
             if (isGlobalConfig(configName))
                 return;
             const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (!isConfigEnv(configDef, configName))
+            if (!isLoadableAtBuildTime(configDef))
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
             if (isAlreadyLoaded)
@@ -288,14 +289,13 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev) {
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsAll(configValueSources, configDefinitions);
         const configValuesComputed = getComputed(configValueSources, configDefinitions);
-        const configValues = getConfigValues(configValueSources, configValuesComputed, configDefinitions);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
             routeFilesystem,
+            configDefinitions,
             configValueSources,
-            configValuesComputed,
-            configValues
+            configValuesComputed
         };
         return pageConfig;
     }));
@@ -328,7 +328,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
     if (!onBeforeRenderConfig)
         return;
     const onBeforeRenderEnv = onBeforeRenderConfig.configEnv;
-    const isClientRouting = !!pageConfig.configValues.clientRouting?.value;
+    const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean');
     // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
     assertUsage(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
 }
@@ -389,6 +389,7 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
     }
     const globalVikeConfig = {};
     const pageConfigGlobal = {
+        configDefinitions: configDefinitionsBuiltInGlobal,
         configValueSources: {}
     };
     await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
@@ -422,7 +423,15 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
         const add = (interfaceFile) => {
             assert(!visited.has(interfaceFile));
             visited.add(interfaceFile);
-            sourcesInfo.push([configName, interfaceFile, configDef, userRootDir, importedFilesLoaded]);
+            const isHighestInheritancePrecedence = sourcesInfo.length === 0;
+            sourcesInfo.push([
+                configName,
+                interfaceFile,
+                configDef,
+                userRootDir,
+                importedFilesLoaded,
+                isHighestInheritancePrecedence
+            ]);
         };
         // Main resolution logic
         {
@@ -493,7 +502,7 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
 function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
-async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded) {
+async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded, isHighestInheritancePrecedence) {
     const conf = interfaceFile.fileExportsByConfigName[configName];
     assert(conf);
     const configEnv = deriveConfigEnvFromFileName(configDef.env, interfaceFile.filePath.fileName);
@@ -502,6 +511,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
     };
+    const isOverriden = configDef.cumulative ? false : !isHighestInheritancePrecedence;
     // +client.js
     if (configDef._valueIsFilePath) {
         let definedAtFilePath;
@@ -528,7 +538,8 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
-            valueIsDefinedByValueFile: false,
+            valueIsDefinedByPlusFile: false,
+            isOverriden,
             definedAtFilePath
         };
         return configValueSource;
@@ -544,11 +555,12 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 locationId,
                 configEnv,
                 valueIsImportedAtRuntime: true,
-                valueIsDefinedByValueFile: false,
+                valueIsDefinedByPlusFile: false,
+                isOverriden,
                 definedAtFilePath: pointerImport
             };
             // Load pointer import
-            if (isConfigEnv(configDef, configName) &&
+            if (isLoadableAtBuildTime(configDef) &&
                 // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
                 configName !== 'extends') {
                 if (pointerImport.filePathAbsoluteFilesystem) {
@@ -568,7 +580,8 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             value: configValue,
             configEnv,
             valueIsImportedAtRuntime: false,
-            valueIsDefinedByValueFile: false,
+            valueIsDefinedByPlusFile: false,
+            isOverriden,
             definedAtFilePath: definedAtFilePath_
         };
         return configValueSource;
@@ -581,7 +594,8 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             locationId,
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
-            valueIsDefinedByValueFile: true,
+            valueIsDefinedByPlusFile: true,
+            isOverriden,
             definedAtFilePath: {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: configName === interfaceFile.configName
@@ -876,59 +890,6 @@ function determineIsErrorPage(routeFilesystem) {
 function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }
-function getConfigValues(configValueSources, configValuesComputed, configDefinitions) {
-    const configValues = {};
-    Object.entries(configValuesComputed).forEach(([configName, configValueComputed]) => {
-        configValues[configName] = {
-            type: 'computed',
-            value: configValueComputed.value,
-            definedAtData: null
-        };
-    });
-    Object.entries(configValueSources).forEach(([configName, sources]) => {
-        const configDef = configDefinitions[configName];
-        assert(configDef);
-        if (!configDef.cumulative) {
-            const configValueSource = sources[0];
-            if ('value' in configValueSource) {
-                configValues[configName] = {
-                    type: 'standard',
-                    value: configValueSource.value,
-                    definedAtData: getDefinedAtFile(configValueSource)
-                };
-            }
-        }
-        else {
-            const value = mergeCumulative(configName, sources);
-            const definedAtData = sources.map((source) => getDefinedAtFile(source));
-            assert(value.length === definedAtData.length);
-            configValues[configName] = {
-                type: 'cumulative',
-                value,
-                definedAtData
-            };
-        }
-    });
-    return configValues;
-}
-function getDefinedAtFile(configValueSource) {
-    return {
-        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
-    };
-}
-function mergeCumulative(configName, configValueSources) {
-    const configValues = [];
-    configValueSources.forEach((configValueSource) => {
-        // We could, in principle, also support cumulative for values that aren't loaded at config-time but it isn't completely trivial to implement.
-        assert('value' in configValueSource);
-        // Make sure configValueSource.value is serializable
-        assertConfigValueIsSerializable(configValueSource.value, configName, getDefinedAtFile(configValueSource));
-        const { value } = configValueSource;
-        configValues.push(value);
-    });
-    return configValues;
-}
 function getConfigEnvValue(val, errMsgIntro) {
     const errInvalidValue = `${errMsgIntro} an invalid value ${pc.cyan(JSON.stringify(val))}`;
     // Legacy outdated values
@@ -971,13 +932,8 @@ function getConfigDefinition(configDefinitions, configName, filePathToShowToUser
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-function isConfigEnv(configDef, configName) {
-    const configEnv = configDef.env;
-    if (configDef.cumulative) {
-        // In principle we could lift that requirement (but it requires non-trivial modifications)
-        assertUsage(configEnv.config, `Config ${pc.cyan(configName)} needs its ${pc.cyan('env')} to have ${pc.cyan('{ config: true }')} (because ${pc.cyan(configName)} is a ${pc.cyan('cumulative')} config)`);
-    }
-    return !!configEnv.config;
+function isLoadableAtBuildTime(configDef) {
+    return !!configDef.env.config && !configDef._valueIsFilePath;
 }
 function isGlobalConfig(configName) {
     if (configName === 'prerender')

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

@@ -4,13 +4,11 @@ import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll
 import { getVikeConfig } from './getVikeConfig.js';
 import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
-import { getConfigValue } from '../../../../../shared/page-configs/getConfigValue.js';
-import { getConfigValueSourcesNotOverriden } from '../../../shared/getConfigValueSourcesNotOverriden.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { getConfigVike } from '../../../../shared/getConfigVike.js';
-import { getConfigValuesSerialized } from './getConfigValuesSerialized.js';
 import { fixServerAssets_isEnabled } from '../../buildConfig/fixServerAssets.js';
+import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
     assert(result);
@@ -32,16 +30,9 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
 function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
     const lines = [];
     const importStatements = [];
-    const isClientRouting = getConfigValue(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
-    lines.push('export const configValuesImported = [');
-    lines.push(getConfigValuesImported(pageConfig, isForClientSide, isClientRouting, importStatements));
-    lines.push('];');
+    const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesSerialized = {');
-    lines.push(getConfigValuesSerialized(pageConfig, importStatements, (configEnv, configValueSource) => isEnvMatch(configEnv, !configValueSource ? false : checkWhetherIsImport(configValueSource), {
-        isImport: false,
-        isForClientSide,
-        isClientRouting
-    })));
+    lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: false, isDev }), ''));
     lines.push('};');
     if (!fixServerAssets_isEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
         importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);
@@ -49,32 +40,3 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const code = [...importStatements, ...lines].join('\n');
     return code;
 }
-function getConfigValuesImported(pageConfig, isForClientSide, isClientRouting, importStatements) {
-    const lines = [];
-    getConfigValueSourcesNotOverriden(pageConfig).forEach((configValueSource) => {
-        if (!isEnvMatch(configValueSource.configEnv, checkWhetherIsImport(configValueSource), {
-            isImport: true,
-            isForClientSide,
-            isClientRouting
-        }))
-            return;
-        const whitespace = '  ';
-        lines.push(...serializeConfigValueImported(configValueSource, configValueSource.configName, whitespace, importStatements));
-    });
-    const code = lines.join('\n');
-    return code;
-}
-function checkWhetherIsImport(configValueSource) {
-    const { valueIsImportedAtRuntime, valueIsFilePath } = configValueSource;
-    return valueIsImportedAtRuntime && !valueIsFilePath;
-}
-function isEnvMatch(configEnv, isImport, runtime) {
-    // Whether config value is imported or serialized
-    if (isImport !== runtime.isImport)
-        return false;
-    // Runtime match
-    const { isForClientSide, isClientRouting } = runtime;
-    if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: false }))
-        return false;
-    return true;
-}

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

@@ -1,11 +1,9 @@
 export { getVirtualFilePageConfigs };
-import { assert, objectEntries } from '../../../utils.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { debug } from './debug.js';
 import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
-import { getConfigValuesSerialized } from './getConfigValuesSerialized.js';
+import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
     const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, isDev, true);
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
@@ -14,16 +12,16 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     const lines = [];
     const importStatements = [];
     lines.push('export const pageConfigsSerialized = [');
-    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements));
+    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements));
     lines.push('];');
     lines.push('export const pageConfigGlobalSerialized = {');
-    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements));
+    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements));
     lines.push('};');
     const code = [...importStatements, ...lines].join('\n');
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
-function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements) {
+function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements) {
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
@@ -33,57 +31,19 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
         lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
-        // Serialized config values
         lines.push(`    configValuesSerialized: {`);
-        lines.push(getConfigValuesSerialized(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true })));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true, isDev }), '    '));
         lines.push(`    },`);
-        // Imported config values
-        const whitespace = '    ';
-        lines.push(`${whitespace}configValuesImported: [`);
-        Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
-            const configValue = pageConfig.configValues[configName];
-            if (configValue)
-                return;
-            const configValueSource = sources[0];
-            assert(configValueSource);
-            if (!configValueSource.configEnv.eager)
-                return;
-            if (!isRuntimeEnvMatch(configValueSource.configEnv, { isForClientSide, isClientRouting, isEager: true }))
-                return;
-            lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, importStatements));
-        });
-        lines.push(`${whitespace}],`);
         lines.push(`  },`);
     });
     const code = lines.join('\n');
     return code;
 }
-function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements) {
+function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements) {
     const lines = [];
-    /* Nothing (yet)
-    lines.push(`  configValuesSerialized: {`)
-    lines.push(`  },`)
-    */
-    lines.push(`  configValuesImported: [`);
-    objectEntries(pageConfigGlobal.configValueSources).forEach(([configName, sources]) => {
-        if (configName === 'onBeforeRoute') {
-            // if( isForClientSide && !isClientRouting ) return
-        }
-        else if (configName === 'onPrerenderStart') {
-            if (isDev || isForClientSide) {
-                // Only load onPrerenderStart() in server production runtime
-                return;
-            }
-        }
-        else {
-            assert(false);
-        }
-        const configValueSource = sources[0];
-        assert(configValueSource);
-        const whitespace = '    ';
-        lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, importStatements));
-    });
-    lines.push(`  ],`);
+    lines.push(`  configValuesSerialized: {`);
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true, isDev }), '    '));
+    lines.push(`  },`);
     const code = lines.join('\n');
     return code;
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/isRuntimeEnvMatch.d.ts

@@ -4,4 +4,5 @@ declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtime: {
     isForClientSide: boolean;
     isClientRouting: boolean;
     isEager: boolean;
+    isDev: boolean;
 }): boolean;

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

@@ -14,5 +14,11 @@ function isRuntimeEnvMatch(configEnv, runtime) {
     // Eager
     if (runtime.isEager !== !!configEnv.eager)
         return false;
+    // Production/development
+    if (
+    //
+    (configEnv.production === true && runtime.isDev) ||
+        (configEnv.production === false && !runtime.isDev))
+        return false;
     return true;
 }

package/dist/esm/node/prerender/runPrerender.js

@@ -16,7 +16,7 @@ import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
 import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
-import { getConfigValue } from '../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValue.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
@@ -27,6 +27,7 @@ import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
+import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -114,7 +115,7 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
     // V1 design
     pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
-        const configValue = getConfigValue(pageConfig, configName, 'boolean');
+        const configValue = getConfigValueBuildTime(pageConfig, configName, 'boolean');
         if (configValue?.value === false) {
             const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
             assert(configValueFilePathToShowToUser);
@@ -473,7 +474,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             if (pageContext._pageConfigs.length > 0) {
                 const pageConfig = pageContext._pageConfigs.find((p) => p.pageId === pageId);
                 assert(pageConfig);
-                usesClientRouter = getConfigValue(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+                usesClientRouter = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
             }
             else {
                 usesClientRouter = globalContext.pluginManifest.usesClientRouter;

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -107,7 +107,7 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
         });
     }
     // The JavaScript entry <script> tag
-    const scriptEntry = await mergeScriptEntries(pageAssets, isProduction);
+    const scriptEntry = await mergeScriptEntries(pageAssets);
     if (scriptEntry) {
         htmlTags.push({
             htmlTag: scriptEntry,
@@ -128,11 +128,11 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     });
     return htmlTags;
 }
-async function mergeScriptEntries(pageAssets, isProduction) {
+async function mergeScriptEntries(pageAssets) {
     const scriptEntries = pageAssets.filter((pageAsset) => pageAsset.isEntry && pageAsset.assetType === 'script');
     const viteScripts = await getViteDevScripts();
     const scriptTagsHtml = `${viteScripts}${scriptEntries.map((asset) => inferAssetTag(asset)).join('')}`;
-    const scriptTag = mergeScriptTags(scriptTagsHtml, isProduction);
+    const scriptTag = mergeScriptTags(scriptTagsHtml);
     return scriptTag;
 }
 function getPageContextJsonScriptTag(pageContext) {

package/dist/esm/node/runtime/html/injectAssets/getViteDevScripts.js

@@ -1,6 +1,6 @@
 export { getViteDevScripts };
 import { getGlobalContext } from '../../globalContext.js';
-import { assert, assertUsage } from '../../utils.js';
+import { assert, assertUsage, assertWarning } from '../../utils.js';
 import pc from '@brillout/picocolors';
 async function getViteDevScripts() {
     const globalContext = getGlobalContext();
@@ -16,7 +16,8 @@ async function getViteDevScripts() {
     assertUsage(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), 'Vite plugins that minify the HTML are not supported by vike, see https://github.com/vikejs/vike/issues/224');
     assertUsage(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), 'You are using a Vite Plugin that transforms the HTML in a way that conflicts with vike. Create a new GitHub ticket to discuss a solution.');
     const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
-    assert(viteInjection.includes('script'), { viteInjection });
+    assert(viteInjection.includes('script'));
+    assertWarning(!viteInjection.includes('import('), 'Unexpected Vite HMR code. Reach out to a Vike maintainer on GitHub.', { onlyOnce: true });
     const scriptTags = viteInjection;
     return scriptTags;
 }

package/dist/esm/node/runtime/html/injectAssets/mergeScriptTags.d.ts

@@ -1,2 +1,2 @@
 export { mergeScriptTags };
-declare function mergeScriptTags(scriptTagsHtml: string, isProduction: boolean): string;
+declare function mergeScriptTags(scriptTagsHtml: string): string;

package/dist/esm/node/runtime/html/injectAssets/mergeScriptTags.js

@@ -4,7 +4,7 @@ import { scriptAttrs } from './inferHtmlTags.js';
 const scriptRE = /(<script\b(?:\s[^>]*>|>))(.*?)<\/script>/gims;
 const srcRE = /\bsrc\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
 const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
-function mergeScriptTags(scriptTagsHtml, isProduction) {
+function mergeScriptTags(scriptTagsHtml) {
     let scriptTag = '';
     const scripts = parseScripts(scriptTagsHtml);
     // We need to merge module scripts to ensure execution order
@@ -19,13 +19,7 @@ function mergeScriptTags(scriptTagsHtml, isProduction) {
                 const hasInnerHtml = !!innerHtml.trim();
                 if (src) {
                     assert(!hasInnerHtml);
-                    if (isProduction) {
-                        contents.push(`import ${JSON.stringify(src)};`);
-                    }
-                    else {
-                        // Ensure HMR preamble code is executed before client entries
-                        contents.push(`import(${JSON.stringify(src)});`);
-                    }
+                    contents.push(`import ${JSON.stringify(src)};`);
                 }
                 else if (hasInnerHtml) {
                     innerHtml = innerHtml.split('\n').filter(Boolean).join('\n');

package/dist/esm/node/runtime/renderPage/analyzePage.js

@@ -4,12 +4,16 @@ import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageC
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
 import { getGlobalContext } from '../globalContext.js';
-import { getClientEntry } from '../../shared/getClientEntry.js';
+import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValue.js';
 function analyzePage(pageFilesAll, pageConfig, pageId) {
     if (pageConfig) {
         const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
-        const clientFilePath = getClientEntry(pageConfig);
-        const clientEntry = !isClientSideRenderable ? clientFilePath : getVikeClientEntry(isClientRouting);
+        const clientEntries = [];
+        const clientFilePath = getConfigValueRuntime(pageConfig, 'client', 'string')?.value ?? null;
+        if (clientFilePath)
+            clientEntries.push(clientFilePath);
+        if (isClientSideRenderable)
+            clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
             id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
@@ -41,15 +45,13 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
           }
         })
         */
-        const clientEntries = [];
-        if (clientEntry) {
+        clientEntries.forEach((clientEntry) => {
             clientDependencies.push({
                 id: clientEntry,
                 onlyAssets: false,
                 eagerlyImported: false
             });
-            clientEntries.push(clientEntry);
-        }
+        });
         return {
             isHtmlOnly: !isClientSideRenderable,
             isClientRouting,

package/dist/esm/node/runtime/renderPage/createHttpResponseObject/getCacheControl.js

@@ -1,13 +1,13 @@
 export { getCacheControl };
 import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
-import { getConfigValue } from '../../../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValue.js';
 const defaultValue = 'no-store, max-age=0';
 function getCacheControl(pageId, pageConfigs) {
     // TODO/v1-release: remove
     if (pageConfigs.length === 0)
         return defaultValue;
     const pageConfig = getPageConfig(pageId, pageConfigs);
-    const configValue = getConfigValue(pageConfig, 'cacheControl', 'string');
+    const configValue = getConfigValueRuntime(pageConfig, 'cacheControl', 'string');
     const value = configValue?.value;
     if (value)
         return value;

package/dist/esm/node/runtime/renderPage/loadUserFilesServerSide.d.ts

@@ -14,7 +14,7 @@ type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContex
 type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
 declare function loadUserFilesServerSide(pageContext: {
     _pageId: string;
-} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageContextExports & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.d.ts

@@ -65,7 +65,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+    } & import("../../../shared/getPageFiles.js").PageContextExports & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];
@@ -116,7 +116,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+    } & import("../../../shared/getPageFiles.js").PageContextExports & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];
@@ -168,7 +168,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+    } & import("../../../shared/getPageFiles.js").PageContextExports & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];
@@ -219,7 +219,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles/getExports.js").PageContextExports & {
+    } & import("../../../shared/getPageFiles.js").PageContextExports & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -21,7 +21,6 @@ import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
-import { assertV1Design } from '../../shared/assertV1Design.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -171,7 +170,8 @@ async function getRenderContext() {
     const globalContext = getGlobalContext();
     const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await getPageFilesAll(false, globalContext.isProduction);
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    assertV1Design(pageFilesAll.length > 0, pageConfigs, pageFilesAll);
+    // We assume assertV1Design() was already called at build-time
+    assert(pageFilesAll.length === 0 || pageConfigs.length === 0);
     const renderContext = {
         pageFilesAll: pageFilesAll,
         pageConfigs,