vike 0.4.221 → 0.4.222-commit-207e079

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

@@ -1,16 +1,13 @@
 export { getPlusFilesAll };
-export { getPlusFileValueConfigName };
-import { assert, assertPosixPath, assertUsage } from '../../../../utils.js';
+import { assert } from '../../../../utils.js';
 import { configDefinitionsBuiltIn } from './configDefinitionsBuiltIn.js';
 import { getLocationId } from './filesystemRouting.js';
-import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
-import { crawlPlusFiles } from './crawlPlusFiles.js';
+import { crawlPlusFiles, getPlusFileValueConfigName } from './crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadValueFile } from './loadFileAtConfigTime.js';
 import { resolvePointerImport } from './resolvePointerImport.js';
 import { getFilePathResolved } from '../../../../shared/getFilePath.js';
 import { assertExtensionsConventions } from './assertExtensions.js';
-import path from 'node:path';
 async function getPlusFilesAll(userRootDir, esbuildCache) {
     const plusFiles = await findPlusFiles(userRootDir, null);
     const configFiles = [];
@@ -120,35 +117,3 @@ async function findPlusFiles(userRootDir, outDirRoot) {
     const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
-function getPlusFileValueConfigName(filePath) {
-    assertPosixPath(filePath);
-    if (isTemporaryBuildFile(filePath))
-        return null;
-    const fileName = path.posix.basename(filePath);
-    // assertNoUnexpectedPlusSign(filePath, fileName)
-    const basename = fileName.split('.')[0];
-    if (!basename.startsWith('+')) {
-        return null;
-    }
-    else {
-        const configName = basename.slice(1);
-        assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
-        return configName;
-    }
-}
-/* https://github.com/vikejs/vike/issues/1407
-function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
-  const dirs = path.posix.dirname(filePath).split('/')
-  dirs.forEach((dir, i) => {
-    const dirPath = dirs.slice(0, i + 1).join('/')
-    assertUsage(
-      !dir.includes('+'),
-      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
-    )
-  })
-  assertUsage(
-    !fileName.slice(1).includes('+'),
-    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
-  )
-}
-*/

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

@@ -51,7 +51,7 @@ async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir,
 async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig, esbuildCache) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig ? 'is-extension-config' : true, esbuildCache);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig, esbuildCache);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [...visited, filePathAbsoluteFilesystem], esbuildCache);
     const configFile = {
         fileExports,

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

@@ -10,7 +10,7 @@ type FileExports = {
 };
 type EsbuildCache = Record<string, // filePathAbsoluteFilesystem
 Promise<FileExports>>;
-declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isConfigFile: boolean | 'is-extension-config', esbuildCache: EsbuildCache): Promise<FileExports>;
+declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isExtensionConfig: boolean, esbuildCache: EsbuildCache): Promise<FileExports>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;
 declare function getConfigExecutionErrorIntroMsg(err: unknown): string | null;
 declare function isTemporaryBuildFile(filePath: string): boolean;

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

@@ -21,8 +21,9 @@ const debug = createDebugger('vike:pointer-imports');
 const debugEsbuildResolve = createDebugger('vike:esbuild-resolve');
 if (debugEsbuildResolve.isActivated)
     debugEsbuildResolve('esbuild version', version);
-async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile, esbuildCache) {
+async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig, esbuildCache) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
+    assert(filePathAbsoluteFilesystem);
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
     if (esbuildCache[filePathAbsoluteFilesystem]) {
         return await esbuildCache[filePathAbsoluteFilesystem];
@@ -35,12 +36,12 @@ async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile, esbu
         assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
     }
     let fileExports;
-    if (isConfigFile === 'is-extension-config' && !isHeader && fileExtension.endsWith('js')) {
+    if (isExtensionConfig && !isHeader && fileExtension.endsWith('js')) {
         // This doesn't track dependencies => we should never use this for user land configs
         fileExports = await executeFile(filePathAbsoluteFilesystem, filePath);
     }
     else {
-        const transformImports = isConfigFile && (isHeader ? 'all' : true);
+        const transformImports = isHeader ? 'all' : true;
         const code = await transpileFile(filePath, transformImports, userRootDir);
         fileExports = await executeTranspiledFile(filePath, code);
     }
@@ -49,6 +50,7 @@ async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile, esbu
 }
 async function transpileFile(filePath, transformImports, userRootDir) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
+    assert(filePathAbsoluteFilesystem);
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     if (debug.isActivated)
@@ -333,6 +335,7 @@ function isTemporaryBuildFile(filePath) {
     const fileName = path.posix.basename(filePath);
     return /\.build-[a-z0-9]{12}\.mjs$/.test(fileName);
 }
+// TODO/next-major: remove
 function isHeaderFile(filePath) {
     assertPosixPath(filePath);
     const fileExtensions = getFileExtensions(filePath);

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

@@ -9,12 +9,13 @@ export type { VikeConfigObject };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type ConfigDefinitions, type ConfigDefinitionInternal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import type { ResolvedConfig } from 'vite';
-import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { type ConfigUserFriendly, type PageConfigsUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { type PlusFile } from './getVikeConfig/getPlusFilesAll.js';
 type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
-    global: ReturnType<typeof getPageConfigUserFriendlyNew>;
+    global: ConfigUserFriendly;
+    pages: PageConfigsUserFriendly;
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(config: ResolvedConfig): void;

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

@@ -7,7 +7,7 @@ export { getConfVal };
 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, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
+import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
@@ -31,6 +31,7 @@ function reloadVikeConfig(config) {
     const userRootDir = config.root;
     const vikeVitePluginOptions = config._vikeVitePluginOptions;
     assert(vikeVitePluginOptions);
+    // TODO/now: unify with esbuildCache
     vikeConfigDependencies.clear();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
     handleReloadSideEffects();
@@ -126,7 +127,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                global: getPageConfigUserFriendlyNew({ configValues: {} })
+                global: getPageConfigUserFriendlyNew({ configValues: {} }),
+                pages: {}
             };
             return dummyData;
         }
@@ -135,15 +137,26 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     const esbuildCache = {};
     const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
-    assertKnownConfigs(plusFilesAll);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
+    assertKnownConfigs(configDefinitionsResolved, plusFilesAll);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
     // interop vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     // global
-    const configValues = getConfigValues(pageConfigGlobal);
-    const global = getPageConfigUserFriendlyNew({ configValues });
-    return { pageConfigs, pageConfigGlobal, global };
+    const configValuesGlobal = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigUserFriendlyNew({ configValues: configValuesGlobal });
+    // TODO/now DEDUPE
+    // 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];
+    }));
+    return { pageConfigs, pageConfigGlobal, global, pages };
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const configDefinitionsGlobal = getConfigDefinitions(
@@ -229,10 +242,9 @@ function assertPageConfigGlobal(pageConfigGlobal, plusFilesAll) {
     });
 }
 function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDefinitionsGlobal) {
-    const locationIdsAll = objectKeys(plusFilesAll);
     // Determine existing global +config.js files
     const configFilePathsGlobal = [];
-    const plusFilesGlobal = Object.values(objectFromEntries(objectEntries(plusFilesAll).filter(([locationId]) => isGlobalLocation(locationId, locationIdsAll)))).flat();
+    const plusFilesGlobal = Object.values(objectFromEntries(objectEntries(plusFilesAll).filter(([locationId]) => isGlobalLocation(locationId, plusFilesAll)))).flat();
     plusFilesGlobal
         .filter((i) => i.isConfigFile)
         .forEach((plusFile) => {
@@ -251,7 +263,7 @@ function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDef
         if (!filePathAbsoluteUserRootDir)
             return;
         assert(!plusFile.isExtensionConfig);
-        if (!isGlobalLocation(source.locationId, locationIdsAll)) {
+        if (!isGlobalLocation(source.locationId, plusFilesAll)) {
             const configDef = configDefinitionsGlobal[configName];
             assert(configDef);
             const isConditionallyGlobal = isCallable(configDef.global);
@@ -284,7 +296,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
     // 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.`);
 }
-function getConfigValues(pageConfig) {
+function getConfigValues(pageConfig, tolerateMissingValue) {
     const configValues = {};
     getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
         if (entry.configValueBase.type === 'computed') {
@@ -295,7 +307,11 @@ function getConfigValues(pageConfig) {
         if (entry.configValueBase.type === 'standard') {
             assert('sourceRelevant' in entry); // Help TS
             const { configValueBase, sourceRelevant, configName } = entry;
-            assert('value' in sourceRelevant);
+            if (!sourceRelevant.valueIsLoaded) {
+                if (tolerateMissingValue)
+                    return;
+                assert(false);
+            }
             const { value } = sourceRelevant;
             configValues[configName] = { ...configValueBase, value };
         }
@@ -304,9 +320,18 @@ function getConfigValues(pageConfig) {
             const { configValueBase, sourcesRelevant, configName } = entry;
             const values = [];
             sourcesRelevant.forEach((source) => {
-                assert('value' in source);
+                if (!source.valueIsLoaded) {
+                    if (tolerateMissingValue)
+                        return;
+                    assert(false);
+                }
                 values.push(source.value);
             });
+            if (values.length === 0) {
+                if (tolerateMissingValue)
+                    return;
+                assert(false);
+            }
             configValues[configName] = { ...configValueBase, value: values };
         }
     });
@@ -351,10 +376,9 @@ function getPlusFilesRelevant(plusFilesAll, locationIdPage) {
     return plusFilesRelevant;
 }
 function sortForGlobal(plusFilesAll) {
-    const locationIdsAll = objectKeys(plusFilesAll);
     const plusFilesAllSorted = Object.fromEntries(objectEntries(plusFilesAll)
         .sort(lowerFirst(([locationId]) => locationId.split('/').length))
-        .sort(makeFirst(([locationId]) => isGlobalLocation(locationId, locationIdsAll))));
+        .sort(makeFirst(([locationId]) => isGlobalLocation(locationId, plusFilesAll))));
     return plusFilesAllSorted;
 }
 function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal) {
@@ -748,13 +772,13 @@ function getComputed(configValueSources, configDefinitions) {
     return configValuesComputed;
 }
 // Show error message upon unknown config
-function assertKnownConfigs(plusFilesAll) {
+function assertKnownConfigs(configDefinitionsResolved, plusFilesAll) {
     const configDefinitionsAll = getConfigDefinitions(plusFilesAll);
     const configNamesKnownAll = Object.keys(configDefinitionsAll);
-    objectEntries(plusFilesAll).forEach(([locationId, plusFiles]) => {
-        const plusFilesRelevant = getPlusFilesRelevant(plusFilesAll, locationId);
-        const configDefinitionsLocal = getConfigDefinitions(plusFilesRelevant);
-        const configNamesKnownLocal = Object.keys(configDefinitionsLocal);
+    const configNamesGlobal = Object.keys(configDefinitionsResolved.configDefinitionsGlobal);
+    objectEntries(configDefinitionsResolved.configDefinitionsLocal).forEach(([_locationId, { configDefinitions, plusFiles }]) => {
+        const configDefinitionsLocal = configDefinitions;
+        const configNamesKnownLocal = [...Object.keys(configDefinitionsLocal), ...configNamesGlobal];
         plusFiles.forEach((plusFile) => {
             const configNames = getDefiningConfigNames(plusFile);
             configNames.forEach((configName) => {
@@ -926,3 +950,10 @@ function resolveConfigEnv(configEnv, filePath) {
     }
     return configEnvResolved;
 }
+/** Whether configs defined in `locationId` apply to every page */
+function isGlobalLocation(locationId, plusFilesAll) {
+    const locationIdsPage = objectEntries(plusFilesAll)
+        .filter(([_locationId, plusFiles]) => isDefiningPage(plusFiles))
+        .map(([locationId]) => locationId);
+    return locationIdsPage.every((locId) => isInherited(locationId, locId));
+}

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

@@ -16,23 +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 } from '../../shared/page-configs/getPageConfigUserFriendly.js';
+import type { ConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 import type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
-type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig'>;
+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'];
-} & PageRuntimeInfo & ({
+    pages: PageConfigsUserFriendly;
+} & BaseUrlsResolved & PageRuntimeInfo & ({
     isProduction: false;
     isPrerendering: false;
     viteConfig: ResolvedConfig;
@@ -50,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 */
@@ -71,6 +73,7 @@ declare function getUserFiles(): Promise<{
     allPageIds: string[];
     pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    pages: PageConfigsUserFriendly;
     config: import("../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
 }>;
 declare function setGlobalContext_buildEntry(buildEntry: unknown): Promise<void>;

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,6 +32,7 @@ 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());
 async function getGlobalContextInternal() {
@@ -75,8 +76,14 @@ async function getGlobalContextAsync(isProduction) {
     return globalContext_public;
 }
 function makePublic(globalContext) {
-    // TODO/soon: add `pages`
-    const globalContextPublic = makePublicCopy(globalContext, 'globalContext', ['assetsManifest', 'config', 'viteConfig']);
+    const globalContextPublic = makePublicCopy(globalContext, 'globalContext', [
+        'assetsManifest',
+        'config',
+        'viteConfig',
+        'pages',
+        'baseServer',
+        'baseAssets'
+    ]);
     return globalContextPublic;
 }
 async function setGlobalContext_viteDevServer(viteDevServer) {
@@ -180,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 });
@@ -189,7 +196,7 @@ function defineGlobalContext() {
     assertGlobalContextIsDefined();
     onSetupRuntime();
 }
-function assembleGlobalContext() {
+function resolveGlobalContext() {
     const { viteDevServer, viteConfig, isPrerendering, isProduction, userFiles } = globalObject;
     assert(typeof isProduction === 'boolean');
     let globalContext;
@@ -208,7 +215,8 @@ function assembleGlobalContext() {
             viteDevServer,
             viteConfig,
             ...userFiles,
-            viteConfigRuntime
+            viteConfigRuntime,
+            ...resolveBaseRuntime(viteConfigRuntime, userFiles.config)
         };
     }
     else {
@@ -225,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);
@@ -250,7 +259,7 @@ async function getUserFiles() {
     const globalObject_ = globalObject;
     const { pageConfigsRuntime } = globalObject_;
     assert(pageConfigsRuntime);
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = pageConfigsRuntime;
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = pageConfigsRuntime;
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
     const userFiles = {
         pageFilesAll,
@@ -259,6 +268,7 @@ async function getUserFiles() {
         allPageIds,
         pageRoutes,
         onBeforeRouteHook,
+        pages: pageConfigsUserFriendly,
         config: globalConfig.config
     };
     assertV1Design(
@@ -393,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/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/handleErrorWithoutErrorPage.d.ts

@@ -1,5 +1,5 @@
 export { handleErrorWithoutErrorPage };
-import type { GlobalContext } from '../globalContext.js';
+import type { GlobalContextInternal } from '../globalContext.js';
 import type { PageContextAfterRender } from './renderPageAlreadyRouted.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageFile } from '../../../shared/getPageFiles.js';
@@ -10,6 +10,6 @@ declare function handleErrorWithoutErrorPage<PageContext extends {
     pageId: null;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
-    _globalContext: GlobalContext;
+    _globalContext: GlobalContextInternal;
     urlOriginal: string;
 }>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;

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

@@ -6,12 +6,12 @@ import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-import type { GlobalContext } from '../globalContext.js';
+import type { GlobalContextInternal } from '../globalContext.js';
 type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
     urlOriginal: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
-    _globalContext: GlobalContext;
+    _globalContext: GlobalContextInternal;
 };
 type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
 declare function loadUserFilesServerSide(pageContext: {

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

@@ -12,7 +12,7 @@ async function loadUserFilesServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
-        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext.pageId, !globalContext.isProduction),
+        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, globalContext.pageConfigGlobal, pageContext.pageId, !globalContext.isProduction),
         analyzePageClientSideInit(pageContext._pageFilesAll, pageContext.pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
     const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = await analyzePage(pageContext._pageFilesAll, pageConfig, pageContext.pageId, globalContext);
@@ -96,11 +96,11 @@ async function loadUserFilesServerSide(pageContext) {
     }
     return pageContextAddendum;
 }
-async function loadPageUserFiles(pageFilesAll, pageConfig, pageId, isDev) {
+async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const pageContextExports = getPageConfigUserFriendlyOld(pageFilesServerSide, pageConfigLoaded);
+    const pageContextExports = getPageConfigUserFriendlyOld(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
     return {
         pageContextExports,
         pageFilesLoaded: pageFilesServerSide

package/dist/esm/node/runtime/renderPage/log404/index.d.ts

@@ -1,12 +1,12 @@
 export { log404 };
 export { getRoutesInfo };
 import type { PageRoutes } from '../../../../shared/route/index.js';
-import type { GlobalContext } from '../../globalContext.js';
+import type { GlobalContextInternal } from '../../globalContext.js';
 declare function log404(pageContext: {
     urlPathname: string;
     errorWhileRendering: null | Error;
     isClientSideNavigation: boolean;
     _pageRoutes: PageRoutes;
-    _globalContext: GlobalContext;
+    _globalContext: GlobalContextInternal;
 }): Promise<void>;
 declare function getRoutesInfo(pageRoutes: PageRoutes): string | null;

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

@@ -4,7 +4,7 @@ import { PageContextUrlInternal } from '../../../shared/getPageContextUrlCompute
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageConfigUserFriendly } from '../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { PageContextBuiltInServerInternal } from '../../../shared/types.js';
-import type { GlobalContext, GlobalContextPublic } from '../globalContext.js';
+import type { GlobalContextInternal, GlobalContextPublic } from '../globalContext.js';
 type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal & PageConfigUserFriendly & {
     urlOriginal: string;
     /** @deprecated */
@@ -18,7 +18,7 @@ type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal
     is404: null | boolean;
     isClientSideNavigation: boolean;
     pageProps?: Record<string, unknown>;
-    _globalContext: GlobalContext;
+    _globalContext: GlobalContextInternal;
     globalContext: GlobalContextPublic;
 } & Record<string, unknown>;
 declare function preparePageContextForUserConsumptionServerSide(pageContext: PageContextForUserConsumptionServerSide): void;