vike 0.4.220-commit-a9f46b8 → 0.4.220-commit-9a798ce

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;

package/dist/esm/shared/page-configs/Config.d.ts

@@ -37,7 +37,7 @@ import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { InjectFilterEntry } from '../../types/index.js';
-import type { VikeVitePluginOptions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import type { VikeVitePluginOptions } from '../../node/plugin/index.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
@@ -246,11 +246,55 @@ type ConfigBuiltIn = {
      */
     guard?: GuardAsync | GuardSync | ImportString;
     /**
-     * Whether to pre-render the page(s).
+     * Pre-render page(s).
      *
      * https://vike.dev/pre-rendering
+     * https://vike.dev/prerender
+     *
+     * @default false
      */
-    prerender?: boolean | ImportString;
+    prerender?: boolean | ImportString | {
+        /**
+         * Allow only some of your pages to be pre-rendered.
+         *
+         * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
+         *
+         * https://vike.dev/prerender#partial
+         *
+         * @default false
+         */
+        partial?: boolean;
+        /**
+         * Don't create a new directory for each HTML file.
+         *
+         * For example, generate `dist/client/about.html` instead of `dist/client/about/index.html`.
+         *
+         * https://vike.dev/prerender#noextradir
+         *
+         * @default false
+         */
+        noExtraDir?: boolean;
+        /**
+         * Number of concurrent pre-render jobs.
+         *
+         * Set to `false` to disable concurrency.
+         *
+         * https://vike.dev/prerender#parallel
+         *
+         * @default os.cpus().length
+         */
+        parallel?: boolean | number;
+        /**
+         * Disable the automatic initiation of the pre-rendering process when running `$ vike build`.
+         *
+         * Use this if you want to programmatically initiate the pre-rendering process instead.
+         *
+         * https://vike.dev/prerender#disableautorun
+         *
+         * @default false
+         */
+        disableAutoRun?: boolean;
+    };
     /**
      * Install Vike extensions.
      *
@@ -358,6 +402,34 @@ type ConfigBuiltIn = {
      * https://vike.dev/redirects
      */
     redirects?: Record<string, string>;
+    /** Whether URLs should end with a trailing slash.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    trailingSlash?: boolean;
+    /** Disable automatic URL normalization.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    disableUrlNormalization?: boolean;
+    /** @deprecated It's now `true` by default. You can remove this option. */
+    includeAssetsImportedByServer?: boolean;
+    /** @deprecated See https://vike.dev/disableAutoFullBuild */
+    disableAutoFullBuild?: boolean | 'prerender';
+    /** The Base URL of your server.
+     *
+     * https://vike.dev/base-url
+     */
+    baseServer?: string;
+    /** The Base URL of your static assets.
+     *
+     * https://vike.dev/base-url
+     */
+    baseAssets?: string;
     /**
      * @experimental DON'T USE: the API *will* have breaking changes upon any minor version release.
      *
@@ -407,6 +479,7 @@ type ConfigBuiltIn = {
 type ConfigBuiltInResolved = {
     passToClient?: string[][];
     redirects?: Record<string, string>[];
+    prerender?: Exclude<Config['prerender'], ImportString | undefined>[];
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;