vike 0.4.220-commit-af5c91f → 0.4.221-commit-8577456

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{debug.js → virtual-files/debug.js}

@@ -1,2 +1,2 @@
-import { createDebugger } from '../../../utils.js';
+import { createDebugger } from '../../../../utils.js';
 export const debug = createDebugger('vike:virtual-files');

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{getVirtualFilePageConfigValuesAll.js → virtual-files/getVirtualFilePageConfigValuesAll.js}

@@ -1,13 +1,13 @@
 export { getVirtualFilePageConfigValuesAll };
-import { assert } from '../../../utils.js';
-import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
-import { getVikeConfig } from './getVikeConfig.js';
-import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
+import { assert } from '../../../../utils.js';
+import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll } from '../../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { getVikeConfig } from '../getVikeConfig.js';
+import { extractAssetsAddQuery } from '../../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
-import { fixServerAssets_isEnabled } from '../../buildConfig/fixServerAssets.js';
-import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
+import { serializeConfigValues } from '../../../../../../shared/page-configs/serialize/serializeConfigValues.js';
+import { fixServerAssets_isEnabled } from '../../../buildConfig/fixServerAssets.js';
+import { getConfigValueBuildTime } from '../../../../../../shared/page-configs/getConfigValueBuildTime.js';
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
     assert(result);

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{getVirtualFilePageConfigs.js → virtual-files/getVirtualFilePageConfigs.js}

@@ -1,9 +1,9 @@
 export { getVirtualFilePageConfigs };
-import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { getVirtualFileIdPageConfigValuesAll } from '../../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { debug } from './debug.js';
-import { getVikeConfig } from './getVikeConfig.js';
+import { getVikeConfig } from '../getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
+import { serializeConfigValues } from '../../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
     const vikeConfig = await getVikeConfig(config, { doNotRestartViteOnError: true });
     const { pageConfigs, pageConfigGlobal } = vikeConfig;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{isRuntimeEnvMatch.d.ts → virtual-files/isRuntimeEnvMatch.d.ts}

@@ -1,5 +1,5 @@
 export { isRuntimeEnvMatch };
-import type { ConfigEnvInternal } from '../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal } from '../../../../../../shared/page-configs/PageConfig.js';
 declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtime: {
     isForClientSide: boolean;
     isClientRouting: boolean;

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

@@ -1,7 +1,6 @@
 export { setGlobalContext };
-import { setGlobalContext_isViteDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_vikeConfig } from '../../runtime/globalContext.js';
+import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProduction } from '../../runtime/globalContext.js';
 import { assertFilePathAbsoluteFilesystem, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
-import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { getOutDirs } from '../shared/getOutDirs.js';
 function setGlobalContext() {
     return [
@@ -22,7 +21,7 @@ function setGlobalContext() {
                 order: 'pre',
                 handler(_, env) {
                     const isViteDev = isDevCheck(env);
-                    setGlobalContext_isViteDev(isViteDev);
+                    setGlobalContext_isProduction(!isViteDev);
                     markSetup_isViteDev(isViteDev);
                 }
             }
@@ -36,8 +35,6 @@ function setGlobalContext() {
                     const { outDirRoot } = getOutDirs(config);
                     assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for `importServerProductionEntry({ outDir })` of @brillout/vite-plugin-server-entry
                     setGlobalContext_viteConfig(config, outDirRoot);
-                    const vikeConfig = await getVikeConfig(config);
-                    setGlobalContext_vikeConfig(vikeConfig);
                 }
             }
         }

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

@@ -0,0 +1,2 @@
+import type { InlineConfig, ResolvedConfig } from 'vite';
+export declare function getFullBuildInlineConfig(config: ResolvedConfig): InlineConfig;

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

@@ -0,0 +1,17 @@
+import { getViteConfigFromCli, isViteCliCall } from './isViteCliCall.js';
+export function getFullBuildInlineConfig(config) {
+    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
+    if (config._viteConfigEnhanced) {
+        return config._viteConfigEnhanced;
+    }
+    else {
+        return {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
+            build: {
+                ...configFromCli?.build
+            }
+        };
+    }
+}

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

@@ -12,4 +12,4 @@ type OutDirs = {
 };
 declare function getOutDirs(config: ResolvedConfig): OutDirs;
 /** Appends `client/` or `server/` to `config.build.outDir` */
-declare function resolveOutDir(config: UserConfig): string;
+declare function resolveOutDir(config: UserConfig, isSSR?: true): string;

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

@@ -6,49 +6,34 @@ import { viteIsSSR } from './viteIsSSR.js';
 const debug = createDebugger('vike:outDir');
 function getOutDirs(config) {
     debug('getOutDirs()', new Error().stack);
-    let outDirRoot;
-    {
-        const outDir = getOutDirFromViteResolvedConfig(config);
-        if (isOutDirRoot(outDir)) {
-            outDirRoot = outDir;
-        }
-        else {
-            assertOutDirResolved(outDir, config);
-            assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
-            assert('/client'.length === '/server'.length);
-            outDirRoot = outDir.slice(0, -1 * '/client'.length);
-        }
-    }
-    const outDirs = getOutDirsAll(outDirRoot, config.root);
-    debug('outDirRoot', outDirRoot);
-    debug('outDirs', outDirs);
+    const outDir = getOutDirFromViteResolvedConfig(config);
+    if (!isOutDirRoot(outDir))
+        assertOutDirResolved(outDir, config);
+    const outDirs = getOutDirsAll(outDir, config.root);
     return outDirs;
 }
 /** Appends `client/` or `server/` to `config.build.outDir` */
-function resolveOutDir(config) {
+function resolveOutDir(config, isSSR) {
     debug('resolveOutDir()', new Error().stack);
+    const isServerSide = viteIsSSR(config) || isSSR;
+    debug('isServerSide', isServerSide);
     const outDir = getOutDirFromViteUserConfig(config) || 'dist';
-    debug('outDir', 'outDir');
-    // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
-    if (!isOutDirRoot(outDir)) {
-        assertOutDirResolved(outDir, config);
-        return outDir;
+    debug('outDir', outDir);
+    /* outDir may already be resolved when using Telefunc + Vike (because both Telefunc and Vike use this logic)
+    assert(isOutDirRoot(outDir))
+    */
+    const { outDirClient, outDirServer } = getOutDirsAll(outDir);
+    if (isServerSide) {
+        debug('outDirServer', 'outDirServer');
+        return outDirServer;
     }
     else {
-        const { outDirClient, outDirServer } = determineOutDirs(outDir);
-        if (viteIsSSR(config)) {
-            debug('outDirServer', 'outDirServer');
-            return outDirServer;
-        }
-        else {
-            debug('outDirClient', 'outDirClient');
-            return outDirClient;
-        }
+        debug('outDirClient', 'outDirClient');
+        return outDirClient;
     }
 }
 function determineOutDirs(outDirRoot) {
     assertPosixPath(outDirRoot);
-    assert(!outDirRoot.endsWith('/'));
     assert(isOutDirRoot(outDirRoot));
     const outDirClient = pathJoin(outDirRoot, 'client');
     const outDirServer = pathJoin(outDirRoot, 'server');
@@ -56,8 +41,35 @@ function determineOutDirs(outDirRoot) {
     assertIsNotOutDirRoot(outDirServer);
     return { outDirClient, outDirServer };
 }
-function getOutDirsAll(outDirRoot, root) {
-    if (!outDirIsAbsolutePath(outDirRoot)) {
+function getOutDirsAll(outDir, root) {
+    let outDirRoot;
+    {
+        if (isOutDirRoot(outDir)) {
+            outDirRoot = outDir;
+        }
+        else {
+            assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
+            assert('/client'.length === '/server'.length);
+            outDirRoot = outDir.slice(0, -1 * '/client'.length);
+        }
+    }
+    debug('outDirRoot', outDirRoot);
+    let outDirs;
+    if (root) {
+        outDirs = getOutDirsAllFromRootNormalized(outDirRoot, root);
+    }
+    else {
+        outDirs = getOutDirsAllFromRoot(outDirRoot);
+    }
+    debug('outDirs', outDirs);
+    return outDirs;
+}
+function getOutDirsAllFromRoot(outDirRoot) {
+    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
+    return { outDirRoot, outDirClient, outDirServer };
+}
+function getOutDirsAllFromRootNormalized(outDirRoot, root) {
+    if (root && !outDirIsAbsolutePath(outDirRoot)) {
         assertPosixPath(outDirRoot);
         assertPosixPath(root);
         outDirRoot = pathJoin(root, outDirRoot);
@@ -85,7 +97,7 @@ function isOutDirRoot(outDirRot) {
 function assertIsNotOutDirRoot(outDir) {
     assert(outDir.endsWith('/client') || outDir.endsWith('/server'));
 }
-/** `outDir` ends with `/server` or `/client` */
+/** Assert that `outDir` ends with `/server` or `/client` */
 function assertOutDirResolved(outDir, config) {
     assertPosixPath(outDir);
     assertIsNotOutDirRoot(outDir);
@@ -103,16 +115,16 @@ function getOutDirFromViteUserConfig(config) {
     let outDir = config.build?.outDir;
     if (outDir === undefined)
         return undefined;
-    outDir = normalize(outDir);
+    outDir = normalizeOutDir(outDir);
     return outDir;
 }
 function getOutDirFromViteResolvedConfig(config) {
     let outDir = config.build.outDir;
     assert(outDir);
-    outDir = normalize(outDir);
+    outDir = normalizeOutDir(outDir);
     return outDir;
 }
-function normalize(outDir) {
+function normalizeOutDir(outDir) {
     outDir = toPosixPath(outDir);
     outDir = outDir.replace(/\/+$/, ''); // remove trailing slashes
     return outDir;

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

@@ -1,10 +1,7 @@
+import type { ResolvedConfig, UserConfig } from 'vite';
 export { viteIsSSR };
 export { viteIsSSR_options };
-declare function viteIsSSR(config: {
-    build?: {
-        ssr?: boolean | string;
-    };
-}): boolean;
+declare function viteIsSSR(config: ResolvedConfig | UserConfig): boolean;
 type Options = undefined | boolean | {
     ssr?: boolean;
 };

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

@@ -68,7 +68,7 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
-    prerenderContextPublic: PrerenderContextPublic;
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined, config: ResolvedConfig): Promise<{
+    forceExit: boolean;
 }>;
 declare function runPrerender_forceExit(): void;

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

@@ -8,7 +8,7 @@ import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign,
 import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
-import { getGlobalContext, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
+import { getGlobalContextInternal, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
 import { resolveConfig } from 'vite';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
@@ -28,6 +28,8 @@ import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 import { setContextIsPrerendering } from './context.js';
 import { resolvePrerenderConfig, resolvePrerenderConfigLocal } from './resolvePrerenderConfig.js';
 import { getOutDirs } from '../plugin/shared/getOutDirs.js';
+import { isVikeCli } from '../cli/context.js';
+import { isViteCliCall } from '../plugin/shared/isViteCliCall.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.
@@ -45,8 +47,9 @@ async function runPrerenderFromCLIPrerenderCommand() {
         process.exit(1);
     }
     runPrerender_forceExit();
+    assert(false);
 }
-async function runPrerenderFromAutoRun(viteConfig) {
+async function runPrerenderFromAutoRun(viteConfig, config) {
     let prerenderContextPublic;
     try {
         const ret = await runPrerender({ viteConfig });
@@ -57,7 +60,9 @@ async function runPrerenderFromAutoRun(viteConfig) {
         logErrorHint(err);
         process.exit(1);
     }
-    return { prerenderContextPublic };
+    config.vike.prerenderContext = prerenderContextPublic;
+    const forceExit = isVikeCli() || isViteCliCall();
+    return { forceExit };
 }
 async function runPrerender(options = {}, standaloneTrigger) {
     setContextIsPrerendering();
@@ -85,7 +90,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
-    const globalContext = getGlobalContext();
+    const globalContext = await getGlobalContextInternal();
     globalContext.pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {
         noExtraDir: noExtraDir ?? false,
@@ -95,10 +100,10 @@ async function runPrerender(options = {}, standaloneTrigger) {
         output: []
     };
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
-    await callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList);
-    await handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit);
-    await callOnPrerenderStartHook(prerenderContext);
+    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit, globalContext);
+    await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
+    await handlePagesWithStaticRoutes(prerenderContext, globalContext, doNotPrerenderList, concurrencyLimit);
+    await callOnPrerenderStartHook(prerenderContext, globalContext);
     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) => {
@@ -108,17 +113,17 @@ async function runPrerender(options = {}, standaloneTrigger) {
         }
         await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
     };
-    await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
+    await routeAndPrerender(prerenderContext, globalContext, concurrencyLimit, onComplete);
     warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
-    await prerender404(prerenderContext, onComplete);
+    await prerender404(prerenderContext, globalContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderContext.prerenderedPageContexts, doNotPrerenderList, partial);
+    await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = makePublic(prerenderContext);
     return { viteConfig, prerenderContextPublic };
 }
-async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
+async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit, globalContext) {
     // V1 design
     pageConfigs.forEach((pageConfig) => {
         const configValue = resolvePrerenderConfigLocal(pageConfig);
@@ -136,7 +141,6 @@ async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurr
     });
     // Old design
     // TODO/v1-release: remove
-    const globalContext = getGlobalContext();
     await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
@@ -179,9 +183,8 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     assert(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
-    const globalContext = getGlobalContext();
     // V1 design
     await Promise.all(globalContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
@@ -229,7 +232,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimi
         }
         const prerenderResult = await executeHook(() => hookFn(), { hookName, hookFilePath, hookTimeout }, null);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
-        result.forEach(({ url, pageContext }) => {
+        await Promise.all(result.map(async ({ url, pageContext }) => {
             {
                 const pageContextFound = prerenderContext.pageContexts.find((pageContext) => isSameUrl(pageContext.urlOriginal, url));
                 if (pageContextFound) {
@@ -240,7 +243,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimi
                     assertUsage(false, `URL ${pc.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
                 }
             }
-            const pageContextNew = createPageContext(url, prerenderContext);
+            const pageContextNew = await createPageContext(url, prerenderContext, globalContext);
             objectAssign(pageContextNew, {
                 _providedByHook: {
                     hookFilePath,
@@ -254,12 +257,11 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimi
                 });
                 objectAssign(pageContextNew, pageContext);
             }
-        });
+        }));
     })));
 }
-async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit) {
+async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNotPrerenderList, concurrencyLimit) {
     // Pre-render pages with a static route
-    const globalContext = getGlobalContext();
     await Promise.all(globalContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
         const { pageId } = pageRoute;
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
@@ -285,7 +287,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList,
             return;
         }
         const routeParams = {};
-        const pageContext = createPageContext(urlOriginal, prerenderContext);
+        const pageContext = await createPageContext(urlOriginal, prerenderContext, globalContext);
         objectAssign(pageContext, {
             _providedByHook: null,
             routeParams,
@@ -303,7 +305,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList,
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-function createPageContext(urlOriginal, prerenderContext) {
+async function createPageContext(urlOriginal, prerenderContext, globalContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
@@ -315,13 +317,12 @@ function createPageContext(urlOriginal, prerenderContext) {
     };
     objectAssign(pageContextInit, prerenderContext.pageContextInit);
     {
-        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit);
+        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
         objectAssign(pageContext, pageContextInitEnhanced);
     }
     return pageContext;
 }
-async function callOnPrerenderStartHook(prerenderContext) {
-    const globalContext = getGlobalContext();
+async function callOnPrerenderStartHook(prerenderContext, globalContext) {
     let onPrerenderStartHook;
     // V1 design
     if (globalContext.pageConfigs.length > 0) {
@@ -448,8 +449,7 @@ async function callOnPrerenderStartHook(prerenderContext) {
     });
     addPageContextComputedUrl(prerenderContext.pageContexts);
 }
-async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete) {
-    const globalContext = getGlobalContext();
+async function routeAndPrerender(prerenderContext, globalContext, concurrencyLimit, onComplete) {
     assert(globalContext.isPrerendering);
     // Route all URLs
     await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
@@ -531,8 +531,7 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
         assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial) {
-    const globalContext = getGlobalContext();
+async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPrerenderList, partial) {
     const isV1 = globalContext.pageConfigs.length > 0;
     const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
     /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
@@ -548,11 +547,11 @@ 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(prerenderContext, onComplete) {
+async function prerender404(prerenderContext, globalContext, onComplete) {
     if (!Object.values(prerenderContext.prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
-            result = await prerender404Page(prerenderContext.pageContextInit);
+            result = await prerender404Page(prerenderContext.pageContextInit, globalContext);
         }
         catch (err) {
             assertIsNotAbort(err, 'the 404 page');

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

@@ -1,36 +1,37 @@
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
-export { getGlobalContext };
+export { getGlobalContextInternal };
 export { getViteDevServer };
 export { getViteConfig };
 export { initGlobalContext_renderPage };
 export { initGlobalContext_runPrerender };
-export { initGlobalContext_getGlobalContextAsync };
+export { initGlobalContext_getPagesAndRoutes };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
-export { setGlobalContext_vikeConfig };
-export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
+export { setGlobalContext_isProduction };
 export { setGlobalContext_buildEntry };
 export { clearGlobalContext };
 export { assertBuildInfo };
 export { getViteConfigRuntime };
+export { updateUserFiles };
 export type { BuildInfo };
+export type { GlobalContext };
+export type { GlobalContextPublic };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
-import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import type { ConfigUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
-type GlobalContextPublic = {
-    assetsManifest: null | ViteManifest;
+import type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
+type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig'>;
+type PageRuntimeInfo = Awaited<ReturnType<typeof getUserFiles>>;
+type GlobalContext = GlobalContextWithoutPublicCopy & {
+    globalContext_public: GlobalContextPublic;
 };
-type PageRuntimeInfo = Awaited<ReturnType<typeof getPageRuntimeInfo>>['userFiles'];
-type GlobalContext = {
+type GlobalContextWithoutPublicCopy = {
     viteConfigRuntime: {
         _baseViteOriginal: null | string;
     };
-    vikeConfig: {
-        global: ConfigUserFriendly;
-    };
+    config: ConfigUserFriendly['config'];
 } & PageRuntimeInfo & ({
     isProduction: false;
     isPrerendering: false;
@@ -49,40 +50,41 @@ type GlobalContext = {
     usesClientRouter: boolean;
     viteConfig: ResolvedConfig;
 })));
-declare function getGlobalContext(): GlobalContext;
+declare function getGlobalContextInternal(): Promise<GlobalContext>;
 /** @experimental https://vike.dev/getGlobalContext */
 declare function getGlobalContextSync(): GlobalContextPublic;
 /** @experimental https://vike.dev/getGlobalContext */
 declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
-declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
+declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): Promise<void>;
 declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
-declare function setGlobalContext_vikeConfig(vikeConfig: VikeConfigObject): void;
-declare function setGlobalContext_isViteDev(isViteDev: boolean): void;
 declare function setGlobalContext_isPrerendering(): void;
+declare function setGlobalContext_isProduction(isProduction: boolean): void;
 declare function getViteDevServer(): ViteDevServer | null;
 declare function getViteConfig(): ResolvedConfig | null;
 declare function initGlobalContext_renderPage(): Promise<void>;
 declare function initGlobalContext_runPrerender(): Promise<void>;
-declare function initGlobalContext_getGlobalContextAsync(isProduction: boolean): Promise<void>;
-declare function getPageRuntimeInfo(isProduction: boolean): Promise<{
-    userFiles: {
-        pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-        pageConfigs: import("../../__internal/index.js").PageConfig[];
-        pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        allPageIds: string[];
-        pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-        onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    };
-    globalConfig: ConfigUserFriendly;
+declare function initGlobalContext_getPagesAndRoutes(): Promise<void>;
+declare function getUserFiles(): Promise<{
+    pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    pageConfigs: import("../../__internal/index.js").PageConfig[];
+    pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    allPageIds: string[];
+    pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    config: import("../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
 }>;
-declare function setGlobalContext_buildEntry(buildEntry: unknown): void;
+declare function setGlobalContext_buildEntry(buildEntry: unknown): Promise<void>;
 type BuildInfo = {
     versionAtBuildTime: string;
     usesClientRouter: boolean;
     viteConfigRuntime: {
         _baseViteOriginal: string;
+        vitePluginServerEntry: {
+            inject?: NonNullable<ConfigVitePluginServerEntry['vitePluginServerEntry']>['inject'];
+        };
     };
 };
 declare function assertBuildInfo(buildInfo: unknown): asserts buildInfo is BuildInfo;
-declare function getViteConfigRuntime(viteConfig: ResolvedConfig): BuildInfo['viteConfigRuntime'];
+declare function getViteConfigRuntime(viteConfig: ResolvedConfig & ConfigVitePluginServerEntry): BuildInfo['viteConfigRuntime'];
+declare function updateUserFiles(): Promise<void>;
 declare function clearGlobalContext(): void;