vike 0.4.220 → 0.4.221-commit-8577456

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

@@ -4,16 +4,15 @@ 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, 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';
-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';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
-import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
 import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueRuntime.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
@@ -25,8 +24,12 @@ import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 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, 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.
@@ -44,18 +47,25 @@ async function runPrerenderFromCLIPrerenderCommand() {
         process.exit(1);
     }
     runPrerender_forceExit();
+    assert(false);
 }
-async function runPrerenderFromAutoRun(viteConfig) {
+async function runPrerenderFromAutoRun(viteConfig, config) {
+    let prerenderContextPublic;
     try {
-        await runPrerender({ viteConfig });
+        const ret = await runPrerender({ viteConfig });
+        prerenderContextPublic = ret.prerenderContextPublic;
     }
     catch (err) {
         console.error(err);
         logErrorHint(err);
         process.exit(1);
     }
+    config.vike.prerenderContext = prerenderContextPublic;
+    const forceExit = isVikeCli() || isViteCliCall();
+    return { forceExit };
 }
 async function runPrerender(options = {}, standaloneTrigger) {
+    setContextIsPrerendering();
     checkOutdatedOptions(options);
     onSetupPrerender();
     setGlobalContext_isPrerendering();
@@ -69,7 +79,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);
     validatePrerenderConfig(prerenderConfig);
     if (!prerenderConfig) {
         assert(standaloneTrigger);
@@ -80,46 +90,47 @@ 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 = {};
-    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 = {};
+    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) => {
         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);
+    await routeAndPrerender(prerenderContext, globalContext, concurrencyLimit, onComplete);
+    warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderContext, globalContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial);
-    return { viteConfig };
+    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 configName = 'prerender';
-        const configValue = getConfigValueBuildTime(pageConfig, configName, 'boolean');
-        if (configValue?.value === false) {
-            const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
-            assert(configValueFilePathToShowToUser);
+        const configValue = resolvePrerenderConfigLocal(pageConfig);
+        if (!configValue)
+            return;
+        const { value, configValueFilePathToShowToUser } = configValue;
+        if (value === false) {
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,
                 setByConfigName: 'prerender',
@@ -130,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);
@@ -173,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';
@@ -223,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) {
@@ -234,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,
@@ -248,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)) {
@@ -279,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,
@@ -297,11 +305,11 @@ 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,
-        _noExtraDir: prerenderContext._noExtraDir,
+        _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
@@ -309,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) {
@@ -387,17 +394,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;
@@ -439,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 () => {
@@ -504,7 +513,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir,
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
             pageId
         });
     })));
@@ -522,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)
@@ -539,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(prerenderedPageContexts, prerenderContext, onComplete) {
-    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
+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');
@@ -563,22 +571,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 +599,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 +773,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,8 @@ 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 '../../utils/isPropertyGetter.js';
-export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/path.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertSetup.js';
@@ -15,3 +14,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,8 @@ 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 '../../utils/isPropertyGetter.js';
-export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/path.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertSetup.js';
@@ -17,3 +16,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

@@ -1,38 +1,37 @@
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
-export { getGlobalContext };
+export { getGlobalContextInternal };
 export { getViteDevServer };
 export { getViteConfig };
-export { getRuntimeManifest };
 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 { 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 = {
-    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 = {
-    baseServer: string;
-    baseAssets: null | string;
-    includeAssetsImportedByServer: boolean;
-    trailingSlash: boolean;
-    disableUrlNormalization: boolean;
-    vikeConfig: {
-        global: ConfigUserFriendly;
+type GlobalContextWithoutPublicCopy = {
+    viteConfigRuntime: {
+        _baseViteOriginal: null | string;
     };
+    config: ConfigUserFriendly['config'];
 } & PageRuntimeInfo & ({
     isProduction: false;
     isPrerendering: false;
@@ -51,32 +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 getRuntimeManifest(vikeConfigGlobal: VikeConfigGlobal, viteConfig: ResolvedConfig): RuntimeManifest;
-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 & ConfigVitePluginServerEntry): BuildInfo['viteConfigRuntime'];
+declare function updateUserFiles(): Promise<void>;
 declare function clearGlobalContext(): void;