vike 0.4.219 → 0.4.220-commit-9a798ce

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.d.ts

@@ -3,8 +3,47 @@ export { runPrerenderFromCLIPrerenderCommand };
 export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
+export type { PrerenderContextPublic };
+import { PageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
+import { PageContextUrlInternal } from '../../shared/getPageContextUrlComputed.js';
 import type { APIOptions } from '../api/types.js';
+type ProvidedByHook = null | {
+    hookFilePath: string;
+    hookName: 'onBeforePrerenderStart' | 'prerender';
+};
+type TransformerHook = {
+    hookFilePath: string;
+    hookName: 'onPrerenderStart' | 'onBeforePrerender';
+};
+type PageContextPrerendered = {
+    urlOriginal: string;
+    _providedByHook?: ProvidedByHook;
+};
+type PrerenderedPageContexts = Record<string, PageContextPrerendered>;
+type PrerenderContext = {
+    pageContexts: PageContext[];
+    pageContextInit: Record<string, unknown> | null;
+    noExtraDir: boolean;
+    prerenderedPageContexts: PrerenderedPageContexts;
+    output: Output;
+};
+type Output = {
+    filePath: string;
+    fileType: FileType;
+    fileContent: string;
+    pageContext: PageContextPrerendered;
+}[];
+type FileType = 'HTML' | 'JSON';
+type PrerenderContextPublic = Pick<PrerenderContext, 'pageContexts'>;
+type PageContext = PageContextInitEnhanced & {
+    _urlRewrite: null;
+    _urlHandler: null;
+    _urlOriginalBeforeHook?: string;
+    _urlOriginalModifiedByHook?: TransformerHook;
+    _providedByHook: ProvidedByHook;
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+} & PageContextUrlInternal;
 type PrerenderOptions = APIOptions & {
     /** Initial `pageContext` values */
     pageContextInit?: Record<string, unknown>;
@@ -29,5 +68,7 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<void>;
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
+    prerenderContextPublic: PrerenderContextPublic;
+}>;
 declare function runPrerender_forceExit(): void;

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

@@ -4,7 +4,7 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy } from './utils.js';
 import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -27,6 +27,8 @@ import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 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.
@@ -46,16 +48,20 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
 }
 async function runPrerenderFromAutoRun(viteConfig) {
+    let prerenderContextPublic;
     try {
-        await runPrerender({ viteConfig });
+        const ret = await runPrerender({ viteConfig });
+        prerenderContextPublic = ret.prerenderContextPublic;
     }
     catch (err) {
         console.error(err);
         logErrorHint(err);
         process.exit(1);
     }
+    return { prerenderContextPublic };
 }
 async function runPrerender(options = {}, standaloneTrigger) {
+    setContextIsPrerendering();
     checkOutdatedOptions(options);
     onSetupPrerender();
     setGlobalContext_isPrerendering();
@@ -69,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);
@@ -82,43 +88,48 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await initGlobalContext_runPrerender();
     const globalContext = getGlobalContext();
     globalContext.pageFilesAll.forEach(assertExportNames);
-    const prerenderContext = {};
-    objectAssign(prerenderContext, {
-        _urlHandler: null,
-        _noExtraDir: noExtraDir ?? false,
+    const prerenderContext = {
+        noExtraDir: noExtraDir ?? false,
         pageContexts: [],
-        pageContextInit: options.pageContextInit ?? null
-    });
+        pageContextInit: options.pageContextInit ?? null,
+        prerenderedPageContexts: {},
+        output: []
+    };
     const doNotPrerenderList = [];
     await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
     await callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext);
-    const prerenderedPageContexts = {};
     let prerenderedCount = 0;
+    // Write files as soon as pages finish rendering (instead of writing all files at once only after all pages have rendered).
     const onComplete = async (htmlFile) => {
         prerenderedCount++;
         if (htmlFile.pageId) {
-            prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
+            prerenderContext.prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
         }
-        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, logLevel);
+        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
     };
     await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
-    warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
-    await prerender404(prerenderedPageContexts, prerenderContext, onComplete);
+    warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial);
-    return { viteConfig };
+    warnMissingPages(prerenderContext.prerenderedPageContexts, doNotPrerenderList, partial);
+    const prerenderContextPublic = makePublic(prerenderContext);
+    return { viteConfig, prerenderContextPublic };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // 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,
@@ -301,7 +312,7 @@ function createPageContext(urlOriginal, prerenderContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
-        _noExtraDir: prerenderContext._noExtraDir,
+        _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
@@ -387,17 +398,20 @@ async function callOnPrerenderStartHook(prerenderContext) {
     const docLink = 'https://vike.dev/i18n#pre-rendering';
     // Set `enumerable` to `false` to avoid computed URL properties from being iterated & copied in onPrerenderStart() hook, e.g. /examples/i18n/
     const { restoreEnumerable, addPageContextComputedUrl } = makePageContextComputedUrlNonEnumerable(prerenderContext.pageContexts);
-    let result = await executeHook(() => hookFn({
-        pageContexts: prerenderContext.pageContexts,
+    let result = await executeHook(() => {
+        const prerenderContextPublic = makePublic(prerenderContext);
         // TODO/v1-release: remove warning
-        get prerenderPageContexts() {
-            assertWarning(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
-                showStackTrace: true,
-                onlyOnce: true
-            });
-            return prerenderContext.pageContexts;
-        }
-    }), onPrerenderStartHook, null);
+        Object.defineProperty(prerenderContextPublic, 'prerenderPageContexts', {
+            get() {
+                assertWarning(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return prerenderContext.pageContexts;
+            }
+        });
+        return hookFn(prerenderContextPublic);
+    }, onPrerenderStartHook, null);
     restoreEnumerable();
     if (result === null || result === undefined) {
         return;
@@ -504,7 +518,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir,
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
             pageId
         });
     })));
@@ -539,8 +553,8 @@ function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial)
         assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
-async function prerender404(prerenderedPageContexts, prerenderContext, onComplete) {
-    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerender404(prerenderContext, onComplete) {
+    if (!Object.values(prerenderContext.prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
             result = await prerender404Page(prerenderContext.pageContextInit);
@@ -563,22 +577,23 @@ async function prerender404(prerenderedPageContexts, prerenderContext, onComplet
         }
     }
 }
-async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, logLevel) {
+async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, output, logLevel) {
     assert(urlOriginal.startsWith('/'));
     const writeJobs = [
-        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel)
+        write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
     ];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel));
+        writeJobs.push(write(urlOriginal, pageContext, 'JSON', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel));
     }
     await Promise.all(writeJobs);
 }
-async function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel) {
+async function write(urlOriginal, pageContext, fileType, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel) {
     let fileUrl;
-    if (fileExtension === '.html') {
+    if (fileType === 'HTML') {
         fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
     else {
+        assert(fileType === 'JSON');
         fileUrl = getPageContextRequestUrl(urlOriginal);
     }
     assertPosixPath(fileUrl);
@@ -590,6 +605,12 @@ async function write(urlOriginal, pageContext, fileExtension, fileContent, root,
     assertPosixPath(outDirClient);
     assertPosixPath(filePathRelative);
     const filePath = path.posix.join(outDirClient, filePathRelative);
+    output.push({
+        filePath,
+        fileType,
+        fileContent,
+        pageContext
+    });
     if (onPagePrerender) {
         const prerenderPageContext = {};
         objectAssign(prerenderPageContext, pageContext);
@@ -758,3 +779,9 @@ prerenderConfig) {
         assertUsage(false, `Setting ${pc.cyan(`prerender.${prop}`)} ${errMsg}`);
     }
 }
+function makePublic(prerenderContext) {
+    const prerenderContextPublic = makePublicCopy(prerenderContext, 'prerenderContext', [
+        'pageContexts'
+    ]);
+    return prerenderContextPublic;
+}

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';
@@ -15,3 +15,4 @@ export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/makePublicCopy.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';
@@ -17,3 +17,4 @@ export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/makePublicCopy.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, objectKeys, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger } 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');
@@ -50,28 +48,8 @@ async function getGlobalContextAsync(isProduction) {
     return makePublic(globalContext);
 }
 function makePublic(globalContext) {
-    const globalContextPublic = {
-        // TODO/now: add viteConfig and vikeConfig
-        assetsManifest: globalContext.assetsManifest
-    };
-    // Add internals (and prepended _ prefix to their keys)
-    {
-        const publicKeys = Object.keys(globalContextPublic);
-        objectKeys(globalContext)
-            .filter((key) => !publicKeys.includes(key))
-            .forEach((key) => {
-            const keyPublic = `_${key}`;
-            Object.defineProperty(globalContextPublic, keyPublic, {
-                enumerable: true,
-                get() {
-                    assertWarning(false, `Using internal globalContext.${keyPublic} which is discouraged: it may break in any minor version update. Instead, reach out on GitHub and elaborate your use case.`, {
-                        onlyOnce: true
-                    });
-                    return globalContext[key];
-                }
-            });
-        });
-    }
+    // TODO/now: add viteConfig and vikeConfig
+    const globalContextPublic = makePublicCopy(globalContext, 'globalContext', ['assetsManifest']);
     return globalContextPublic;
 }
 function setGlobalContext_viteDevServer(viteDevServer) {
@@ -161,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,
@@ -172,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,
@@ -194,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);
@@ -234,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
@@ -279,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/page-files/setup.js

@@ -1,3 +1,3 @@
 export {};
-// TODO/v1-release: remove
+// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
 // This doesn't do anything anymore. (It's kept to avoid introducing a breaking change.)

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;