vike 0.4.220-commit-a9f46b8 → 0.4.220-commit-5c7810f

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

@@ -22,7 +22,9 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const { pageConfigs } = vikeConfig;
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     assert(pageConfig, { id, pageId });
-    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer, isDev);
+    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, 
+    // TODO/now: add meta.default
+    vikeConfig.global.config.includeAssetsImportedByServer ?? true, isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }

package/dist/esm/node/plugin/plugins/previewConfig.js

@@ -7,7 +7,7 @@ import pc from '@brillout/picocolors';
 import { logDockerHint } from './devConfig/index.js';
 function previewConfig() {
     let config;
-    // let vikeConfigGlobal: VikeConfigGlobal
+    // let vikeConfig: VikeConfigObject
     return {
         name: 'vike:previewConfig',
         apply: applyPreview,
@@ -22,8 +22,7 @@ function previewConfig() {
         async configResolved(config_) {
             config = config_;
             logDockerHint(config.preview.host);
-            // const vikeConfig = await getVikeConfig(config)
-            // vikeConfigGlobal = vikeConfig.vikeConfigGlobal
+            // vikeConfig = await getVikeConfig(config)
         },
         configurePreviewServer(server) {
             /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
@@ -33,7 +32,7 @@ function previewConfig() {
             return () => {
                 assertDist();
                 /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
-                if (!vikeConfigGlobal.prerender || vikeConfigGlobal.prerender.partial) {
+                if (!vikeConfig.global.config.prerender || vikeConfig.global.config.prerender.partial) {
                   addSsrMiddleware(server.middlewares, config, true)
                 }
                 /*/

package/dist/esm/node/plugin/utils.js

@@ -2,7 +2,7 @@
 // We call onLoad() here so that it's called even when only a subset of the plugin is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
 import { onLoad } from './onLoad.js';
 onLoad();
-// We tolerate the fact that we load all of the runtime utils even though some of it isn't needed
+// It's common practice for Vike's Vite plugin to import from Vike's sever runtime
 export * from '../runtime/utils.js';
 // Utils only needed by `plugin/*`
 export * from '../../utils/viteIsSSR.js';

package/dist/esm/node/prerender/context.d.ts

@@ -2,8 +2,8 @@ export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
 export { isPrerendering };
 export { setContextIsPrerendering };
-import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-declare function isPrerenderAutoRunEnabled(vikeConfigGlobal: VikeConfigGlobal): boolean;
+import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+declare function isPrerenderAutoRunEnabled(vikeConfig: VikeConfigObject): boolean;
 declare function temp_disablePrerenderAutoRun(): void;
 declare function isPrerendering(): boolean;
 declare function setContextIsPrerendering(): void;

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

@@ -3,12 +3,14 @@ export { temp_disablePrerenderAutoRun };
 export { isPrerendering };
 export { setContextIsPrerendering };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
+import { resolvePrerenderConfig } from './resolvePrerenderConfig.js';
 const globalObject = getGlobalObject('prerender/context.ts', {});
-function isPrerenderAutoRunEnabled(vikeConfigGlobal) {
-    return (vikeConfigGlobal.prerender &&
-        !vikeConfigGlobal.prerender.disableAutoRun &&
+function isPrerenderAutoRunEnabled(vikeConfig) {
+    const prerenderConfig = resolvePrerenderConfig(vikeConfig.global.config.prerender);
+    return (prerenderConfig &&
+        !prerenderConfig.disableAutoRun &&
         !globalObject.isDisabled &&
-        vikeConfigGlobal.disableAutoFullBuild !== 'prerender');
+        vikeConfig.global.config.disableAutoFullBuild !== 'prerender');
 }
 // TODO/v1-release: remove
 function temp_disablePrerenderAutoRun() {

package/dist/esm/node/prerender/resolvePrerenderConfig.d.ts

@@ -0,0 +1,5 @@
+export { resolvePrerenderConfig };
+import type { ConfigResolved } from '../../shared/page-configs/Config/PageContextConfig.js';
+type PrerenderConfigSemiResolved = ConfigResolved['prerender'];
+type PrerenderConfig = false | Exclude<Required<NonNullable<PrerenderConfigSemiResolved>[number]>, boolean>;
+declare function resolvePrerenderConfig(prerenderConfigs: PrerenderConfigSemiResolved): PrerenderConfig;

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

@@ -0,0 +1,23 @@
+export { resolvePrerenderConfig };
+// TODO/now:
+// - prerender.value
+// - correct isPrerendering
+function resolvePrerenderConfig(prerenderConfigs) {
+    if (!prerenderConfigs || prerenderConfigs.every((configVal) => !configVal)) {
+        return false;
+    }
+    const prerenderSettings = prerenderConfigs.filter(isObject2);
+    const prerenderConfig = {
+        partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
+    };
+    return prerenderConfig;
+}
+function isObject2(p) {
+    return typeof p === 'object';
+}
+function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}

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

@@ -28,6 +28,7 @@ import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js'
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 import { setContextIsPrerendering } from './context.js';
+import { resolvePrerenderConfig } from './resolvePrerenderConfig.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.
@@ -74,7 +75,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const vikeConfig = await getVikeConfig(viteConfig);
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
-    const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
+    const prerenderConfig = resolvePrerenderConfig(vikeConfig.global.config.prerender);
     validatePrerenderConfig(prerenderConfig);
     if (!prerenderConfig) {
         assert(standaloneTrigger);
@@ -122,9 +123,13 @@ async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurr
     // V1 design
     pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
-        const configValue = getConfigValueBuildTime(pageConfig, configName, 'boolean');
-        if (configValue?.value === false) {
-            const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
+        const configValue = getConfigValueBuildTime(pageConfig, configName);
+        if (!configValue)
+            return;
+        assert(hasProp(configValue, 'value', 'array'));
+        if (configValue.value[0] === false) {
+            assert(isArray(configValue.definedAtData));
+            const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData[0]);
             assert(configValueFilePathToShowToUser);
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,

package/dist/esm/node/prerender/utils.d.ts

@@ -4,9 +4,9 @@ export * from '../../utils/projectInfo.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';
-export * from '../../utils/getOutDirs.js';
+export * from '../plugin/getOutDirs.js';
 export * from '../../utils/isPropertyGetter.js';
-export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/toPosixPath.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertSetup.js';

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

@@ -6,9 +6,9 @@ export * from '../../utils/projectInfo.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';
-export * from '../../utils/getOutDirs.js';
+export * from '../plugin/getOutDirs.js';
 export * from '../../utils/isPropertyGetter.js';
-export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/toPosixPath.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertSetup.js';

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

@@ -3,7 +3,6 @@ export { getGlobalContextAsync };
 export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
-export { getRuntimeManifest };
 export { initGlobalContext_renderPage };
 export { initGlobalContext_runPrerender };
 export { initGlobalContext_getGlobalContextAsync };
@@ -14,10 +13,11 @@ export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
 export { setGlobalContext_buildEntry };
 export { clearGlobalContext };
+export { assertBuildInfo };
+export { getViteConfigRuntime };
+export type { BuildInfo };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
-import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import type { ConfigUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 type GlobalContextPublic = {
@@ -25,11 +25,9 @@ type GlobalContextPublic = {
 };
 type PageRuntimeInfo = Awaited<ReturnType<typeof getPageRuntimeInfo>>['userFiles'];
 type GlobalContext = {
-    baseServer: string;
-    baseAssets: null | string;
-    includeAssetsImportedByServer: boolean;
-    trailingSlash: boolean;
-    disableUrlNormalization: boolean;
+    viteConfigRuntime: {
+        _baseViteOriginal: null | string;
+    };
     vikeConfig: {
         global: ConfigUserFriendly;
     };
@@ -77,6 +75,14 @@ declare function getPageRuntimeInfo(isProduction: boolean): Promise<{
     };
     globalConfig: ConfigUserFriendly;
 }>;
-declare function getRuntimeManifest(vikeConfigGlobal: VikeConfigGlobal, viteConfig: ResolvedConfig): RuntimeManifest;
 declare function setGlobalContext_buildEntry(buildEntry: unknown): void;
+type BuildInfo = {
+    versionAtBuildTime: string;
+    usesClientRouter: boolean;
+    viteConfigRuntime: {
+        _baseViteOriginal: string;
+    };
+};
+declare function assertBuildInfo(buildInfo: unknown): asserts buildInfo is BuildInfo;
+declare function getViteConfigRuntime(viteConfig: ResolvedConfig): BuildInfo['viteConfigRuntime'];
 declare function clearGlobalContext(): void;

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

@@ -5,7 +5,6 @@ export { getGlobalContextAsync };
 export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
-export { getRuntimeManifest };
 export { initGlobalContext_renderPage };
 export { initGlobalContext_runPrerender };
 export { initGlobalContext_getGlobalContextAsync };
@@ -16,14 +15,13 @@ export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
 export { setGlobalContext_buildEntry };
 export { clearGlobalContext };
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy } from './utils.js';
+export { assertBuildInfo };
+export { getViteConfigRuntime };
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy, projectInfo, checkType } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.js';
 import { getPageFilesAll, setPageFiles, setPageFilesAsync } from '../../shared/getPageFiles/getPageFiles.js';
-import { assertPluginManifest } from '../shared/assertPluginManifest.js';
-import { assertRuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import pc from '@brillout/picocolors';
-import { resolveBaseFromResolvedConfig } from '../shared/resolveBase.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { assertV1Design } from '../shared/assertV1Design.js';
 const debug = createDebugger('vike:globalContext');
@@ -141,7 +139,7 @@ async function initGlobalContext(isProduction) {
         assert(viteDevServer);
         assert(!isPrerendering);
         const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
-        const pluginManifest = getRuntimeManifest(vikeConfig.vikeConfigGlobal, viteConfig);
+        const viteConfigRuntime = getViteConfigRuntime(viteConfig);
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
@@ -152,20 +150,14 @@ async function initGlobalContext(isProduction) {
                 global: globalConfig
             },
             ...userFiles,
-            baseServer: pluginManifest.baseServer,
-            baseAssets: pluginManifest.baseAssets,
-            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
-            trailingSlash: pluginManifest.trailingSlash,
-            disableUrlNormalization: pluginManifest.disableUrlNormalization
+            viteConfigRuntime
         };
     }
     else {
         const buildEntry = await getBuildEntry(globalObject.outDirRoot, isPrerendering);
-        const { assetsManifest, pluginManifest } = buildEntry;
+        const { assetsManifest, buildInfo } = buildEntry;
         setPageFiles(buildEntry.pageFiles);
         const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
-        assertViteManifest(assetsManifest);
-        assertPluginManifest(pluginManifest);
         const globalContext = {
             isProduction: true,
             assetsManifest,
@@ -174,12 +166,8 @@ async function initGlobalContext(isProduction) {
             },
             ...userFiles,
             viteDevServer: null,
-            baseServer: pluginManifest.baseServer,
-            baseAssets: pluginManifest.baseAssets,
-            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
-            trailingSlash: pluginManifest.trailingSlash,
-            usesClientRouter: pluginManifest.usesClientRouter,
-            disableUrlNormalization: pluginManifest.disableUrlNormalization
+            viteConfigRuntime: buildInfo.viteConfigRuntime,
+            usesClientRouter: buildInfo.usesClientRouter
         };
         if (isPrerendering) {
             assert(viteConfig);
@@ -214,19 +202,6 @@ async function getPageRuntimeInfo(isProduction) {
     pageConfigs.length > 0, pageFilesAll);
     return { userFiles, globalConfig };
 }
-function getRuntimeManifest(vikeConfigGlobal, viteConfig) {
-    const { includeAssetsImportedByServer, trailingSlash, disableUrlNormalization } = vikeConfigGlobal;
-    const { baseServer, baseAssets } = resolveBaseFromResolvedConfig(vikeConfigGlobal.baseServer, vikeConfigGlobal.baseAssets, viteConfig);
-    const manifest = {
-        baseServer,
-        baseAssets,
-        includeAssetsImportedByServer,
-        trailingSlash,
-        disableUrlNormalization
-    };
-    assertRuntimeManifest(manifest);
-    return manifest;
-}
 function assertViteManifest(manifest) {
     assert(isPlainObject(manifest));
     /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/vikejs/vike/issues/769
@@ -259,17 +234,48 @@ async function getBuildEntry(outDir, isPrerendering) {
         assert(globalObject.buildEntry);
     }
     const { buildEntry } = globalObject;
-    assert(isObject(buildEntry));
-    assert(hasProp(buildEntry, 'pageFiles', 'object'));
-    assert(hasProp(buildEntry, 'assetsManifest', 'object'));
-    assert(hasProp(buildEntry, 'pluginManifest', 'object'));
+    assertBuildEntry(buildEntry);
     return buildEntry;
 }
 function setGlobalContext_buildEntry(buildEntry) {
     debug('setGlobalContext_buildEntry()');
+    assertBuildEntry(buildEntry);
     globalObject.buildEntry = buildEntry;
     globalObject.buildEntryPrevious = buildEntry;
 }
+function assertBuildEntry(buildEntry) {
+    assert(isObject(buildEntry));
+    assert(hasProp(buildEntry, 'pageFiles', 'object'));
+    const { pageFiles } = buildEntry;
+    assert(hasProp(buildEntry, 'assetsManifest', 'object'));
+    const { assetsManifest } = buildEntry;
+    assertViteManifest(assetsManifest);
+    assert(hasProp(buildEntry, 'buildInfo', 'object'));
+    const { buildInfo } = buildEntry;
+    assertBuildInfo(buildInfo);
+    checkType({ pageFiles, assetsManifest, buildInfo });
+}
+function assertBuildInfo(buildInfo) {
+    assert(isObject(buildInfo));
+    assert(hasProp(buildInfo, 'versionAtBuildTime', 'string'));
+    assertVersionAtBuildTime(buildInfo.versionAtBuildTime);
+    assert(hasProp(buildInfo, 'viteConfigRuntime', 'object'));
+    assert(hasProp(buildInfo.viteConfigRuntime, '_baseViteOriginal', 'string'));
+    assert(hasProp(buildInfo, 'usesClientRouter', 'boolean'));
+    checkType({ ...buildInfo, viteConfigRuntime: buildInfo.viteConfigRuntime });
+}
+function assertVersionAtBuildTime(versionAtBuildTime) {
+    const versionAtRuntime = projectInfo.projectVersion;
+    const pretty = (version) => pc.bold(`vike@${version}`);
+    assertUsage(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
+}
+function getViteConfigRuntime(viteConfig) {
+    assert(hasProp(viteConfig, '_baseViteOriginal', 'string'));
+    const viteConfigRuntime = {
+        _baseViteOriginal: viteConfig._baseViteOriginal
+    };
+    return viteConfigRuntime;
+}
 function initDevEntry() {
     setPageFilesAsync(getPageFilesExports);
 }

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

@@ -37,7 +37,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     } & {
         _objectCreatedByVike: boolean;
         _baseServer: string;
-        _baseAssets: string | null;
+        _baseAssets: string;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../__internal/index.js").PageConfig[];
@@ -88,7 +88,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     } & {
         _objectCreatedByVike: boolean;
         _baseServer: string;
-        _baseAssets: string | null;
+        _baseAssets: string;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../__internal/index.js").PageConfig[];
@@ -140,7 +140,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     } & {
         _objectCreatedByVike: boolean;
         _baseServer: string;
-        _baseAssets: string | null;
+        _baseAssets: string;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../__internal/index.js").PageConfig[];
@@ -191,7 +191,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     } & {
         _objectCreatedByVike: boolean;
         _baseServer: string;
-        _baseAssets: string | null;
+        _baseAssets: string;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../__internal/index.js").PageConfig[];
@@ -251,7 +251,7 @@ declare function getPageContextInitEnhanced(pageContextInit: {
 } & {
     _objectCreatedByVike: boolean;
     _baseServer: string;
-    _baseAssets: string | null;
+    _baseAssets: string;
     _includeAssetsImportedByServer: boolean;
     _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../../__internal/index.js").PageConfig[];

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

@@ -18,6 +18,7 @@ import { preparePageContextForUserConsumptionServerSide } from './preparePageCon
 import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
+import { resolveBaseRuntime } from '../../shared/resolveBase.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext.pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -114,14 +115,16 @@ function getPageContextInitEnhanced(pageContextInit, { ssr: { urlRewrite, urlHan
 } } = {}) {
     assert(pageContextInit.urlOriginal);
     const globalContext = getGlobalContext();
+    const { baseServer, baseAssets } = resolveBaseRuntime();
     const pageContextInitEnhanced = {};
     objectAssign(pageContextInitEnhanced, pageContextInit);
     objectAssign(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
         // The following is defined on `pageContext` because we can eventually make these non-global
-        _baseServer: globalContext.baseServer,
-        _baseAssets: globalContext.baseAssets,
-        _includeAssetsImportedByServer: globalContext.includeAssetsImportedByServer,
+        _baseServer: baseServer,
+        _baseAssets: baseAssets,
+        // TODO/now: add meta.default
+        _includeAssetsImportedByServer: globalContext.vikeConfig.global.config.includeAssetsImportedByServer ?? true,
         // TODO: use GloablContext instead
         _pageFilesAll: globalContext.pageFilesAll,
         _pageConfigs: globalContext.pageConfigs,

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

@@ -1,4 +1,6 @@
 export { resolveRedirects };
 export { resolveRouteStringRedirect };
+export { redirectsErrPrefix };
+declare const redirectsErrPrefix = "[+redirects]";
 declare function resolveRedirects(redirectsAll: Record<string, string>[], urlPathname: string): null | string;
 declare function resolveRouteStringRedirect(urlSource: string, urlTarget: string, urlPathname: string): null | string;

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

@@ -1,14 +1,14 @@
 export { resolveRedirects };
 // For ./resolveRedirects.spec.ts
 export { resolveRouteStringRedirect };
+export { redirectsErrPrefix };
 import { assertIsNotBrowser } from '../../../utils/assertIsNotBrowser.js';
 import { assert, assertUsage, assertUsageUrlRedirectTarget, isUrlRedirectTarget } from '../../../shared/utils.js';
 import { resolveUrlPathname } from '../../../shared/route/resolveUrlPathname.js';
 import { assertRouteString, resolveRouteString } from '../../../shared/route/resolveRouteString.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser(); // Don't bloat the client
-// TODO/next-major-release: update
-const configSrc = '[vite.config.js > vike({ redirects })]';
+const redirectsErrPrefix = '[+redirects]';
 function resolveRedirects(redirectsAll, urlPathname) {
     const redirects = merge(redirectsAll);
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
@@ -19,9 +19,9 @@ function resolveRedirects(redirectsAll, urlPathname) {
     return null;
 }
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
-    assertRouteString(urlSource, `${configSrc} Invalid`);
+    assertRouteString(urlSource, `${redirectsErrPrefix} Invalid`);
     // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
-    assertUsageUrlRedirectTarget(urlTarget, `${configSrc} The URL redirection target`, true);
+    assertUsageUrlRedirectTarget(urlTarget, `${redirectsErrPrefix} The URL redirection target`, true);
     assertParams(urlSource, urlTarget);
     const match = resolveRouteString(urlSource, urlPathname);
     if (!match)
@@ -37,7 +37,7 @@ function assertParams(urlSource, urlTarget) {
     routeSegments.forEach((routeSegment) => {
         if (routeSegment.startsWith('@') || routeSegment.startsWith('*')) {
             const segments = urlSource.split('/');
-            assertUsage(segments.includes(routeSegment), `${configSrc} The redirection source URL ${pc.string(urlSource)} is missing the URL parameter ${pc.string(routeSegment)} used by the redirection target URL ${pc.string(urlTarget)}`);
+            assertUsage(segments.includes(routeSegment), `${redirectsErrPrefix} The redirection source URL ${pc.string(urlSource)} is missing the URL parameter ${pc.string(routeSegment)} used by the redirection target URL ${pc.string(urlTarget)}`);
         }
     });
 }

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

@@ -18,6 +18,7 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
+import { resolveBaseRuntime } from '../shared/resolveBase.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
     httpRequestsCount: 0
 });
@@ -336,14 +337,16 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
     assertUsage(false, `${pc.code('renderPage(pageContextInit)')} called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${pc.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${pc.cyan('createDevMiddleware()')} middleware is executed *before* the ${pc.cyan('renderPage()')} middleware, see ${pc.underline('https://vike.dev/renderPage')}`);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
-    const { trailingSlash, disableUrlNormalization, baseServer } = getGlobalContext();
+    const globalContext = getGlobalContext();
+    const { baseServer } = resolveBaseRuntime();
+    const { trailingSlash, disableUrlNormalization } = globalContext.vikeConfig.global.config;
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
     if (isPageContextRequest)
         return null;
-    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash, baseServer);
+    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash ?? false, baseServer);
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
@@ -354,7 +357,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 }
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const globalContext = getGlobalContext();
-    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, globalContext.baseServer);
+    const { baseServer } = resolveBaseRuntime();
+    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
@@ -385,8 +389,9 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         }
         if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
+        const { baseServer } = resolveBaseRuntime();
         if (!originChanged)
-            urlTarget = prependBase(urlTarget, globalContext.baseServer);
+            urlTarget = prependBase(urlTarget, baseServer);
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
@@ -451,7 +456,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
     return { pageContextAbort };
 }
 function assertBaseUrl(pageContextInit) {
-    const { baseServer } = getGlobalContext();
+    const { baseServer } = resolveBaseRuntime();
     const { urlOriginal } = pageContextInit;
     const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
     const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);

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

@@ -21,8 +21,8 @@ export * from '../../utils/compareString.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/stringifyStringArray.js';
 export * from '../../utils/unique.js';
-export * from '../../utils/filesystemPathHandling.js';
-export * from '../../utils/getOutDirs.js';
+export * from '../../utils/toPosixPath.js';
+export * from '../plugin/getOutDirs.js';
 export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isSameErrorMessage.js';

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

@@ -25,8 +25,8 @@ export * from '../../utils/compareString.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/stringifyStringArray.js';
 export * from '../../utils/unique.js';
-export * from '../../utils/filesystemPathHandling.js';
-export * from '../../utils/getOutDirs.js';
+export * from '../../utils/toPosixPath.js';
+export * from '../plugin/getOutDirs.js';
 export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isSameErrorMessage.js';

package/dist/esm/node/shared/resolveBase.d.ts

@@ -1,11 +1,14 @@
 export { resolveBase };
+export { resolveBaseRuntime };
 export { resolveBaseFromResolvedConfig };
 import type { ResolvedConfig } from 'vite';
 declare function resolveBaseFromResolvedConfig(baseServer: string | null, baseAssets: string | null, config: ResolvedConfig): {
     baseServer: string;
     baseAssets: string;
 };
-declare function resolveBase(baseViteOriginal: string | null, baseServerUnresolved: string | null, baseAssetsUnresolved: string | null): {
+type BaseUrlsResolved = {
     baseServer: string;
     baseAssets: string;
 };
+declare function resolveBaseRuntime(): BaseUrlsResolved;
+declare function resolveBase(baseViteOriginal: string | null, baseServerUnresolved: string | null, baseAssetsUnresolved: string | null): BaseUrlsResolved;

package/dist/esm/node/shared/resolveBase.js

@@ -1,12 +1,21 @@
 export { resolveBase };
+export { resolveBaseRuntime };
 export { resolveBaseFromResolvedConfig };
 import { assert, assertUsage, isBaseServer, isBaseAssets } from './utils.js';
 import pc from '@brillout/picocolors';
+import { getGlobalContext } from '../runtime/globalContext.js';
 function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
     let baseViteOriginal = config._baseViteOriginal;
     assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
     return resolveBase(baseViteOriginal, baseServer, baseAssets);
 }
+function resolveBaseRuntime() {
+    const globalContext = getGlobalContext();
+    const baseViteOriginal = globalContext.viteConfigRuntime._baseViteOriginal;
+    const baseServerUnresolved = globalContext.vikeConfig.global.config.baseServer ?? null;
+    const baseAssetsUnresolved = globalContext.vikeConfig.global.config.baseAssets ?? null;
+    return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
+}
 function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
     if (baseViteOriginal === '/__UNSET__')
         baseViteOriginal = null;