vike 0.4.259 → 0.4.260

package/dist/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -9,10 +9,11 @@ export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
+export { EARLY_SETTINGS };
 export type { VikeConfigInternal };
 export type { PageConfigBuildTimeBeforeComputed };
-import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../types/PageConfig.js';
-import { type ConfigDefinitionsInternal, type ConfigDefinitionInternal } from './resolveVikeConfigInternal/metaBuiltIn.js';
+import type { PageConfigGlobalBuildTime, ConfigEnv, PageConfigBuildTime, DefinedAtFilePath } from '../../../types/PageConfig.js';
+import { type ConfigDefinitionsInternal } from './resolveVikeConfigInternal/metaBuiltIn.js';
 import { type GlobalConfigPublic } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
 import { type PlusFile } from './resolveVikeConfigInternal/getPlusFilesByLocationId.js';
 import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
@@ -62,8 +63,22 @@ declare function getVikeConfigFromCliOrEnv(): {
     configFromCliOptions: import("../../cli/parseCli.js").CliOptions | null;
     configFromEnvVar: Record<string, unknown> | null;
 };
+declare const EARLY_SETTINGS: readonly ["root", "mode"];
 type PageConfigBuildTimeBeforeComputed = Omit<PageConfigBuildTime, 'configValuesComputed'>;
-declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitionsInternal, configName: string): ConfigDefinitionInternal | null;
+declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitionsInternal, configName: string): {
+    env: ConfigEnv;
+    cumulative?: boolean;
+    effect?: import("./resolveVikeConfigInternal/metaBuiltIn.js").ConfigEffect;
+    eager?: boolean;
+    global?: boolean | ((value: unknown, moreInfo: {
+        isGlobalLocation: boolean;
+    }) => boolean);
+    vite?: boolean;
+    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
+    _valueIsFilePath?: true;
+    _userEffectDefinedAtFilePath?: DefinedAtFilePath;
+    isDefinedByPeerDependency?: undefined;
+} | null;
 declare function getConfVal(plusFile: PlusFile, configName: string): null | {
     value: unknown;
     valueIsLoaded: true;

package/dist/node/vite/shared/resolveVikeConfigInternal.js

@@ -10,14 +10,13 @@ export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
+export { EARLY_SETTINGS };
 import { deepEqual } from '../../../utils/deepEqual.js';
 import { assertKeys } from '../../../utils/assertKeys.js';
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { getMostSimilar } from '../../../utils/getMostSimilar.js';
-import { includes } from '../../../utils/includes.js';
 import { objectEntries } from '../../../utils/objectEntries.js';
 import { objectFromEntries } from '../../../utils/objectFromEntries.js';
-import { objectKeys } from '../../../utils/objectKeys.js';
 import { makeLast } from '../../../utils/sorter.js';
 import { assert, assertUsage, assertWarning } from '../../../utils/assert.js';
 import { checkType } from '../../../utils/checkType.js';
@@ -41,11 +40,14 @@ import pc from '@brillout/picocolors';
 import { getConfigDefinedAt, getDefinedByString, } from '../../../shared-server-client/page-configs/getConfigDefinedAt.js';
 import { loadPointerImport, loadValueFile } from './resolveVikeConfigInternal/loadFileAtConfigTime.js';
 import { resolvePointerImport } from './resolveVikeConfigInternal/resolvePointerImport.js';
+import { parsePointerImportData } from './resolveVikeConfigInternal/pointerImports.js';
 import { getFilePathResolved } from './getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared-server-client/page-configs/getConfigValueBuildTime.js';
 import { resolveGlobalConfigPublic, } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
 import { getConfigValuesBase, isJsonValue, } from '../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
-import { getPlusFilesByLocationId, } from './resolveVikeConfigInternal/getPlusFilesByLocationId.js';
+import { getPlusFilesByLocationId, getPlusFileFromConfigFile, } from './resolveVikeConfigInternal/getPlusFilesByLocationId.js';
+import { assertRouteString } from '../../../shared-server-client/route/resolveRouteString.js';
+import { getExtensionName } from './resolveVikeConfigInternal/assertExtensions.js';
 import { getEnvVarObject } from './getEnvVarObject.js';
 import { getVikeApiOperation } from '../../../shared-server-node/api-context.js';
 import { getCliOptions } from '../../cli/context.js';
@@ -221,7 +223,8 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
         globalObject.isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
-    setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
+    setCliAndApiOptions(pageConfigGlobal, pageConfigs, configDefinitionsResolved);
+    warnEarlySettingsInConfigFile(pageConfigGlobal);
     const globalConfigPublic = resolveGlobalConfig(pageConfigGlobal, pageConfigs);
     const prerenderContext = await resolvePrerenderContext({
         config: globalConfigPublic.config,
@@ -254,8 +257,7 @@ async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbu
     // We use `plusFilesByLocationId` in order to allow non-global Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
     plusFilesByLocationIdOrdered, (configDef) => !!configDef.global);
     await loadCustomConfigBuildTimeFiles(plusFilesByLocationId, configDefinitionsGlobal, userRootDir, esbuildCache);
-    const configDefinitionsAll = getConfigDefinitions(Object.values(plusFilesByLocationId).flat());
-    const configNamesKnownAll = Object.keys(configDefinitionsAll);
+    const configNamesKnownAll = getConfigNames(Object.values(plusFilesByLocationId).flat());
     const configNamesKnownGlobal = Object.keys(configDefinitionsGlobal);
     assert(configNamesKnownGlobal.every((configName) => configNamesKnownAll.includes(configName)));
     const configDefinitionsLocal = {};
@@ -265,9 +267,13 @@ async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbu
             .map(([, plusFiles]) => plusFiles)
             .flat()
             .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderPage(plusFile1, plusFile2, locationIdPage, null));
-        const configDefinitions = getConfigDefinitions(plusFilesRelevant, (configDef) => configDef.global !== true);
+        const { configDefinitions, peerDependencyConfigNames } = collectConfigDefinitions(plusFilesRelevant, (configDef) => configDef.global !== true);
         await loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache);
-        const configNamesKnownLocal = unique([...Object.keys(configDefinitions), ...configNamesKnownGlobal]);
+        const configNamesKnownLocal = unique([
+            ...Object.keys(configDefinitions),
+            ...peerDependencyConfigNames,
+            ...configNamesKnownGlobal,
+        ]);
         assert(configNamesKnownLocal.every((configName) => configNamesKnownAll.includes(configName)));
         configDefinitionsLocal[locationIdPage] = {
             configDefinitions,
@@ -279,11 +285,10 @@ async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbu
     const configDefinitionsResolved = {
         configDefinitionsGlobal,
         configDefinitionsLocal,
-        configDefinitionsAll,
         configNamesKnownAll,
         configNamesKnownGlobal,
     };
-    assertKnownConfigs(configDefinitionsResolved);
+    warnUnknownConfigs(configDefinitionsResolved);
     return configDefinitionsResolved;
 }
 // Load value files (with `env.config===true`) of *custom* configs.
@@ -319,35 +324,94 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesByLocationI
     assertPageConfigGlobal(pageConfigGlobal, plusFilesByLocationId);
     const pageConfigs = objectEntries(configDefinitionsResolved.configDefinitionsLocal)
         .filter(([_locationId, { plusFiles }]) => isDefiningPage(plusFiles))
-        .map(([locationId, { configDefinitions, plusFilesRelevant }]) => {
-        const configDefinitionsLocal = configDefinitions;
-        const configValueSources = {};
-        objectEntries(configDefinitionsLocal)
-            .filter(([_configName, configDef]) => configDef.global !== true)
-            .forEach(([configName, configDef]) => {
-            const sources = resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, false, plusFilesByLocationId);
-            if (sources.length === 0)
-                return;
-            configValueSources[configName] = sources;
-        });
-        const pageConfigRoute = determineRouteFilesystem(locationId, configValueSources);
-        applyEffects(configValueSources, configDefinitionsLocal, plusFilesByLocationId);
-        sortConfigValueSources(configValueSources, locationId);
-        const pageConfig = {
-            pageId: locationId,
-            ...pageConfigRoute,
-            configDefinitions: configDefinitionsLocal,
-            plusFiles: plusFilesRelevant,
-            configValueSources,
-        };
-        const configValuesComputed = getComputed(pageConfig);
-        objectAssign(pageConfig, { configValuesComputed });
-        checkType(pageConfig);
-        return pageConfig;
-    });
+        .map(([locationId, { configDefinitions, plusFilesRelevant }]) => resolvePageConfigBuildTime(locationId, locationId, plusFilesRelevant, configDefinitions, plusFilesByLocationId, userRootDir));
+    // Pages defined programmatically via +pages
+    pageConfigs.push(...getProgrammaticPageConfigs(configDefinitionsResolved, plusFilesByLocationId, userRootDir));
     assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal };
 }
+function resolvePageConfigBuildTime(pageId, locationId, plusFilesRelevant, configDefinitionsLocal, plusFilesByLocationId, userRootDir) {
+    const configValueSources = {};
+    objectEntries(configDefinitionsLocal)
+        .filter(([_configName, configDef]) => configDef.global !== true)
+        .forEach(([configName, configDef]) => {
+        const sources = resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, false, plusFilesByLocationId);
+        if (sources.length === 0)
+            return;
+        configValueSources[configName] = sources;
+    });
+    const pageConfigRoute = determineRouteFilesystem(locationId, configValueSources);
+    applyEffects(configValueSources, configDefinitionsLocal, plusFilesByLocationId);
+    sortConfigValueSources(configValueSources, locationId);
+    const pageConfig = {
+        pageId,
+        ...pageConfigRoute,
+        configDefinitions: configDefinitionsLocal,
+        plusFiles: plusFilesRelevant,
+        configValueSources,
+    };
+    const configValuesComputed = getComputed(pageConfig);
+    objectAssign(pageConfig, { configValuesComputed });
+    checkType(pageConfig);
+    return pageConfig;
+}
+/**
+ * Get the pages defined programmatically via +pages
+ */
+function getProgrammaticPageConfigs(configDefinitionsResolved, plusFilesByLocationId, userRootDir) {
+    const pageConfigs = [];
+    const entryIndexByLocationId = {};
+    // +pages can be set in a +config.js or +pages.js file — getConfVal() handles both
+    const plusFilesDefiningPages = Object.values(plusFilesByLocationId)
+        .flat()
+        .filter((plusFile) => {
+        const confVal = getConfVal(plusFile, 'pages');
+        return !!confVal && confVal.valueIsLoaded;
+    });
+    plusFilesDefiningPages.forEach((plusFileDefiningPages) => {
+        const locationIdAnchor = plusFileDefiningPages.locationId;
+        const local = configDefinitionsResolved.configDefinitionsLocal[locationIdAnchor];
+        assert(local);
+        const confVal = getConfVal(plusFileDefiningPages, 'pages');
+        assert(confVal?.valueIsLoaded);
+        const pages = confVal.value;
+        const definedAt = plusFileDefiningPages.filePath.filePathToShowToUser;
+        assertUsage(Array.isArray(pages), `${definedAt} sets ${pc.cyan('+pages')} to an invalid value: it should be an array`);
+        pages.forEach((entry, i) => {
+            const definedAtEntry = `${definedAt} > ${pc.cyan(`pages[${i}]`)}`;
+            assertUsage(isObject(entry), `${definedAtEntry} should be an object`);
+            assertUsage('route' in entry, `${definedAtEntry} should set ${pc.cyan('+route')}`);
+            // A Route Function can't be inlined (a function can't be serialized to the runtime): it must be a pointer import
+            assertUsage(!isCallable(entry.route), `${definedAtEntry} sets ${pc.cyan('+route')} to a function, but a Route Function can't be inlined — define the Route Function in a separate file and import it with ${pc.cyan("{ type: 'vike:pointer' }")} instead (so that Vike can load it at runtime)`);
+            assertUsage(typeof entry.route === 'string', `${definedAtEntry} should set ${pc.cyan('+route')} to a Route String or Route Function`);
+            // A Route String is validated now; a Route Function (pointer import) is validated at runtime.
+            if (!parsePointerImportData(entry.route))
+                assertRouteString(entry.route, `${definedAtEntry} sets an invalid`);
+            assertUsage(!('extends' in entry), `${definedAtEntry} sets ${pc.cyan('+extends')} which isn't supported for programmatically defined pages`);
+            const index = entryIndexByLocationId[locationIdAnchor] ?? 0;
+            entryIndexByLocationId[locationIdAnchor] = index + 1;
+            const base = locationIdAnchor === '/' ? '' : locationIdAnchor;
+            // The page's virtual locationId = its inheritance position (a child of the +config.js that defines +pages) so that:
+            // - The page's own values (`entry`) only apply to that page
+            // - The page inherits as usual
+            const locationIdVirtual = `${base}/(+pages)/entry:${index}`;
+            // Hack: treat `entry` as the page's own +config.js — getPlusFileFromConfigFile() makes pointer imports (e.g. +Page) resolve to runtime imports.
+            const plusFileVirtual = getPlusFileFromConfigFile({ fileExports: { default: entry }, filePath: plusFileDefiningPages.filePath, extendsFilePaths: [] }, false, locationIdVirtual, userRootDir);
+            getConfigNamesSetByPlusFile(plusFileVirtual).forEach((configName) => {
+                // Warn on unknown configs
+                isUnknownConfig(configName, local.configNamesKnownLocal, configDefinitionsResolved, locationIdAnchor, true, definedAtEntry);
+                // A global config (e.g. +onBeforeRoute) applies app-wide and can't be set on a single page. (We check `global === true` so conditionally-global configs such as +prerender, whose `global` is a function, are still allowed per-page.)
+                const configDefGlobal = configDefinitionsResolved.configDefinitionsGlobal[configName];
+                assertUsage(configDefGlobal?.global !== true, `${definedAtEntry} sets the global config ${pc.cyan(`+${configName}`)} which can't be set on a single page — set it at a global config file instead`);
+            });
+            // The page's own values (`entry`) first (most-specific), then the inherited configs
+            const plusFilesRelevant = [plusFileVirtual, ...local.plusFilesRelevant];
+            // Perf: resolvePageConfigBuildTime() re-resolves the inherited config per entry — fine for typical +pages array length. But for very large +pages arrays this might be too slow: consider resolving the inherited part once and re-use.
+            pageConfigs.push(resolvePageConfigBuildTime(locationIdVirtual, locationIdVirtual, plusFilesRelevant, local.configDefinitions, plusFilesByLocationId, userRootDir));
+        });
+    });
+    return pageConfigs;
+}
 function assertPageConfigGlobal(pageConfigGlobal, plusFilesByLocationId) {
     Object.entries(pageConfigGlobal.configValueSources).forEach(([configName, sources]) => {
         assertGlobalConfigLocation(configName, sources, plusFilesByLocationId, pageConfigGlobal.configDefinitions);
@@ -394,10 +458,18 @@ function assertGlobalConfigLocation(configName, sources, plusFilesByLocationId,
     });
 }
 function assertPageConfigs(pageConfigs) {
+    assertNoDuplicatePageIds(pageConfigs);
     pageConfigs.forEach((pageConfig) => {
         assertOnBeforeRenderEnv(pageConfig);
     });
 }
+function assertNoDuplicatePageIds(pageConfigs) {
+    const seen = new Set();
+    pageConfigs.forEach(({ pageId }) => {
+        assert(!seen.has(pageId));
+        seen.add(pageId);
+    });
+}
 function assertOnBeforeRenderEnv(pageConfig) {
     const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
     if (!onBeforeRenderConfig)
@@ -461,32 +533,50 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
                 filePathAbsoluteUserRootDir: '/vite.config.js',
             }),
             fileExportPathToShowToUser: null,
-        }));
+        }, pageConfigGlobal.configDefinitions));
     });
 }
-function setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved) {
+function setCliAndApiOptions(pageConfigGlobal, pageConfigs, configDefinitionsResolved) {
     // Vike API — passed options [lowest precedence]
     const vikeApiOperation = getVikeApiOperation();
     if (vikeApiOperation?.options.vikeConfig) {
-        addSources(vikeApiOperation.options.vikeConfig, { definedBy: 'api', operation: vikeApiOperation.operation }, false);
+        addSources(vikeApiOperation.options.vikeConfig, {
+            definedBy: 'api',
+            operation: vikeApiOperation.operation,
+        });
     }
     const { configFromCliOptions, configFromEnvVar } = getVikeConfigFromCliOrEnv();
     // Vike CLI options
     if (configFromCliOptions) {
-        addSources(configFromCliOptions, { definedBy: 'cli' }, true);
+        addSources(configFromCliOptions, { definedBy: 'cli' });
     }
     // VIKE_CONFIG [highest precedence]
     if (configFromEnvVar) {
-        addSources(configFromEnvVar, { definedBy: 'env' }, false);
+        addSources(configFromEnvVar, { definedBy: 'env' });
     }
     return;
-    function addSources(configValues, definedBy, exitOnError) {
+    function addSources(configValues, definedBy) {
         Object.entries(configValues).forEach(([configName, value]) => {
             var _a;
             const sourceName = `The ${getDefinedByString(definedBy, configName)}`;
-            assertKnownConfig(configName, configDefinitionsResolved.configNamesKnownGlobal, configDefinitionsResolved, '/', false, sourceName, exitOnError);
-            const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
-            sources.unshift(getSourceNonConfigFile(configName, value, definedBy));
+            const isUnknown = isUnknownConfig(configName, configDefinitionsResolved.configNamesKnownAll, configDefinitionsResolved, '/', false, sourceName);
+            if (isUnknown)
+                return;
+            if (configName in pageConfigGlobal.configDefinitions) {
+                const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+                const source = getSourceNonConfigFile(configName, value, definedBy, pageConfigGlobal.configDefinitions);
+                sources.unshift(source);
+                return;
+            }
+            // Non-global config: inject into every page config that knows about it (highest precedence)
+            pageConfigs.forEach((pageConfig) => {
+                var _a;
+                if (!(configName in pageConfig.configDefinitions))
+                    return;
+                const sources = ((_a = pageConfig.configValueSources)[configName] ?? (_a[configName] = []));
+                const source = getSourceNonConfigFile(configName, value, definedBy, pageConfig.configDefinitions);
+                sources.unshift(source);
+            });
         });
     }
 }
@@ -503,9 +593,9 @@ function getVikeConfigFromCliOrEnv() {
         configFromEnvVar,
     };
 }
-function getSourceNonConfigFile(configName, value, definedAt) {
-    assert(includes(objectKeys(metaBuiltIn), configName));
-    const configDef = metaBuiltIn[configName];
+function getSourceNonConfigFile(configName, value, definedAt, configDefinitionsGlobal) {
+    const configDef = configDefinitionsGlobal[configName] ?? metaBuiltIn[configName];
+    assert(configDef);
     const source = {
         valueIsLoaded: true,
         value,
@@ -518,6 +608,30 @@ function getSourceNonConfigFile(configName, value, definedAt) {
     };
     return source;
 }
+// Settings that must be resolved early before Vike crawls +config.js files:
+// - They can't be defined inside +config.js files.
+// - They must be set early (via Vike's CLI/API options or VIKE_CONFIG), and read early before Vike's main config resolution.
+const EARLY_SETTINGS = [
+    // +root determines where Vike looks for +config.js files (so it can't be defined inside +config.js itself)
+    'root',
+    // +mode affects which vite.config.js environment is loaded
+    'mode',
+];
+function warnEarlySettingsInConfigFile(pageConfigGlobal) {
+    for (const configName of EARLY_SETTINGS) {
+        const sources = pageConfigGlobal.configValueSources[configName];
+        if (!sources)
+            continue;
+        for (const source of sources) {
+            if (!source.plusFile) {
+                // `plusFile === null` => source comes from Vike CLI argument, Vike API option, or VIKE_CONFIG
+                continue;
+            }
+            const configDefinedAt = getConfigDefinedAt('Config', configName, source.definedAt);
+            assertWarning(false, `${configDefinedAt} has no effect: it can't be set from a ${pc.cyan('+')} file — see ${pc.underline(`https://vike.dev/${configName}`)}`, { onlyOnce: true });
+        }
+    }
+}
 function sortConfigValueSources(configValueSources, locationIdPage) {
     Object.entries(configValueSources).forEach(([configName, sources]) => {
         sources
@@ -605,9 +719,10 @@ function sortPlusFilesSameLocationId(plusFile1, plusFile2, configName) {
     return 0;
 }
 function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal, plusFilesByLocationId) {
-    let sources = plusFilesRelevant
-        .filter((plusFile) => isDefiningConfig(plusFile, configName))
-        .flatMap((plusFile) => getConfigValueSources(configName, plusFile, configDef, userRootDir));
+    let plusFilesConfig = plusFilesRelevant.filter((plusFile) => isDefiningConfig(plusFile, configName));
+    // Make Vike extension installation idempotent. (Don't cumulate configs twice of an extension installed twice.) Since `plusFilesRelevant` is ordered by inheritance the occurrence closest to the page's locationId is the one kept.
+    plusFilesConfig = dedupeExtensions(plusFilesConfig);
+    let sources = plusFilesConfig.flatMap((plusFile) => getConfigValueSources(configName, plusFile, configDef, userRootDir));
     // Filter hydrid global-local configs
     if (!isCallable(configDef.global)) {
         // Already filtered
@@ -628,6 +743,20 @@ function resolveConfigValueSources(configName, configDef, plusFilesRelevant, use
 function isDefiningConfig(plusFile, configName) {
     return getConfigNamesSetByPlusFile(plusFile).includes(configName);
 }
+function dedupeExtensions(plusFiles) {
+    const seen = new Set();
+    return plusFiles.filter((plusFile) => {
+        if (!plusFile.isConfigFile || !plusFile.isExtensionConfig)
+            return true;
+        const name = getExtensionName(plusFile);
+        // The extension's `name` is guaranteed by assertExtensionsConventions()
+        assert(name);
+        if (seen.has(name))
+            return false;
+        seen.add(name);
+        return true;
+    });
+}
 function getConfigValueSources(configName, plusFile, configDef, userRootDir) {
     const confVal = getConfVal(plusFile, configName);
     assert(confVal);
@@ -752,6 +881,9 @@ function isDefiningPage(plusFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
+function isDefiningProgrammaticPages(plusFiles) {
+    return plusFiles.some((plusFile) => getConfigNamesSetByPlusFile(plusFile).includes('pages'));
+}
 function resolveIsGlobalValue(configDefGlobal, source, plusFilesByLocationId) {
     assert(source.valueIsLoaded);
     let isGlobal;
@@ -772,8 +904,16 @@ function getConfigNamesSetByPlusFile(plusFile) {
         return Object.keys(plusFile.fileExportsByConfigName);
     }
 }
+function getConfigNames(plusFilesRelevant, filter) {
+    const { configDefinitions, peerDependencyConfigNames } = collectConfigDefinitions(plusFilesRelevant, filter);
+    return [...Object.keys(configDefinitions), ...peerDependencyConfigNames];
+}
 function getConfigDefinitions(plusFilesRelevant, filter) {
+    return collectConfigDefinitions(plusFilesRelevant, filter).configDefinitions;
+}
+function collectConfigDefinitions(plusFilesRelevant, filter) {
     let configDefinitions = { ...metaBuiltIn };
+    const peerDependencyConfigNames = new Set();
     // Add user-land meta configs
     plusFilesRelevant
         .slice()
@@ -799,14 +939,9 @@ function getConfigDefinitions(plusFilesRelevant, filter) {
         });
         objectEntries(meta).forEach(([configName, configDefinitionUserLand]) => {
             if ('isDefinedByPeerDependency' in configDefinitionUserLand) {
-                /* vike-server@1.0.24 wrongfully sets `stream: { env: { config: true }, isDefinedByPeerDependency: true }`
-                assert(deepEqual(Object.keys(configDefinitionUserLand), ['isDefinedByPeerDependency']))
-                //*/
-                if (!configDefinitions[configName]) {
-                    configDefinitions[configName] = {
-                        env: { client: false, server: false, config: false },
-                    };
-                }
+                assert(deepEqual(Object.keys(configDefinitionUserLand), ['isDefinedByPeerDependency']));
+                if (!configDefinitions[configName])
+                    peerDependencyConfigNames.add(configName);
                 return;
             }
             // User can override an existing config definition
@@ -814,12 +949,13 @@ function getConfigDefinitions(plusFilesRelevant, filter) {
                 ...configDefinitions[configName],
                 ...configDefinitionUserLand,
             };
+            peerDependencyConfigNames.delete(configName);
         });
     });
     if (filter) {
         configDefinitions = Object.fromEntries(Object.entries(configDefinitions).filter(([_configName, configDef]) => filter(configDef)));
     }
-    return configDefinitions;
+    return { configDefinitions, peerDependencyConfigNames };
 }
 function assertMetaUsage(metaVal, metaConfigDefinedAt) {
     if (!isObject(metaVal)) {
@@ -969,33 +1105,36 @@ function getComputed(pageConfig) {
     });
     return configValuesComputed;
 }
-// Show error message upon unknown config
-function assertKnownConfigs(configDefinitionsResolved) {
+function warnUnknownConfigs(configDefinitionsResolved) {
     objectEntries(configDefinitionsResolved.configDefinitionsLocal).forEach(([_locationId, { configNamesKnownLocal, plusFiles }]) => {
         plusFiles.forEach((plusFile) => {
             const configNames = getConfigNamesSetByPlusFile(plusFile);
             configNames.forEach((configName) => {
                 const { locationId } = plusFile;
                 const sourceName = plusFile.filePath.filePathToShowToUser;
-                assertKnownConfig(configName, configNamesKnownLocal, configDefinitionsResolved, locationId, true, sourceName, false);
+                isUnknownConfig(configName, configNamesKnownLocal, configDefinitionsResolved, locationId, true, sourceName);
             });
         });
     });
 }
-function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitionsResolved, locationId, isPlusFile, sourceName, exitOnError) {
+function isUnknownConfig(configName, configNamesKnownRelevant, configDefinitionsResolved, locationId, isPlusFile, sourceName) {
     const { configNamesKnownAll } = configDefinitionsResolved;
     if (configNamesKnownRelevant.includes(configName)) {
         assert(configNamesKnownAll.includes(configName));
-        return;
+        return false;
     }
     const configNameColored = pc.cyan(configName);
+    const warn = (msg) => {
+        assertWarning(false, msg, { onlyOnce: true });
+        return true;
+    };
     // Inheritance issue: config is known but isn't defined at `locationId`
     if (configNamesKnownAll.includes(configName)) {
-        assertUsage(false, `${sourceName} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`, { exitOnError });
+        return warn(`${sourceName} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`);
     }
     const errMsg = isPlusFile
-        ? `${sourceName} sets an unknown config ${configNameColored}`
-        : `${sourceName} sets an unknown Vike config, see ${pc.underline('https://vike.dev/cli')} for the list of CLI options`;
+        ? `${sourceName} sets an unknown config ${configNameColored} — for the list of built-in configs, see ${pc.underline('https://vike.dev/settings')} and ${pc.underline('https://vike.dev/hooks')}`
+        : `${sourceName} sets an unknown Vike config — see ${pc.underline('https://vike.dev/cli')} for the list of CLI options`;
     assert(errMsg.includes(configName));
     // Missing vike-{react,vue,solid} installation
     {
@@ -1014,7 +1153,7 @@ function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitio
         if (configName in knownVikeExntensionConfigs) {
             const requiredVikeExtension = joinEnglish(knownVikeExntensionConfigs[configName].map((e) => pc.bold(e)), 'or');
             const errMsgEnhanced = `${errMsg}. If you want to use the configuration ${configNameColored} documented at ${pc.underline(`https://vike.dev/${configName}`)} then make sure to install ${requiredVikeExtension}. (Alternatively, you can define ${configNameColored} yourself by using ${pc.cyan('meta')}, see ${pc.underline('https://vike.dev/meta')} for more information.)`;
-            assertUsage(false, errMsgEnhanced, { exitOnError });
+            return warn(errMsgEnhanced);
         }
     }
     // Similarity hint
@@ -1031,9 +1170,9 @@ function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitio
         if (configName === 'page') {
             errMsgEnhanced += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.cyan('P')} because it defines a UI component: a ubiquitous JavaScript convention is that the name of UI components start with a capital letter.)`;
         }
-        assertUsage(false, errMsgEnhanced, { exitOnError });
+        return warn(errMsgEnhanced);
     }
-    assertUsage(false, errMsg, { exitOnError });
+    return warn(errMsg);
 }
 function determineRouteFilesystem(locationId, configValueSources) {
     const configName = 'filesystemRoutingRoot';
@@ -1151,7 +1290,9 @@ function resolveConfigEnv(configEnv, filePath) {
 /** Whether configs defined in `locationId` apply to every page */
 function isGlobalLocation(locationId, plusFilesByLocationId) {
     const locationIdsPage = objectEntries(plusFilesByLocationId)
-        .filter(([_locationId, plusFiles]) => isDefiningPage(plusFiles))
+        .filter(([_locationId, plusFiles]) => isDefiningPage(plusFiles) ||
+        // Also add locationId if it defines +pages — programmatic pages are anchored there, so a config that doesn't cover them isn't global.
+        isDefiningProgrammaticPages(plusFiles))
         .map(([locationId]) => locationId);
     return locationIdsPage.every((locId) => isInherited(locationId, locId));
 }

package/dist/server/runtime/globalContext.js

@@ -454,9 +454,12 @@ async function createGlobalContext(virtualFileExportsGlobalEntry) {
     debug('createGlobalContext() - done [sync]');
     // We define an early globalContext version synchronously, so that getGlobalContextSync() can be called early.
     // - Required by vike-vercel
-    assert(globalObject.globalContext);
+    const globalContextIsSetEarly = !!globalObject.globalContext;
+    assertWarning(globalContextIsSetEarly, "globalContext isn't set early", { onlyOnce: false });
     const globalContext = await globalContextPromise;
     debug('createGlobalContext() - done [async]');
+    assert(globalContextIsSetEarly); // We deliberately assert after the `await` (otherwise it swallows promise rejections such as an assert() failing synchronously inside `async createGlobalContextShared()`).
+    assert(globalObject.globalContext);
     assertV1Design(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);

package/dist/server/runtime/renderPageServer/createPageContextServer.d.ts

@@ -24,7 +24,10 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
     isPrerendering: boolean;
     _requestId: number;
 } & PageContextInit & {
-    _reqDev?: import("http").IncomingMessage;
+    _nodeDev?: {
+        req: import("http").IncomingMessage;
+        res: import("http").ServerResponse;
+    };
     _reqWeb?: Request;
 } & {
     _globalContext: ({
@@ -100,7 +103,10 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
     _baseServer: string;
     _baseAssets: string;
     _pageContextInit: PageContextInit & {
-        _reqDev?: import("http").IncomingMessage;
+        _nodeDev?: {
+            req: import("http").IncomingMessage;
+            res: import("http").ServerResponse;
+        };
         _reqWeb?: Request;
     } & {
         headers?: Record<string, unknown>;
@@ -132,6 +138,9 @@ declare function createPageContextServerWithoutGlobalContext(pageContextInit: Pa
     isPrerendering: boolean;
     _requestId: number;
 } & PageContextInit & {
-    _reqDev?: import("http").IncomingMessage;
+    _nodeDev?: {
+        req: import("http").IncomingMessage;
+        res: import("http").ServerResponse;
+    };
     _reqWeb?: Request;
 };

package/dist/server/runtime/renderPageServer/html/injectAssets/getHtmlTags.js

@@ -3,7 +3,6 @@ import { assert, assertWarning, assertUsage } from '../../../../../utils/assert.
 import { freezePartial } from '../../../../../utils/freezePartial.js';
 import { isObject } from '../../../../../utils/isObject.js';
 import { getGlobalContextClientSerialized, getPageContextClientSerialized, } from '../serializeContext.js';
-import { sanitizeJson } from './sanitizeJson.js';
 import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
 import { mergeScriptTags } from './mergeScriptTags.js';
 import { getPageConfig } from '../../../../../shared-server-client/page-configs/helpers.js';
@@ -186,7 +185,7 @@ function mergeScriptEntries(pageAssets, viteDevScript, pageContext) {
     return scriptEntry;
 }
 function getPageContextJsonScriptTag(pageContext) {
-    const pageContextClientSerialized = sanitizeJson(getPageContextClientSerialized(pageContext, true));
+    const pageContextClientSerialized = getPageContextClientSerialized(pageContext, true);
     const nonceAttr = inferNonceAttr(pageContext);
     const htmlTag = `<script id="${htmlElementId_pageContext}" type="application/json"${nonceAttr}>${pageContextClientSerialized}</script>`;
     // Used by contra.com https://github.com/gajus
@@ -195,7 +194,7 @@ function getPageContextJsonScriptTag(pageContext) {
     return htmlTag;
 }
 function getGlobalContextJsonScriptTag(pageContext) {
-    const globalContextClientSerialized = sanitizeJson(getGlobalContextClientSerialized(pageContext, true));
+    const globalContextClientSerialized = getGlobalContextClientSerialized(pageContext, true);
     const nonceAttr = inferNonceAttr(pageContext);
     const htmlTag = `<script id="${htmlElementId_globalContext}" type="application/json"${nonceAttr}>${globalContextClientSerialized}</script>`;
     return htmlTag;

package/dist/server/runtime/renderPageServer/html/serializeContext.js

@@ -115,16 +115,11 @@ function serializeValue(value, isHtmlJsonScript, varName) {
     return stringify(value, {
         forbidReactElements: true,
         valueName: varName,
-        // Prevent Google from crawling URLs in JSON:
-        // - https://github.com/vikejs/vike/pull/2603
-        // - https://github.com/brillout/json-serializer/blob/38edbb9945de4938da1e65d6285ce1dd123a45ef/test/main.spec.ts#L44-L95
-        replacer: !isHtmlJsonScript
-            ? undefined
-            : (_key, value) => {
-                if (typeof value === 'string') {
-                    return { replacement: value.replaceAll('/', '\\/'), resolved: false };
-                }
-            },
+        htmlScriptSafe: {
+            // Could be set to `isHtmlJsonScript` but we always use `htmlScriptSafe.escapeScripts` to be extra safe
+            escapeScripts: true,
+            escapeURLs: isHtmlJsonScript,
+        },
     });
 }
 function getPassToClientPageContext(pageContext) {