vike 0.4.191 → 0.4.192

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -17,7 +17,7 @@ const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 // - vike/shared/page-configs/serialize/parsePageConfigs.ts
 // - parsePageConfigs() is loaded on both the client- and server-side.
 (0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
-function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspace) {
+function serializeConfigValues(pageConfig, importStatements, isEnvMatch, { isEager }, tabspace) {
     const lines = [];
     tabspace += '  ';
     Object.entries(pageConfig.configValuesComputed ?? {}).forEach(([configName, configValuesComputed]) => {
@@ -36,6 +36,8 @@ function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspac
     Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
         const configDef = pageConfig.configDefinitions[configName];
         (0, utils_js_1.assert)(configDef);
+        if (isEager !== !!configDef.eager)
+            return;
         if (!configDef.cumulative) {
             const configValueSource = sources[0];
             (0, utils_js_1.assert)(configValueSource);

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.191';
+exports.PROJECT_VERSION = '0.4.192';

package/dist/cjs/utils/genPromise.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genPromise = void 0;
+function genPromise() {
+    let resolve;
+    const promise = new Promise((r) => (resolve = r));
+    return { promise, resolve };
+}
+exports.genPromise = genPromise;

package/dist/esm/__internal/index.d.ts

@@ -1,5 +1,6 @@
 export { route, getPagesAndRoutes };
 export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
+export { getPageFilesAllSafe };
 import { route as routeInternal, type PageRoutes } from '../shared/route/index.js';
 import { type PageFile } from '../shared/getPageFiles.js';
 import { PageConfigRuntime } from '../shared/page-configs/PageConfig.js';
@@ -15,6 +16,12 @@ declare function getPagesAndRoutes(): Promise<{
     pageConfigs: PageConfigRuntime[];
     allPageIds: string[];
 }>;
+declare function getPageFilesAllSafe(isProduction: boolean): Promise<{
+    pageFilesAll: PageFile[];
+    allPageIds: string[];
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: import("../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+}>;
 declare function route(pageContext: Parameters<typeof routeInternal>[0]): Promise<{
     pageContextAddendum: import("../shared/route/index.js").PageContextFromRoute;
 }>;

package/dist/esm/__internal/index.js

@@ -1,9 +1,11 @@
 // Internals needed by vite-plugin-vercel
 export { route, getPagesAndRoutes };
+// Internals needed by nitedani's experimental implementation of vike-telefunc
+export { getPageFilesAllSafe };
 import { route as routeInternal } from '../shared/route/index.js';
-import { getGlobalContext, initGlobalContext } from '../node/runtime/globalContext.js';
+import { getPageFilesAll } from '../shared/getPageFiles.js';
+import { getGlobalContext, initGlobalContext_getGlobalContextAsync } from '../node/runtime/globalContext.js';
 import { handleNodeEnv_vitePluginVercel } from '../utils/assertNodeEnv.js';
-import { assert } from '../utils/assert.js';
 import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRouted.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
@@ -13,11 +15,10 @@ import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRo
  */
 async function getPagesAndRoutes() {
     handleNodeEnv_vitePluginVercel();
-    await initGlobalContext(true);
-    const globalContext = getGlobalContext();
-    assert(globalContext.isProduction === true);
     const renderContext = await getRenderContext();
-    const { pageFilesAll, pageConfigs, allPageIds, pageRoutes } = renderContext;
+    const { 
+    //
+    pageRoutes, pageFilesAll, pageConfigs, allPageIds } = renderContext;
     return {
         pageRoutes,
         pageFilesAll,
@@ -25,6 +26,14 @@ async function getPagesAndRoutes() {
         allPageIds
     };
 }
+// TODO: make it cleaner once the internal refactoring about global configs is done.
+// Demo usage: https://github.com/vikejs/vike/pull/1823
+async function getPageFilesAllSafe(isProduction) {
+    await initGlobalContext_getGlobalContextAsync(isProduction);
+    const globalContext = getGlobalContext();
+    const pageFilesAll = await getPageFilesAll(false, globalContext.isProduction);
+    return pageFilesAll;
+}
 async function route(pageContext) {
     const pageContextFromRoute = await routeInternal(pageContext);
     // Old interface

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

@@ -88,23 +88,27 @@ async function triggerFullBuild(config, configVike, bundle) {
         logErrorHint(err);
         process.exit(1);
     }
-    if (configVike.prerender && !configVike.prerender.disableAutoRun) {
+    if (configVike.prerender && !configVike.prerender.disableAutoRun && configVike.disableAutoFullBuild !== 'prerender') {
         await runPrerenderFromAutoFullBuild({ viteConfig: configInline });
         forceExit = true;
     }
 }
 function abortViteBuildSsr(configVike) {
-    if (!configVike.disableAutoFullBuild && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+    if (configVike.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
         assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
         process.exit(0);
     }
 }
 function isDisabled(configVike) {
-    if (configVike.disableAutoFullBuild === null) {
-        // TODO/v1-release: also enable autoFullBuild when running Vite's build() API
+    const { disableAutoFullBuild } = configVike;
+    if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
+        // TODO/v1-release: remove autoFullBuild for both Vite's build() API and Vite's CLI
+        //  - Tell users to use `$ vike build` instead of `$ vite build`
+        //  - Remove the whole writeBundle() hook logic
+        //  - make `$ vite build` only build the client-side
         return !isViteCliCall();
     }
     else {
-        return configVike.disableAutoFullBuild;
+        return disableAutoFullBuild;
     }
 }

package/dist/esm/node/plugin/plugins/config/assertVikeConfig.js

@@ -27,8 +27,10 @@ function checkConfigVike(configVike) {
     }
     {
         const prop = 'disableAutoFullBuild';
-        if (!hasProp(configVike, prop, 'boolean') && !hasProp(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
+        if (!hasProp(configVike, prop, 'boolean') &&
+            !hasProp(configVike, prop, 'undefined') &&
+            !(configVike[prop] === 'prerender'))
+            return { prop, errMsg: "should be a boolean or 'prerender'" };
     }
     {
         const prop = 'includeAssetsImportedByServer';

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.d.ts

@@ -31,6 +31,14 @@ type ConfigDefinition = {
      * https://vike.dev/meta
      */
     effect?: ConfigEffect;
+    /**
+     * Always load the configuration value, and as soon as possible.
+     *
+     * @default false
+     *
+     * https://vike.dev/meta
+     */
+    eager?: boolean;
     /**
      * Whether the configuration always applies to all pages (no config inheritance).
      *

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

@@ -32,7 +32,8 @@ const configDefinitionsBuiltIn = {
         cumulative: true
     },
     route: {
-        env: { server: true, client: 'if-client-routing', eager: true }
+        env: { server: true, client: 'if-client-routing' },
+        eager: true
     },
     guard: {
         env: { server: true, client: 'if-client-routing' }
@@ -41,7 +42,8 @@ const configDefinitionsBuiltIn = {
         env: { server: true }
     },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
-        env: { server: true, client: 'if-client-routing', eager: true }
+        env: { server: true, client: 'if-client-routing' },
+        eager: true
     },
     filesystemRoutingRoot: {
         env: { config: true }
@@ -53,7 +55,8 @@ const configDefinitionsBuiltIn = {
     },
     clientRouting: {
         // We could make it { client: false } but we don't yet because of some legacy V0.4 design code
-        env: { server: true, client: true, config: true, eager: true }
+        env: { server: true, client: true, config: true },
+        eager: true
     },
     clientHooks: {
         env: { config: true }
@@ -74,7 +77,8 @@ const configDefinitionsBuiltIn = {
         env: { config: true }
     },
     clientEntryLoaded: {
-        env: { server: true, client: true, eager: true },
+        env: { server: true, client: true },
+        eager: true,
         _computed: (configValueSources) => {
             {
                 const source = getConfigValueSource(configValueSources, 'clientHooks');
@@ -116,10 +120,12 @@ const configDefinitionsBuiltIn = {
 };
 const configDefinitionsBuiltInGlobal = {
     onPrerenderStart: {
-        env: { server: true, production: true, eager: true }
+        env: { server: true, production: true },
+        eager: true
     },
     onBeforeRoute: {
-        env: { server: true, client: 'if-client-routing', eager: true }
+        env: { server: true, client: 'if-client-routing' },
+        eager: true
     },
     prerender: {
         env: { config: true }

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

@@ -32,7 +32,7 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const importStatements = [];
     const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesSerialized = {');
-    lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: false, isDev }), ''));
+    lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: false }, ''));
     lines.push('};');
     if (!fixServerAssets_isEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
         importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);

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

@@ -32,7 +32,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
         lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true, isDev }), '    '));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: true }, '    '));
         lines.push(`    },`);
         lines.push(`  },`);
     });
@@ -42,7 +42,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
 function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true, isDev }), '    '));
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: true }, '    '));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/isRuntimeEnvMatch.d.ts

@@ -3,6 +3,5 @@ import type { ConfigEnvInternal } from '../../../../../shared/page-configs/PageC
 declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtime: {
     isForClientSide: boolean;
     isClientRouting: boolean;
-    isEager: boolean;
     isDev: boolean;
 }): boolean;

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

@@ -11,9 +11,6 @@ function isRuntimeEnvMatch(configEnv, runtime) {
         if (configEnv.client === 'if-client-routing' && !runtime.isClientRouting)
             return false;
     }
-    // Eager
-    if (runtime.isEager !== !!configEnv.eager)
-        return false;
     // Production/development
     if (
     //

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

@@ -1,6 +1,6 @@
 export { setGlobalContext };
-import { setGlobalContext_isDev, setGlobalContext_viteDevServer } from '../../runtime/globalContext.js';
-import { isDev3 } from '../utils.js';
+import { setGlobalContext_isDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
+import { assertFilePathAbsoluteFilesystem, getOutDirs, isDev3 } from '../utils.js';
 function setGlobalContext() {
     return {
         name: 'vike:setGlobalContext',
@@ -16,6 +16,11 @@ function setGlobalContext() {
                 const isDev = isDev3(env);
                 setGlobalContext_isDev(isDev);
             }
+        },
+        configResolved(config) {
+            const { outDirRoot } = getOutDirs(config);
+            assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+            setGlobalContext_viteConfig(config, outDirRoot);
         }
     };
 }

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

@@ -5,11 +5,11 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 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, handleNodeEnv_prerender, pLimit, assertFilePathAbsoluteFilesystem, isArray, changeEnumerable } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, isArray, changeEnumerable } from './utils.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
-import { getGlobalContext, initGlobalContext, setGlobalContext_prerender } from '../runtime/globalContext.js';
+import { getGlobalContext, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
 import { resolveConfig } from 'vite';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
@@ -22,7 +22,7 @@ import { isErrorPage } from '../../shared/error-page.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { isAbortError } from '../../shared/route/abort.js';
 import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServerSide.js';
-import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } from '../../shared/hooks/getHook.js';
+import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, getHook_setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
@@ -55,7 +55,8 @@ async function runPrerenderFromAutoFullBuild(options) {
 }
 async function runPrerender(options, manuallyTriggered) {
     checkOutdatedOptions(options);
-    setIsPrerenderering();
+    setGlobalContext_isPrerendering();
+    getHook_setIsPrerenderering();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
@@ -63,10 +64,9 @@ async function runPrerender(options, manuallyTriggered) {
     handleNodeEnv_prerender();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
-    setGlobalContext_prerender(viteConfig);
     assertLoadedConfig(viteConfig, options);
     const configVike = await getConfigVike(viteConfig);
-    const { outDirClient, outDirRoot } = getOutDirs(viteConfig);
+    const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = configVike.prerender;
     if (!prerenderConfig) {
@@ -77,8 +77,7 @@ async function runPrerender(options, manuallyTriggered) {
     }
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
-    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
-    await initGlobalContext(true, outDirRoot);
+    await initGlobalContext_runPrerender();
     const renderContext = await getRenderContext();
     renderContext.pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {};

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

@@ -1,13 +1,16 @@
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
-export { initGlobalContext };
 export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
+export { getRuntimeManifest };
+export { initGlobalContext_renderPage };
+export { initGlobalContext_runPrerender };
+export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
+export { setGlobalContext_viteConfig };
 export { setGlobalContext_isDev };
-export { setGlobalContext_prerender };
-export { getRuntimeManifest };
+export { setGlobalContext_isPrerendering };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { PluginManifest } from '../shared/assertPluginManifest.js';
@@ -46,11 +49,14 @@ declare function getGlobalContext(): GlobalContext;
 /** @experimental https://vike.dev/getGlobalContext */
 declare function getGlobalContextSync(): GlobalContextPublic;
 /** @experimental https://vike.dev/getGlobalContext */
-declare function getGlobalContextAsync(): Promise<GlobalContextPublic>;
+declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
+declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
 declare function setGlobalContext_isDev(isDev: boolean): void;
+declare function setGlobalContext_isPrerendering(): void;
 declare function getViteDevServer(): ViteDevServer | null;
-declare function setGlobalContext_prerender(viteConfig: ResolvedConfig): void;
 declare function getViteConfig(): ResolvedConfig | null;
-declare function initGlobalContext(isPrerendering?: boolean, outDir?: string): Promise<void>;
+declare function initGlobalContext_renderPage(): Promise<void>;
+declare function initGlobalContext_runPrerender(): Promise<void>;
+declare function initGlobalContext_getGlobalContextAsync(isProduction: boolean): Promise<void>;
 declare function getRuntimeManifest(configVike: ConfigVikeResolved): RuntimeManifest;

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

@@ -2,25 +2,32 @@
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
 // Internal use
-export { initGlobalContext };
 export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
+export { getRuntimeManifest };
+export { initGlobalContext_renderPage };
+export { initGlobalContext_runPrerender };
+export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
+export { setGlobalContext_viteConfig };
 export { setGlobalContext_isDev };
-export { setGlobalContext_prerender };
-export { getRuntimeManifest };
-import { assert, assertNodeEnv_runtime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys } from './utils.js';
+export { setGlobalContext_isPrerendering };
+import { assert, assertNodeEnv_runtime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys, genPromise } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { assertRuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import pc from '@brillout/picocolors';
-let resolveGlobalContext;
-const globalObject = getGlobalObject('globalContext.ts', {
-    globalContextPromise: new Promise((r) => (resolveGlobalContext = r))
-});
+import { getPageFilesExports } from './page-files/getPageFilesExports.js';
+const globalObject = getGlobalObject('globalContext.ts', (() => {
+    const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
+    return {
+        viteDevServerPromise,
+        viteDevServerPromiseResolve
+    };
+})());
 function getGlobalContext() {
     assert(globalObject.globalContext);
     return globalObject.globalContext;
@@ -31,10 +38,12 @@ function getGlobalContextSync() {
     return makePublic(globalObject.globalContext);
 }
 /** @experimental https://vike.dev/getGlobalContext */
-async function getGlobalContextAsync() {
-    await globalObject.globalContextPromise;
-    assert(globalObject.globalContext);
-    return makePublic(globalObject.globalContext);
+async function getGlobalContextAsync(isProduction) {
+    assertUsage(typeof isProduction === 'boolean', `[getGlobalContextAsync(isProduction)] Argument ${pc.cyan('isProduction')} ${isProduction === undefined ? 'is missing' : `should be ${pc.cyan('true')} or ${pc.cyan('false')}`}`);
+    await initGlobalContext_getGlobalContextAsync(isProduction);
+    const { globalContext } = globalObject;
+    assert(globalContext);
+    return makePublic(globalContext);
 }
 function makePublic(globalContext) {
     const globalContextPublic = {
@@ -63,34 +72,78 @@ function makePublic(globalContext) {
 function setGlobalContext_viteDevServer(viteDevServer) {
     if (globalObject.viteDevServer)
         return;
-    assert(!globalObject.globalContext);
-    globalObject.viteConfig = viteDevServer.config;
+    assertIsNotInitilizedYet();
+    assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
+    globalObject.viteDevServerPromiseResolve(viteDevServer);
+    eagerlyLoadUserFiles();
+}
+function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
+    if (globalObject.viteConfig)
+        return;
+    assertIsNotInitilizedYet();
+    globalObject.viteConfig = viteConfig;
+    globalObject.outDirRoot = outDirRoot;
+}
+function assertIsNotInitilizedYet() {
+    // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
+    assert(!globalObject.globalContext);
 }
 function setGlobalContext_isDev(isDev) {
     globalObject.isDev = isDev;
 }
+function setGlobalContext_isPrerendering() {
+    globalObject.isPrerendering = true;
+}
 function getViteDevServer() {
     return globalObject.viteDevServer ?? null;
 }
-function setGlobalContext_prerender(viteConfig) {
-    if (globalObject.viteConfig)
+function getViteConfig() {
+    return globalObject.viteConfig ?? null;
+}
+async function initGlobalContext_renderPage() {
+    await initGlobalContext(!globalObject.isDev);
+}
+async function initGlobalContext_runPrerender() {
+    if (globalObject.initGlobalContext_runPrerender_alreadyCalled)
         return;
+    globalObject.initGlobalContext_runPrerender_alreadyCalled = true;
+    assert(globalObject.isPrerendering);
+    assert(globalObject.viteConfig);
+    assert(globalObject.outDirRoot);
+    // We assume initGlobalContext_runPrerender() to be called before:
+    // - initGlobalContext_renderPage()
+    // - initGlobalContext_getGlobalContextAsync()
     assert(!globalObject.globalContext);
-    globalObject.viteConfig = viteConfig;
+    await initGlobalContext(true);
 }
-function getViteConfig() {
-    return globalObject.viteConfig ?? null;
+async function initGlobalContext_getGlobalContextAsync(isProduction) {
+    if (!isProduction) {
+        const waitFor = 20;
+        const timeout = setTimeout(() => {
+            assertWarning(false, `Vite's development server still not created after ${waitFor} seconds.`, {
+                onlyOnce: false,
+                showStackTrace: true
+            });
+        }, waitFor * 1000);
+        await globalObject.viteDevServerPromise;
+        clearTimeout(timeout);
+    }
+    await initGlobalContext(isProduction);
 }
-async function initGlobalContext(isPrerendering = false, outDir) {
-    if (globalObject.globalContext)
+async function initGlobalContext(isProduction) {
+    if (globalObject.globalContext) {
+        assert(globalObject.globalContext.isProduction === isProduction);
+        // We assume setGlobalContext_isPrerendering() is called before initGlobalContext()
+        assert(globalObject.globalContext.isPrerendering === (globalObject.isPrerendering ?? false));
         return;
-    const { viteDevServer, viteConfig, isDev } = globalObject;
+    }
+    const { viteDevServer, viteConfig, isDev, isPrerendering } = globalObject;
     assertNodeEnv_runtime(isDev ?? false);
-    if (isDev) {
+    if (!isProduction) {
         assert(viteConfig);
-        assert(!isPrerendering);
         assert(viteDevServer);
+        assert(!isPrerendering);
         const configVike = await getConfigVike(viteConfig);
         const pluginManifest = getRuntimeManifest(configVike);
         globalObject.globalContext = {
@@ -109,7 +162,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
         };
     }
     else {
-        const buildEntries = await loadImportBuild(outDir);
+        const buildEntries = await loadImportBuild(globalObject.outDirRoot);
         assertBuildEntries(buildEntries, isPrerendering ?? false);
         const { pageFiles, assetsManifest, pluginManifest } = buildEntries;
         setPageFiles(pageFiles);
@@ -145,7 +198,6 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             globalObject.globalContext = globalContext;
         }
     }
-    resolveGlobalContext(globalObject.globalContext);
 }
 function getRuntimeManifest(configVike) {
     const { includeAssetsImportedByServer, baseServer, baseAssets, redirects, trailingSlash, disableUrlNormalization } = configVike;
@@ -182,3 +234,8 @@ function assertViteManifest(manifest) {
       })
     */
 }
+function eagerlyLoadUserFiles() {
+    // Other than here, the getPageFilesExports() function is only called only upon calling the renderPage() function.
+    // We call it as early as possible here for better performance.
+    getPageFilesExports();
+}