vike 0.4.191 → 0.4.193-commit-38002cb

package/dist/cjs/node/runtime/page-files/getPageFilesExports.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageFilesExports = void 0;
+const utils_js_1 = require("../utils.js");
+const globalContext_js_1 = require("../globalContext.js");
+const virtualFileImportUserCode_js_1 = require("../../shared/virtual-files/virtualFileImportUserCode.js");
+async function getPageFilesExports() {
+    const viteDevServer = (0, globalContext_js_1.getViteDevServer)();
+    (0, utils_js_1.assert)(viteDevServer);
+    let moduleExports;
+    try {
+        moduleExports = await viteDevServer.ssrLoadModule(virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer);
+    }
+    catch (err) {
+        (0, utils_js_1.debugGlob)(`Glob error: ${virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer} transpile error: `, err);
+        throw err;
+    }
+    moduleExports = moduleExports.default || moduleExports;
+    (0, utils_js_1.debugGlob)('Glob result: ', moduleExports);
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(moduleExports));
+    return moduleExports;
+}
+exports.getPageFilesExports = getPageFilesExports;

package/dist/cjs/node/runtime/page-files/setup.js

@@ -1,23 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const getPageFiles_js_1 = require("../../../shared/getPageFiles.js");
-const utils_js_1 = require("../utils.js");
-const globalContext_js_1 = require("../globalContext.js");
-const virtualFileImportUserCode_js_1 = require("../../shared/virtual-files/virtualFileImportUserCode.js");
-(0, getPageFiles_js_1.setPageFilesAsync)(getPageFilesExports);
-async function getPageFilesExports() {
-    const viteDevServer = (0, globalContext_js_1.getViteDevServer)();
-    (0, utils_js_1.assert)(viteDevServer);
-    let moduleExports;
-    try {
-        moduleExports = await viteDevServer.ssrLoadModule(virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer);
-    }
-    catch (err) {
-        (0, utils_js_1.debugGlob)(`Glob error: ${virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer} transpile error: `, err);
-        throw err;
-    }
-    moduleExports = moduleExports.default || moduleExports;
-    (0, utils_js_1.debugGlob)('Glob result: ', moduleExports);
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(moduleExports));
-    return moduleExports;
-}
+const getPageFilesExports_js_1 = require("./getPageFilesExports.js");
+(0, getPageFiles_js_1.setPageFilesAsync)(getPageFilesExports_js_1.getPageFilesExports);

package/dist/cjs/node/runtime/renderPage/inferMediaType.js

@@ -26,6 +26,9 @@ function inferMediaType(href) {
     if (href.endsWith('.svg')) {
         return { assetType: 'image', mediaType: 'image/svg+xml' };
     }
+    if (href.endsWith('.avif')) {
+        return { assetType: 'image', mediaType: 'image/avif' };
+    }
     // Fonts
     if (href.endsWith('.ttf')) {
         return { assetType: 'font', mediaType: 'font/ttf' };

package/dist/cjs/node/runtime/renderPage.js

@@ -67,12 +67,12 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Prepare context
     let renderContext;
     try {
-        await (0, globalContext_js_1.initGlobalContext)();
+        await (0, globalContext_js_1.initGlobalContext_renderPage)();
         renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
     }
     catch (err) {
-        // Errors are expected since assertUsage() is used in both initGlobalContext() and getRenderContext().
-        // initGlobalContext() and getRenderContext() don't call any user hooks => err isn't thrown from user code
+        // Errors are expected since assertUsage() is used in both initGlobalContext_renderPage() and getRenderContext().
+        // initGlobalContext_renderPage() and getRenderContext() don't call any user hooks => err isn't thrown from user code.
         (0, utils_js_1.assert)(!(0, abort_js_1.isAbortError)(err));
         (0, loggerRuntime_js_1.logRuntimeError)(err, httpRequestId);
         const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);

package/dist/cjs/node/runtime/utils.js

@@ -75,3 +75,4 @@ __exportStar(require("../../utils/normalizeHeaders.js"), exports);
 __exportStar(require("../../utils/isVikeReactApp.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
+__exportStar(require("../../utils/genPromise.js"), exports);

package/dist/cjs/shared/hooks/getHook.js

@@ -3,15 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHookTimeoutDefault = exports.setIsPrerenderering = exports.assertHook = exports.getHookFromPageConfigGlobal = exports.getHookFromPageConfig = exports.getHook = void 0;
+exports.getHookTimeoutDefault = exports.getHook_setIsPrerenderering = exports.assertHook = exports.getHookFromPageConfigGlobal = exports.getHookFromPageConfig = exports.getHook = void 0;
 const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
 const helpers_js_1 = require("../page-configs/helpers.js");
 const getConfigValue_js_1 = require("../page-configs/getConfigValue.js");
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('getHook.ts', {
-    isPrerendering: false
-});
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('getHook.ts', {});
 function getHook(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;
@@ -133,7 +131,7 @@ function getHookTimeoutDefault(hookName) {
     };
 }
 exports.getHookTimeoutDefault = getHookTimeoutDefault;
-function setIsPrerenderering() {
+function getHook_setIsPrerenderering() {
     globalObject.isPrerendering = true;
 }
-exports.setIsPrerenderering = setIsPrerenderering;
+exports.getHook_setIsPrerenderering = getHook_setIsPrerenderering;

package/dist/cjs/shared/page-configs/assertPlusFileExport.js

@@ -24,6 +24,7 @@ function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
     }
     const exportDefault = picocolors_1.default.code('export default');
     const exportNamed = picocolors_1.default.code(`export { ${configName} }`);
+    (0, utils_js_1.assert)(exportNamesValid.length <= 2);
     if (exportNamesValid.length === 0) {
         (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} should have a ${exportNamed} or ${exportDefault}`);
     }
@@ -32,8 +33,6 @@ function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
             onlyOnce: true
         });
     }
-    (0, utils_js_1.assert)(exportNamesValid.length === 1);
-    (0, utils_js_1.assert)(exportNamesInvalid.length > 0);
     if (!TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext))) {
         exportNamesInvalid.forEach((exportInvalid) => {
             (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} unexpected ${picocolors_1.default.cyan(`export { ${exportInvalid} }`)}`, {

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.193-commit-38002cb';

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/cjs/utils/isArray.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isArray = void 0;
-// Typesafe Array.isArray() — asserting unknown[] instead of any[]
+// Same as Array.isArray() but typesafe: asserts unknown[] instead of any[]
 function isArray(value) {
     return Array.isArray(value);
 }

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/buildConfig.js

@@ -12,7 +12,7 @@ import { createRequire } from 'module';
 import fs from 'fs/promises';
 import path from 'path';
 import { fixServerAssets, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
-import { set_constant_ASSETS_MAP } from './importBuild/index.js';
+import { set_ASSETS_MAP } from './importBuild/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
@@ -71,7 +71,7 @@ function buildConfig() {
             name: 'vike:buildConfig:writeBundle',
             apply: 'build',
             // Make sure other writeBundle() hooks are called after this writeBundle() hook.
-            //  - set_constant_ASSETS_MAP() needs to be called before dist/server/ code is executed.
+            //  - set_ASSETS_MAP() needs to be called before dist/server/ code is executed.
             //    - For example, the writeBundle() hook of vite-plugin-vercel needs to be called after this writeBundle() hook, otherwise: https://github.com/vikejs/vike/issues/1527
             enforce: 'pre',
             writeBundle: {
@@ -94,7 +94,7 @@ function buildConfig() {
                         }
                         await fs.rm(clientManifestFilePath);
                         await fs.rm(serverManifestFilePath);
-                        await set_constant_ASSETS_MAP(options, bundle);
+                        await set_ASSETS_MAP(options, bundle);
                     }
                 }
             }

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/importBuild/index.d.ts

@@ -1,8 +1,8 @@
 export { importBuild };
-export { set_constant_ASSETS_MAP };
+export { set_ASSETS_MAP };
 import type { Plugin, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 type Options = Rollup.NormalizedOutputOptions;
 declare function importBuild(): Plugin[];
 /** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
-declare function set_constant_ASSETS_MAP(options: Options, bundle: Bundle): Promise<void>;
+declare function set_ASSETS_MAP(options: Options, bundle: Bundle): Promise<void>;

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -1,6 +1,6 @@
 export { importBuild };
-export { set_constant_ASSETS_MAP };
-import { serverEntryPlugin, findServerEntry } from '@brillout/vite-plugin-server-entry/plugin.js';
+export { set_ASSETS_MAP };
+import { serverEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
 import { assert, getOutDirs, toPosixPath } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
@@ -54,21 +54,31 @@ function getEntryCode(config, configVike) {
     return importerCode;
 }
 /** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
-async function set_constant_ASSETS_MAP(options, bundle) {
+async function set_ASSETS_MAP(options, bundle) {
     const { dir } = options;
     assert(dir);
-    // This will probably fail with @vitejs/plugin-legacy
-    //  - See `git log -p` for how we used to workaround the @vitejs/plugin-legacy issue.
-    const serverEntry = findServerEntry(bundle);
-    const serverEntryFilePath = path.join(dir, serverEntry.fileName);
+    const chunkPath = find_ASSETS_MAP(bundle);
+    const chunkFilePath = path.join(dir, chunkPath);
     const assetsJsonFilePath = path.join(dir, '..', 'assets.json');
-    const [assetsJsonString, serverEntryFileContent] = await Promise.all([
+    const [assetsJsonString, chunkFileContent] = await Promise.all([
         await fs.readFile(assetsJsonFilePath, 'utf8'),
-        await fs.readFile(serverEntryFilePath, 'utf8')
+        await fs.readFile(chunkFilePath, 'utf8')
     ]);
-    const serverEntryFileContentPatched = serverEntryFileContent.replace(ASSETS_MAP, assetsJsonString);
-    assert(serverEntryFileContentPatched !== serverEntryFileContent);
-    await fs.writeFile(serverEntryFilePath, serverEntryFileContentPatched);
+    const serverEntryFileContentPatched = chunkFileContent.replace(ASSETS_MAP, assetsJsonString);
+    assert(serverEntryFileContentPatched !== chunkFileContent);
+    await fs.writeFile(chunkFilePath, serverEntryFileContentPatched);
+}
+function find_ASSETS_MAP(bundle) {
+    let chunkPath;
+    for (const filePath in bundle) {
+        const chunk = bundle[filePath];
+        if ('code' in chunk && chunk.code.includes(ASSETS_MAP)) {
+            assert(!chunkPath);
+            chunkPath = filePath;
+        }
+    }
+    assert(chunkPath);
+    return chunkPath;
 }
 function getImportPath(config) {
     // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct

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/loadImportBuild.js

@@ -1,6 +1,6 @@
 export { loadImportBuild };
 export { setImportBuildGetters };
-import { importServerEntry } from '@brillout/vite-plugin-server-entry/importServerEntry.js';
+import { importServerEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { assert } from '../utils.js';
 const buildGetters = (globalThis.__vike_buildGetters = globalThis.__vike_buildGetters || {
     getters: null

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;