vike 0.4.191 → 0.4.193-commit-38002cb

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();
+}

package/dist/esm/node/runtime/html/stream.js

@@ -55,16 +55,15 @@ async function streamReadableNodeToString(readableNode) {
 }
 async function streamReadableWebToString(readableWeb) {
     const reader = readableWeb.getReader();
-    const decoder = new TextDecoder();
+    const { decode, getClosingChunk } = decodeChunks();
     let str = '';
     while (true) {
         const { done, value } = await reader.read();
         if (done)
             break;
-        str += decoder.decode(value, { stream: true });
+        str += decode(value);
     }
-    // https://github.com/vikejs/vike/pull/1799#discussion_r1713554096
-    str += decoder.decode();
+    str += getClosingChunk();
     return str;
 }
 async function stringToStreamReadableNode(str) {
@@ -128,15 +127,16 @@ async function streamPipeNodeToString(streamPipeNode) {
     return promise;
 }
 function streamPipeWebToString(streamPipeWeb) {
+    const { decode, getClosingChunk } = decodeChunks();
     let str = '';
     let resolve;
     const promise = new Promise((r) => (resolve = r));
     const writable = new WritableStream({
         write(chunk) {
-            assert(typeof chunk === 'string');
-            str += chunk;
+            str += decode(chunk);
         },
         close() {
+            str += getClosingChunk();
             resolve(str);
         }
     });
@@ -388,9 +388,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const writeChunk = (chunk) => {
             assert(writableOriginal);
             writableOriginal.write(chunk);
-            if (debug.isActivated) {
-                debug('data written (Node.js Writable)', getChunkAsString(chunk));
-            }
+            debugWithChunk('data written (Node.js Writable)', chunk);
         };
         // For libraries such as https://www.npmjs.com/package/compression
         //  - React calls writable.flush() when available
@@ -461,9 +459,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const writeChunk = (chunk) => {
             assert(writerOriginal);
             writerOriginal.write(encodeForWebStream(chunk));
-            if (debug.isActivated) {
-                debug('data written (Web Writable)', getChunkAsString(chunk));
-            }
+            debugWithChunk('data written (Web Writable)', chunk);
         };
         // Web Streams have compression built-in
         //  - https://developer.mozilla.org/en-US/docs/Web/API/Compression_Streams_API
@@ -554,14 +550,10 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether we closed `controllerProxy`.
             !controllerProxyIsClosed) {
                 controllerProxy.enqueue(encodeForWebStream(chunk));
-                if (debug.isActivated) {
-                    debug('data written (Web Readable)', getChunkAsString(chunk));
-                }
+                debugWithChunk('data written (Web Readable)', chunk);
             }
             else {
-                if (debug.isActivated) {
-                    debug('data emitted but not written (Web Readable)', getChunkAsString(chunk));
-                }
+                debugWithChunk('data emitted but not written (Web Readable)', chunk);
             }
         };
         // Readables don't have the notion of flushing
@@ -581,9 +573,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         }
         const writeChunk = (chunk) => {
             readableProxy.push(chunk);
-            if (debug.isActivated) {
-                debug('data written (Node.js Readable)', getChunkAsString(chunk));
-            }
+            debugWithChunk('data written (Node.js Readable)', chunk);
         };
         // Readables don't have the notion of flushing
         const flushStream = null;
@@ -796,11 +786,34 @@ function inferStreamName(stream) {
     }
     assert(false);
 }
-function getChunkAsString(chunk) {
+function decodeChunks() {
+    const decoder = new TextDecoder();
+    const decode = (chunk) => {
+        if (typeof chunk === 'string') {
+            return chunk;
+        }
+        else if (chunk instanceof Uint8Array) {
+            return decoder.decode(chunk, { stream: true });
+        }
+        else {
+            assert(false);
+        }
+    };
+    // https://github.com/vikejs/vike/pull/1799#discussion_r1713554096
+    const getClosingChunk = () => {
+        return decoder.decode();
+    };
+    return { decode, getClosingChunk };
+}
+function debugWithChunk(msg, chunk) {
+    if (!debug.isActivated)
+        return;
+    let chunkStr;
     try {
-        return new TextDecoder().decode(chunk);
+        chunkStr = new TextDecoder().decode(chunk);
     }
     catch (err) {
-        return String(chunk);
+        chunkStr = String(chunk);
     }
+    debug(msg, chunkStr);
 }

package/dist/esm/node/runtime/page-files/getPageFilesExports.d.ts

@@ -0,0 +1,2 @@
+export { getPageFilesExports };
+declare function getPageFilesExports(): Promise<Record<string, unknown>>;

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

@@ -0,0 +1,20 @@
+export { getPageFilesExports };
+import { assert, debugGlob, isObject } from '../utils.js';
+import { getViteDevServer } from '../globalContext.js';
+import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
+async function getPageFilesExports() {
+    const viteDevServer = getViteDevServer();
+    assert(viteDevServer);
+    let moduleExports;
+    try {
+        moduleExports = await viteDevServer.ssrLoadModule(virtualFileIdImportUserCodeServer);
+    }
+    catch (err) {
+        debugGlob(`Glob error: ${virtualFileIdImportUserCodeServer} transpile error: `, err);
+        throw err;
+    }
+    moduleExports = moduleExports.default || moduleExports;
+    debugGlob('Glob result: ', moduleExports);
+    assert(isObject(moduleExports));
+    return moduleExports;
+}

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

@@ -1,21 +1,3 @@
 import { setPageFilesAsync } from '../../../shared/getPageFiles.js';
-import { assert, debugGlob, isObject } from '../utils.js';
-import { getViteDevServer } from '../globalContext.js';
-import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
+import { getPageFilesExports } from './getPageFilesExports.js';
 setPageFilesAsync(getPageFilesExports);
-async function getPageFilesExports() {
-    const viteDevServer = getViteDevServer();
-    assert(viteDevServer);
-    let moduleExports;
-    try {
-        moduleExports = await viteDevServer.ssrLoadModule(virtualFileIdImportUserCodeServer);
-    }
-    catch (err) {
-        debugGlob(`Glob error: ${virtualFileIdImportUserCodeServer} transpile error: `, err);
-        throw err;
-    }
-    moduleExports = moduleExports.default || moduleExports;
-    debugGlob('Glob result: ', moduleExports);
-    assert(isObject(moduleExports));
-    return moduleExports;
-}

package/dist/esm/node/runtime/renderPage/inferMediaType.d.ts

@@ -2,6 +2,6 @@ export { inferMediaType };
 export type { MediaType };
 type MediaType = null | {
     assetType: 'image' | 'script' | 'font' | 'style' | 'audio' | 'video' | 'document' | 'fetch' | 'track' | 'worker' | 'embed' | 'object';
-    mediaType: 'text/javascript' | 'text/css' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2' | 'video/mp4' | 'video/webm' | 'video/ogg' | 'video/mpeg' | 'video/x-msvideo' | 'video/quicktime' | 'audio/mpeg' | 'audio/wav' | 'audio/ogg' | 'audio/aac' | 'audio/midi' | 'audio/flac';
+    mediaType: 'text/javascript' | 'text/css' | 'image/avif' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2' | 'video/mp4' | 'video/webm' | 'video/ogg' | 'video/mpeg' | 'video/x-msvideo' | 'video/quicktime' | 'audio/mpeg' | 'audio/wav' | 'audio/ogg' | 'audio/aac' | 'audio/midi' | 'audio/flac';
 };
 declare function inferMediaType(href: string): MediaType;

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

@@ -24,6 +24,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/esm/node/runtime/renderPage.js

@@ -4,7 +4,7 @@ import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted }
 import { route } from '../../shared/route/index.js';
 import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents, isUri } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
-import { getGlobalContext, initGlobalContext } from './globalContext.js';
+import { getGlobalContext, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
 import { createHttpResponseObjectRedirect, createHttpResponsePageContextJson } from './renderPage/createHttpResponseObject.js';
 import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
@@ -61,12 +61,12 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Prepare context
     let renderContext;
     try {
-        await initGlobalContext();
+        await initGlobalContext_renderPage();
         renderContext = await 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.
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
         const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);

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

@@ -56,3 +56,4 @@ export * from '../../utils/normalizeHeaders.js';
 export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
+export * from '../../utils/genPromise.js';

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

@@ -59,3 +59,4 @@ export * from '../../utils/normalizeHeaders.js';
 export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
+export * from '../../utils/genPromise.js';

package/dist/esm/shared/ConfigVike.d.ts

@@ -7,7 +7,7 @@ type ConfigVikeResolved = {
         partial: boolean;
         disableAutoRun: boolean;
     };
-    disableAutoFullBuild: boolean | null;
+    disableAutoFullBuild: boolean | 'prerender' | null;
     includeAssetsImportedByServer: boolean;
     baseAssets: string;
     baseServer: string;
@@ -63,13 +63,13 @@ type ConfigVikeUserProvided = {
         disableAutoRun?: boolean;
     };
     /**
-     * Set to `true` to disable the automatic chaining of all the build steps.
+     * Disable the automatic chaining of build steps.
      *
      * https://vike.dev/disableAutoFullBuild
      *
      * @default false
      */
-    disableAutoFullBuild?: boolean;
+    disableAutoFullBuild?: boolean | 'prerender';
     /** The Base URL of your server.
      *
      * https://vike.dev/base-url

package/dist/esm/shared/hooks/executeHook.d.ts

@@ -4,7 +4,7 @@ export { providePageContext };
 export { isUserHookError };
 import type { PageContextClient, PageContextServer } from '../types.js';
 import type { Hook, HookLoc } from './getHook.js';
-type PageContextUnknown = null | Record<string, unknown>;
+type PageContextUnknown = null | Record<string, any>;
 declare function isUserHookError(err: unknown): false | HookLoc;
 declare function executeHook<T = unknown>(hookFnCaller: () => T, hook: Omit<Hook, 'hookFn'>, pageContext: PageContextUnknown): Promise<T>;
 /**

package/dist/esm/shared/hooks/getHook.d.ts

@@ -2,7 +2,7 @@ export { getHook };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { assertHook };
-export { setIsPrerenderering };
+export { getHook_setIsPrerenderering };
 export type { Hook };
 export type { HookName };
 export type { HookLoc };
@@ -33,4 +33,4 @@ declare function assertHook<TPageContext extends PageContextExports, THookName e
     exports: Record<THookName, Function | undefined>;
 };
 declare function getHookTimeoutDefault(hookName: HookName): HookTimeout;
-declare function setIsPrerenderering(): void;
+declare function getHook_setIsPrerenderering(): void;

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

@@ -2,7 +2,7 @@ export { getHook };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { assertHook };
-export { setIsPrerenderering };
+export { getHook_setIsPrerenderering };
 // TODO/v1-release: remove
 // We export for old V0.4 design which doesn't support configooksTimeout
 export { getHookTimeoutDefault };
@@ -11,9 +11,7 @@ import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
 import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
-const globalObject = getGlobalObject('getHook.ts', {
-    isPrerendering: false
-});
+const globalObject = getGlobalObject('getHook.ts', {});
 function getHook(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;
@@ -130,6 +128,6 @@ function getHookTimeoutDefault(hookName) {
         warning: 4 * 1000
     };
 }
-function setIsPrerenderering() {
+function getHook_setIsPrerenderering() {
     globalObject.isPrerendering = true;
 }

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -67,8 +67,6 @@ type ConfigEnv = {
 /** For Vike internal use */
 type ConfigEnvInternal = Omit<ConfigEnv, 'client'> & {
     client?: boolean | 'if-client-routing';
-    /** Always load value, no matter which page is loaded. */
-    eager?: true;
     /** Load value only in production, or only in development. */
     production?: boolean;
 };

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

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

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.d.ts

@@ -2,4 +2,6 @@ export { serializeConfigValues };
 import type { ConfigEnvInternal, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
 declare function serializeConfigValues(pageConfig: PageConfigBuildTime | (PageConfigGlobalBuildTime & {
     configValuesComputed?: undefined;
-}), importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string): string[];
+}), importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, { isEager }: {
+    isEager: boolean;
+}, tabspace: string): string[];

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

@@ -12,7 +12,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.
 assertIsNotProductionRuntime();
-function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspace) {
+function serializeConfigValues(pageConfig, importStatements, isEnvMatch, { isEager }, tabspace) {
     const lines = [];
     tabspace += '  ';
     Object.entries(pageConfig.configValuesComputed ?? {}).forEach(([configName, configValuesComputed]) => {
@@ -31,6 +31,8 @@ function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspac
     Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
         const configDef = pageConfig.configDefinitions[configName];
         assert(configDef);
+        if (isEager !== !!configDef.eager)
+            return;
         if (!configDef.cumulative) {
             const configValueSource = sources[0];
             assert(configValueSource);

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

@@ -3,6 +3,7 @@ export type { PageContextServer } from '../shared/types.js';
 export type { PageContextClient } from '../shared/types.js';
 export type { PageContextWithServerRouting } from '../shared/types.js';
 export type { PageContextClientWithServerRouting } from '../shared/types.js';
+export type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
 export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.191";
+export declare const PROJECT_VERSION: "0.4.193-commit-38002cb";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.191';
+export const PROJECT_VERSION = '0.4.193-commit-38002cb';

package/dist/esm/utils/genPromise.d.ts

@@ -0,0 +1,4 @@
+export declare function genPromise<T>(): {
+    promise: Promise<T>;
+    resolve: (val: T) => void;
+};

package/dist/esm/utils/genPromise.js

@@ -0,0 +1,5 @@
+export function genPromise() {
+    let resolve;
+    const promise = new Promise((r) => (resolve = r));
+    return { promise, resolve };
+}

package/dist/esm/utils/isArray.js

@@ -1,4 +1,4 @@
-// Typesafe Array.isArray() — asserting unknown[] instead of any[]
+// Same as Array.isArray() but typesafe: asserts unknown[] instead of any[]
 export function isArray(value) {
     return Array.isArray(value);
 }

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.191";
+    projectVersion: "0.4.193-commit-38002cb";
 };