vike 0.4.222 → 0.4.223-commit-586dbfb

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

@@ -8,7 +8,7 @@ export { getConfigDefinitionOptional };
 import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst } from '../../../utils.js';
 import { configDefinitionsBuiltIn } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
+import { isVikeConfigInvalid, isVikeConfigInvalid_set } from '../../../../runtime/renderPage/isVikeConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
@@ -19,8 +19,8 @@ import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { assertExtensionsRequire } from './getVikeConfig/assertExtensions.js';
-import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
-import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
+import { getPageConfigGlobalUserFriendly, getPageConfigUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getConfigValuesBase, isJsonValue } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { getPlusFilesAll } from './getVikeConfig/getPlusFilesAll.js';
 assertIsNotProductionRuntime();
 let restartVite = false;
@@ -37,7 +37,7 @@ function reloadVikeConfig(config) {
     handleReloadSideEffects();
 }
 async function handleReloadSideEffects() {
-    wasConfigInvalid = !!isConfigInvalid;
+    wasConfigInvalid = !!isVikeConfigInvalid;
     const vikeConfigPromisePrevious = vikeConfigPromise;
     try {
         await vikeConfigPromise;
@@ -52,7 +52,7 @@ async function handleReloadSideEffects() {
         // Let the next handleReloadSideEffects() call handle side effects
         return;
     }
-    if (!isConfigInvalid) {
+    if (!isVikeConfigInvalid) {
         if (wasConfigInvalid) {
             wasConfigInvalid = false;
             logConfigErrorRecover();
@@ -105,13 +105,13 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
     if (!hasError) {
         assert(ret);
         assert(err === undefined);
-        isConfigInvalid_set(false);
+        isVikeConfigInvalid_set(false);
         return ret;
     }
     else {
         assert(ret === undefined);
         assert(err);
-        isConfigInvalid_set({ err });
+        isVikeConfigInvalid_set({ err });
         if (!isDev) {
             assert(getViteDevServer() === null);
             throw err;
@@ -127,7 +127,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                global: getPageConfigUserFriendlyNew({ configValues: {} }),
+                global: getPageConfigGlobalUserFriendly({ pageConfigGlobalValues: {} }),
                 pages: {}
             };
             return dummyData;
@@ -143,18 +143,12 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     // interop vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     // global
-    const configValuesGlobal = getConfigValues(pageConfigGlobal);
-    const global = getPageConfigUserFriendlyNew({ configValues: configValuesGlobal });
-    // TODO/now DEDUPE
+    const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigGlobalUserFriendly({ pageConfigGlobalValues });
     // pages
     const pages = objectFromEntries(pageConfigs.map((pageConfig) => {
-        const configValuesLocal = getConfigValues(pageConfig, true);
-        const configValues = { ...configValuesGlobal, ...configValuesLocal };
-        const page = {
-            ...getPageConfigUserFriendlyNew({ configValues }),
-            route: pageConfig.routeFilesystem?.routeString ?? null
-        };
-        return [pageConfig.pageId, page];
+        const pageConfigValues = getConfigValues(pageConfig, true);
+        return getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfigValues);
     }));
     return { pageConfigs, pageConfigGlobal, global, pages };
 }
@@ -219,13 +213,12 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
                 return;
             configValueSources[configName] = sources;
         });
-        const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
+        const pageConfigRoute = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsAll(configValueSources, configDefinitionsLocal);
         const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
         const pageConfig = {
             pageId: locationId,
-            isErrorPage,
-            routeFilesystem,
+            ...pageConfigRoute,
             configDefinitions: configDefinitionsLocal,
             plusFiles: plusFilesRelevant,
             configValueSources,
@@ -359,8 +352,8 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
             locationId: '/',
             plusFile: null,
             isOverriden: configDef.cumulative ? false : sources.length > 0,
-            valueIsImportedAtRuntime: false,
-            valueIsDefinedByPlusFile: false
+            valueIsLoadedWithImport: false,
+            valueIsDefinedByPlusValueFile: false
         });
     });
 }
@@ -424,20 +417,10 @@ function getPlusFilesOrdered(configName, plusFilesRelevant) {
             const plusFilesConfig = plusFilesForConfigName.filter((plusFile) => plusFile.isConfigFile &&
                 // We consider extensions (e.g. vike-react) later (i.e. with less priority)
                 !plusFile.isExtensionConfig);
-            // Make this value:
-            //   /pages/some-page/+{configName}.js > `export default`
-            // override that value:
-            //   /pages/some-page/+config.js > `export default { someConfig }`
-            const plusFileWinner = plusFilesValue[0] ?? plusFilesConfig[0];
-            if (plusFileWinner) {
-                const plusFilesOverriden = [...plusFilesValue, ...plusFilesConfig].filter((f) => f !== plusFileWinner);
-                // A user-land conflict of plusFiles with the same `locationId` (we are iterating over `plusFilesRelevant: PlusFilesByLocationId`) means that the user has superfluously defined the config twice; the user should remove such redundancy as it makes things unnecessarily ambiguous.
-                assertOverwrittenConfigFile(plusFileWinner, plusFilesOverriden, configName);
-                [plusFileWinner, ...plusFilesOverriden].forEach((plusFile) => {
-                    assert(plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it's a user-land plus file
-                    populate(plusFile);
-                });
-            }
+            [...plusFilesValue, ...plusFilesConfig].forEach((plusFile) => {
+                assert(plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it's a user-land plus file
+                populate(plusFile);
+            });
         }
         // ==========================
         // Side-effect configs (next)
@@ -489,8 +472,8 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
         let valueFilePath;
         if (plusFile.isConfigFile) {
             // Defined over pointer import
-            assert(confVal.configValueLoaded);
-            const pointerImport = resolvePointerImport(confVal.configValue, plusFile.filePath, userRootDir, configName);
+            assert(confVal.valueIsLoaded);
+            const pointerImport = resolvePointerImport(confVal.value, plusFile.filePath, userRootDir, configName);
             const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtFilePath_);
             assertUsage(pointerImport, `${configDefinedAt} should be an import`);
             valueFilePath = pointerImport.fileExportPath.filePathAbsoluteVite;
@@ -511,8 +494,8 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv: configDef.env,
-            valueIsImportedAtRuntime: true,
-            valueIsDefinedByPlusFile: false,
+            valueIsLoadedWithImport: false,
+            valueIsDefinedByPlusValueFile: false,
             isOverriden,
             definedAtFilePath
         };
@@ -520,8 +503,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
     }
     // +config.js
     if (plusFile.isConfigFile) {
-        assert(confVal.configValueLoaded);
-        const { configValue } = confVal;
+        assert(confVal.valueIsLoaded);
         // Defined over pointer import
         const pointerImport = plusFile.pointerImportsByConfigName[configName];
         if (pointerImport) {
@@ -537,8 +519,8 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
                 ...configValueSourceCommon,
                 ...value,
                 configEnv: resolveConfigEnv(configDef.env, pointerImport.fileExportPath),
-                valueIsImportedAtRuntime: true,
-                valueIsDefinedByPlusFile: false,
+                valueIsLoadedWithImport: true,
+                valueIsDefinedByPlusValueFile: false,
                 isOverriden,
                 definedAtFilePath: pointerImport.fileExportPath
             };
@@ -548,10 +530,10 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
         const configValueSource = {
             ...configValueSourceCommon,
             valueIsLoaded: true,
-            value: configValue,
+            value: confVal.value,
             configEnv: configDef.env,
-            valueIsImportedAtRuntime: false,
-            valueIsDefinedByPlusFile: false,
+            valueIsLoadedWithImport: false,
+            valueIsDefinedByPlusValueFile: false,
             isOverriden,
             definedAtFilePath: definedAtFilePath_
         };
@@ -560,22 +542,13 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
     // Defined by value file, i.e. +{configName}.js
     if (!plusFile.isConfigFile) {
         const configEnvResolved = resolveConfigEnv(configDef.env, plusFile.filePath);
-        const valueAlreadyLoaded = confVal.configValueLoaded;
-        assert(valueAlreadyLoaded === !!configEnvResolved.config);
-        const value = valueAlreadyLoaded
-            ? {
-                valueIsLoaded: true,
-                value: confVal.configValue
-            }
-            : {
-                valueIsLoaded: false
-            };
+        assert(confVal.valueIsLoaded === !!configEnvResolved.config);
         const configValueSource = {
             ...configValueSourceCommon,
-            ...value,
+            ...confVal,
             configEnv: configEnvResolved,
-            valueIsImportedAtRuntime: !valueAlreadyLoaded,
-            valueIsDefinedByPlusFile: true,
+            valueIsLoadedWithImport: !confVal.valueIsLoaded || !isJsonValue(confVal.value),
+            valueIsDefinedByPlusValueFile: true,
             isOverriden,
             definedAtFilePath: {
                 ...plusFile.filePath,
@@ -589,14 +562,6 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
     }
     assert(false);
 }
-function assertOverwrittenConfigFile(plusFileWinner, plusFilesOverriden, configName) {
-    plusFilesOverriden.forEach((plusFileLoser) => {
-        const loserFilePath = plusFileLoser.filePath.filePathToShowToUser;
-        const winnerFilePath = plusFileWinner.filePath.filePathToShowToUser;
-        const confName = pc.cyan(configName);
-        assertWarning(false, `The value of the config ${confName} defined at ${loserFilePath} is always overwritten by the value defined at ${winnerFilePath}, remove the superfluous value defined at ${loserFilePath}`, { onlyOnce: true });
-    });
-}
 function isDefiningPage(plusFiles) {
     for (const plusFile of plusFiles) {
         const configNames = getDefiningConfigNames(plusFile);
@@ -630,8 +595,8 @@ function getConfigDefinitions(plusFilesRelevant, filter) {
             const confVal = getConfVal(plusFile, 'meta');
             if (!confVal)
                 return;
-            assert(confVal.configValueLoaded);
-            const meta = confVal.configValue;
+            assert(confVal.valueIsLoaded);
+            const meta = confVal.value;
             assertMetaUsage(meta, `Config ${pc.cyan('meta')} defined at ${plusFile.filePath.filePathToShowToUser}`);
             // Set configDef._userEffectDefinedAtFilePath
             Object.entries(meta).forEach(([configName, configDef]) => {
@@ -927,8 +892,8 @@ function getConfVal(plusFile, configName) {
     if (!configNames.includes(configName))
         return null;
     if (plusFile.isNotLoaded)
-        return { configValueLoaded: false };
-    const confVal = { configValue: plusFile.fileExportsByConfigName[configName], configValueLoaded: true };
+        return { valueIsLoaded: false };
+    const confVal = { value: plusFile.fileExportsByConfigName[configName], valueIsLoaded: true };
     return confVal;
 }
 function resolveConfigEnv(configEnv, filePath) {

package/dist/esm/node/plugin/shared/findPageFiles.js

@@ -1,5 +1,5 @@
 export { findPageFiles };
-import glob from 'fast-glob';
+import { glob } from 'tinyglobby';
 import { assertWarning, toPosixPath, scriptFileExtensions } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { getOutDirs } from './getOutDirs.js';
@@ -7,11 +7,11 @@ async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
     const { outDirRoot } = getOutDirs(config);
     const timeBase = new Date().getTime();
-    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false });
+    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false, expandDirectories: false });
     pageFiles = pageFiles.map((p) => '/' + toPosixPath(p));
     const time = new Date().getTime() - timeBase;
     if (isDev) {
-        // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
+        // We only warn in dev, because while building it's expected to take a long time as tinyglobby is competing for resources with other tasks
         assertWarning(time < 1.5 * 1000, `Finding your page files ${pc.cyan('**/*.page.*')} took an unexpected long time (${time}ms). Reach out to the vike maintainer.`, {
             onlyOnce: 'slow-page-files-search'
         });

package/dist/esm/node/plugin/shared/getHttpRequestAsyncStore.js

@@ -10,7 +10,7 @@
 // - We dedupe errors ourself with getHttpRequestAsyncStore().shouldErrorBeSwallowed()
 export { getHttpRequestAsyncStore };
 export { installHttpRequestAsyncStore };
-import { renderPage_addWrapper } from '../../runtime/renderPage.js';
+import { renderPage_addAsyncHookwrapper } from '../../runtime/renderPage.js';
 import { assert, assertIsNotProductionRuntime, isObject, unique } from '../utils.js';
 import { getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
 import { logErrorDebugNote } from './loggerNotProd.js';
@@ -27,7 +27,7 @@ async function installHttpRequestAsyncStore() {
         return;
     }
     asyncLocalStorage = new mod.AsyncLocalStorage();
-    renderPage_addWrapper(async (httpRequestId, renderPage) => {
+    renderPage_addAsyncHookwrapper(async (httpRequestId, renderPage) => {
         assert(asyncLocalStorage);
         const loggedErrors = new Set();
         const markErrorAsLogged = (err) => {

package/dist/esm/node/plugin/shared/viteIsSSR.d.ts

@@ -1,8 +1,11 @@
-import type { ResolvedConfig, UserConfig } from 'vite';
 export { viteIsSSR };
 export { viteIsSSR_options };
+export { viteIsSSR_safe };
+import type { ResolvedConfig, UserConfig } from 'vite';
 declare function viteIsSSR(config: ResolvedConfig | UserConfig): boolean;
-type Options = undefined | boolean | {
+declare function viteIsSSR_options(options: {
+    ssr?: boolean;
+} | undefined): boolean;
+declare function viteIsSSR_safe(config: ResolvedConfig, options: {
     ssr?: boolean;
-};
-declare function viteIsSSR_options(options: Options): boolean;
+} | undefined): boolean;

package/dist/esm/node/plugin/shared/viteIsSSR.js

@@ -1,20 +1,29 @@
-import { assert } from '../../../utils/assert.js';
-import { isObject } from '../../../utils/isObject.js';
 export { viteIsSSR };
 export { viteIsSSR_options };
+export { viteIsSSR_safe };
+import { assert } from '../../../utils/assert.js';
 function viteIsSSR(config) {
     return !!config?.build?.ssr;
 }
-// https://github.com/vitejs/vite/discussions/5109#discussioncomment-1450726
 function viteIsSSR_options(options) {
-    if (options === undefined) {
-        return false;
-    }
-    if (typeof options === 'boolean') {
-        return options;
+    return !!options?.ssr;
+}
+// Vite is quite messy about setting `ssr: boolean`, thus we use an extra safe implemention for security purposes.
+// It's used for .client.js and .server.js guarantee thus we use agressive assert() calls for added safety.
+function viteIsSSR_safe(config, options) {
+    if (config.command === 'build') {
+        assert(typeof config.build.ssr === 'boolean');
+        const val = config.build.ssr;
+        if (options?.ssr !== undefined)
+            assert(val === options.ssr);
+        return val;
     }
-    if (isObject(options)) {
-        return !!options.ssr;
+    else {
+        assert(typeof options?.ssr === 'boolean');
+        const val = options.ssr;
+        /* This assert() fails (which is very unexpected).
+        if (typeof config.build.ssr === 'boolean') assert(val === config.build.ssr)
+        //*/
+        return val;
     }
-    assert(false);
 }

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

@@ -30,6 +30,7 @@ import { resolvePrerenderConfig, resolvePrerenderConfigLocal } from './resolvePr
 import { getOutDirs } from '../plugin/shared/getOutDirs.js';
 import { isVikeCli } from '../cli/context.js';
 import { isViteCliCall } from '../plugin/shared/isViteCliCall.js';
+import { getVikeConfigPublic } from '../plugin/plugins/commonConfig.js';
 async function runPrerenderFromAPI(options = {}) {
     return 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.
@@ -60,7 +61,8 @@ async function runPrerenderFromAutoRun(viteConfig, config) {
         logErrorHint(err);
         process.exit(1);
     }
-    config.vike.prerenderContext = prerenderContextPublic;
+    const vike = getVikeConfigPublic(config);
+    vike.prerenderContext = prerenderContextPublic;
     const forceExit = isVikeCli() || isViteCliCall();
     return { forceExit };
 }

package/dist/esm/node/runtime/globalContext.d.ts

@@ -16,24 +16,25 @@ export { assertBuildInfo };
 export { getViteConfigRuntime };
 export { updateUserFiles };
 export type { BuildInfo };
-export type { GlobalContext };
+export type { GlobalContextInternal };
 export type { GlobalContextPublic };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
-import type { ConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
+import type { PageConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 import type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
-type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig' | 'pages'>;
+import { type BaseUrlsResolved } from '../shared/resolveBase.js';
+type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig' | 'pages' | 'baseAssets' | 'baseServer'>;
 type PageRuntimeInfo = Awaited<ReturnType<typeof getUserFiles>>;
-type GlobalContext = GlobalContextWithoutPublicCopy & {
+type GlobalContextInternal = GlobalContext & {
     globalContext_public: GlobalContextPublic;
 };
-type GlobalContextWithoutPublicCopy = {
+type GlobalContext = {
     viteConfigRuntime: {
         _baseViteOriginal: null | string;
     };
-    config: ConfigUserFriendly['config'];
+    config: PageConfigUserFriendly['config'];
     pages: PageConfigsUserFriendly;
-} & PageRuntimeInfo & ({
+} & BaseUrlsResolved & PageRuntimeInfo & ({
     isProduction: false;
     isPrerendering: false;
     viteConfig: ResolvedConfig;
@@ -51,7 +52,7 @@ type GlobalContextWithoutPublicCopy = {
     usesClientRouter: boolean;
     viteConfig: ResolvedConfig;
 })));
-declare function getGlobalContextInternal(): Promise<GlobalContext>;
+declare function getGlobalContextInternal(): Promise<GlobalContextInternal>;
 /** @experimental https://vike.dev/getGlobalContext */
 declare function getGlobalContextSync(): GlobalContextPublic;
 /** @experimental https://vike.dev/getGlobalContext */

package/dist/esm/node/runtime/globalContext.js

@@ -18,7 +18,7 @@ export { assertBuildInfo };
 export { getViteConfigRuntime };
 export { updateUserFiles };
 // The core logic revolves around:
-// - globalObject.userFiles which is the main requirement for assembleGlobalContext()
+// - globalObject.userFiles which is the main requirement for resolveGlobalContext()
 // - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
 //   - loadBuildEntry() sets globalObject.buildEntry and then sets globalObject.userFiles
 //   - With vike-server it's set at server start: @brillout/vite-plugin-server-entry injects `import './entry.mjs'` (the production entry generated by @brillout/vite-plugin-server-entry) as first line of code of dist/server/index.mjs while dist/server/entry.mjs calls setGlobalContext_buildEntry()
@@ -32,8 +32,9 @@ import pc from '@brillout/picocolors';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { assertV1Design } from '../shared/assertV1Design.js';
 import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
+import { resolveBase } from '../shared/resolveBase.js';
 const debug = createDebugger('vike:globalContext');
-const globalObject = getGlobalObject('globalContext.ts', getInitialGlobalContext());
+const globalObject = getGlobalObject('runtime/globalContext.ts', getInitialGlobalContext());
 async function getGlobalContextInternal() {
     // getGlobalContextInternal() should always be called after initGlobalContext()
     assert(globalObject.isInitialized);
@@ -79,7 +80,9 @@ function makePublic(globalContext) {
         'assetsManifest',
         'config',
         'viteConfig',
-        'pages'
+        'pages',
+        'baseServer',
+        'baseAssets'
     ]);
     return globalContextPublic;
 }
@@ -121,7 +124,7 @@ function getViteConfig() {
 }
 async function initGlobalContext_renderPage() {
     debug('initGlobalContext_renderPage()');
-    // globalObject.isProduction isn't set upon production server without vike-server (there isn't any signal we can use)
+    // `globalObject.isProduction === undefined` when using production server without `vike-server`. (There isn't any reliable signal we can use to determine early whether the environement is production or development.)
     if (globalObject.isProduction === undefined)
         setIsProduction(true);
     await initGlobalContext();
@@ -184,7 +187,7 @@ function setIsProduction(isProduction) {
     globalObject.isProduction = isProduction;
 }
 function defineGlobalContext() {
-    const globalContext = assembleGlobalContext();
+    const globalContext = resolveGlobalContext();
     assertIsDefined(globalContext);
     const globalContext_public = makePublic(globalContext);
     objectAssign(globalContext, { globalContext_public });
@@ -193,7 +196,7 @@ function defineGlobalContext() {
     assertGlobalContextIsDefined();
     onSetupRuntime();
 }
-function assembleGlobalContext() {
+function resolveGlobalContext() {
     const { viteDevServer, viteConfig, isPrerendering, isProduction, userFiles } = globalObject;
     assert(typeof isProduction === 'boolean');
     let globalContext;
@@ -212,7 +215,8 @@ function assembleGlobalContext() {
             viteDevServer,
             viteConfig,
             ...userFiles,
-            viteConfigRuntime
+            viteConfigRuntime,
+            ...resolveBaseRuntime(viteConfigRuntime, userFiles.config)
         };
     }
     else {
@@ -229,7 +233,8 @@ function assembleGlobalContext() {
             ...userFiles,
             viteDevServer: null,
             viteConfigRuntime: buildInfo.viteConfigRuntime,
-            usesClientRouter: buildInfo.usesClientRouter
+            usesClientRouter: buildInfo.usesClientRouter,
+            ...resolveBaseRuntime(buildInfo.viteConfigRuntime, userFiles.config)
         };
         if (isPrerendering) {
             assert(viteConfig);
@@ -398,3 +403,9 @@ function getInitialGlobalContext() {
         viteDevServerPromiseResolve
     };
 }
+function resolveBaseRuntime(viteConfigRuntime, config) {
+    const baseViteOriginal = viteConfigRuntime._baseViteOriginal;
+    const baseServerUnresolved = config.baseServer ?? null;
+    const baseAssetsUnresolved = config.baseAssets ?? null;
+    return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
+}

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

@@ -1,5 +1,5 @@
 export { getViteDevScript };
-import type { GlobalContext } from '../../globalContext.js';
+import type { GlobalContextInternal } from '../../globalContext.js';
 declare function getViteDevScript(pageContext: {
-    _globalContext: GlobalContext;
+    _globalContext: GlobalContextInternal;
 }): Promise<string>;

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

@@ -8,7 +8,7 @@ import { type PreloadFilter } from './injectAssets/getHtmlTags.js';
 import type { StreamFromReactStreamingPackage } from './stream/react-streaming.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageContextSerialization } from './serializePageContextClientSide.js';
-import type { GlobalContext } from '../globalContext.js';
+import type { GlobalContextInternal } from '../globalContext.js';
 type PageContextInjectAssets = {
     urlPathname: string;
     __getPageAssets: () => Promise<PageAsset[]>;
@@ -22,7 +22,7 @@ type PageContextInjectAssets = {
     _baseServer: string;
     _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
-    _globalContext: GlobalContext;
+    _globalContext: GlobalContextInternal;
 } & PageContextSerialization;
 declare function injectHtmlTagsToString(htmlParts: HtmlPart[], pageContext: PageContextInjectAssets & {
     _isStream: false;

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

@@ -2,5 +2,5 @@ export { analyzePage };
 import type { PageFile } from '../../../shared/getPageFiles/getPageFileObject.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type AnalysisResult } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import type { GlobalContext } from '../globalContext.js';
-declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfigRuntime, pageId: string, globalContext: GlobalContext): Promise<AnalysisResult>;
+import type { GlobalContextInternal } from '../globalContext.js';
+declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfigRuntime, pageId: string, globalContext: GlobalContextInternal): Promise<AnalysisResult>;

package/dist/esm/node/runtime/renderPage/createHttpResponse/assertNoInfiniteHttpRedirect.js

@@ -1,7 +1,7 @@
 export { assertNoInfiniteHttpRedirect };
 import { assert, assertUsage, getGlobalObject } from '../../utils.js';
 import pc from '@brillout/picocolors';
-const globalObject = getGlobalObject('assertNoInfiniteHttpRedirect.ts', {
+const globalObject = getGlobalObject('createHttpResponse/assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
 function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {

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

@@ -3,6 +3,7 @@ export { createHttpResponsePageContextJson };
 export { createHttpResponseError };
 export { createHttpResponseRedirect };
 export { createHttpResponseFavicon404 };
+export { createHttpResponseBaseIsMissing };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from '../html/renderHtml.js';
@@ -28,6 +29,7 @@ declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null
     abortStatusCode?: AbortStatusCode;
 }): Promise<HttpResponse>;
 declare function createHttpResponseFavicon404(): HttpResponse;
+declare function createHttpResponseBaseIsMissing(urlOriginal: string, baseServer: string): HttpResponse;
 declare function createHttpResponseError(pageContext: null | {
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];

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

@@ -3,6 +3,7 @@ export { createHttpResponsePageContextJson };
 export { createHttpResponseError };
 export { createHttpResponseRedirect };
 export { createHttpResponseFavicon404 };
+export { createHttpResponseBaseIsMissing };
 import { assert, assertWarning, escapeHtml } from '../utils.js';
 import { getErrorPageId, isErrorPage } from '../../../shared/error-page.js';
 import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
@@ -38,6 +39,29 @@ function createHttpResponseFavicon404() {
     const httpResponse = createHttpResponse(404, 'text/html;charset=utf-8', [], "<p>No favicon.ico found.</p><script>console.log('This HTTP response was generated by Vike.')</script>");
     return httpResponse;
 }
+function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
+    const httpResponse = createHttpResponse(
+    // We use the error code `500` to signal a failing state because this HTTP response should never be used, see https://vike.dev/base-url#setup
+    // In other words: this HTTP response is expected to be generated but isn't expected to be actually used.
+    500, 'text/html;charset=utf-8', [], `
+<h1>Error: Base URL is missing</h1>
+<p>
+  <a href="https://vike.dev/renderPage"><code>renderPage(pageContextInit)</code></a> called with <code>pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}</code> which doesn't start with the Base URL <code>${baseServer}</code>.
+</p>
+<p>
+  See <a href="https://vike.dev/base-url#setup">vike.dev/base-url#setup</a> for how to properly setup your server while using a Base URL.
+</p>
+<style>
+  code {
+    font-family: monospace;
+    background-color: #eaeaea;
+    padding: 3px 5px;
+    border-radius: 4px;
+  }
+</style>
+`);
+    return httpResponse;
+}
 function createHttpResponseError(pageContext) {
     const reason = (() => {
         if (!pageContext) {

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

@@ -1,7 +1,7 @@
 export { executeOnBeforeRenderAndDataHooks };
-import { type PageConfigUserFriendly } from '../../../shared/getPageFiles.js';
+import { type PageConfigUserFriendlyOld } from '../../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 declare function executeOnBeforeRenderAndDataHooks(pageContext: {
     pageId: string;
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
-} & PageConfigUserFriendly & PageContextForUserConsumptionServerSide): Promise<void>;
+} & PageConfigUserFriendlyOld & PageContextForUserConsumptionServerSide): Promise<void>;

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

@@ -5,7 +5,7 @@ export type { GetPageAssets };
 export type { PageContextGetPageAssets };
 import { type MediaType } from './inferMediaType.js';
 import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-import type { GlobalContext } from '../globalContext.js';
+import type { GlobalContextInternal } from '../globalContext.js';
 import type { ResolveClientEntriesDev } from '../../plugin/shared/resolveClientEntriesDev.js';
 type PageAsset = {
     src: string;
@@ -18,7 +18,7 @@ type PageContextGetPageAssets = {
     _baseServer: string;
     _baseAssets: string | null;
     _includeAssetsImportedByServer: boolean;
-    _globalContext: GlobalContext;
+    _globalContext: GlobalContextInternal;
 };
 declare function getPageAssets(pageContext: PageContextGetPageAssets, clientDependencies: ClientDependency[], clientEntries: string[]): Promise<PageAsset[]>;
 declare function setResolveClientEntriesDev(resolveClientEntriesDev: ResolveClientEntriesDev): void;

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

@@ -6,7 +6,7 @@ import { retrieveAssetsProd } from './getPageAssets/retrieveAssetsProd.js';
 import { inferMediaType } from './inferMediaType.js';
 import { getManifestEntry } from './getPageAssets/getManifestEntry.js';
 import { sortPageAssetsForEarlyHintsHeader } from './getPageAssets/sortPageAssetsForEarlyHintsHeader.js';
-const globalObject = getGlobalObject('getPageAssets.ts', {
+const globalObject = getGlobalObject('renderPage/getPageAssets.ts', {
     resolveClientEntriesDev: null
 });
 async function getPageAssets(pageContext, clientDependencies, clientEntries) {