vike 0.4.237 → 0.4.238

package/dist/esm/node/vite/shared/getHttpRequestAsyncStore.js

@@ -9,13 +9,15 @@
 export { getHttpRequestAsyncStore };
 export { installHttpRequestAsyncStore };
 import { renderPage_addAsyncHookwrapper } from '../../runtime/renderPage.js';
-import { assert, assertIsNotProductionRuntime, isObject, unique } from '../utils.js';
+import { assert, assertIsNotProductionRuntime, getGlobalObject, isObject, unique } from '../utils.js';
 import { getConfigBuildErrorFormatted } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { logErrorDebugNote } from './loggerNotProd.js';
 import { isEquivalentErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
 import { isDeepStrictEqual } from 'node:util';
 assertIsNotProductionRuntime();
-let asyncLocalStorage = null;
+const globalObject = getGlobalObject('getHttpRequestAsyncStore.ts', {
+    asyncLocalStorage: null,
+});
 async function installHttpRequestAsyncStore() {
     let mod;
     try {
@@ -24,9 +26,9 @@ async function installHttpRequestAsyncStore() {
     catch {
         return;
     }
-    asyncLocalStorage = new mod.AsyncLocalStorage();
+    globalObject.asyncLocalStorage = new mod.AsyncLocalStorage();
     renderPage_addAsyncHookwrapper(async (httpRequestId, renderPage) => {
-        assert(asyncLocalStorage);
+        assert(globalObject.asyncLocalStorage);
         const loggedErrors = new Set();
         const markErrorAsLogged = (err) => {
             loggedErrors.add(err);
@@ -49,15 +51,15 @@ async function installHttpRequestAsyncStore() {
             shouldErrorBeSwallowed,
             errorDebugNoteAlreadyShown: false,
         };
-        const pageContextReturn = await asyncLocalStorage.run(store, renderPage);
+        const pageContextReturn = await globalObject.asyncLocalStorage.run(store, renderPage);
         return { pageContextReturn };
     });
     return;
 }
 function getHttpRequestAsyncStore() {
-    if (asyncLocalStorage === null)
+    if (globalObject.asyncLocalStorage === null)
         return null;
-    const store = asyncLocalStorage.getStore();
+    const store = globalObject.asyncLocalStorage.getStore();
     assert(store === undefined || isObject(store));
     return store;
 }

package/dist/esm/node/vite/shared/getMagicString.js

@@ -1,6 +1,6 @@
 export { getMagicString };
 import MagicString from 'magic-string';
-// TODO/now use everywhere
+// Used everywhere instead of `new MagicString()` for consistent source map generation
 function getMagicString(code, id) {
     const magicString = new MagicString(code);
     const getMagicStringResult = () => {

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

@@ -1,7 +1,8 @@
 export { getOutDirs };
 export { resolveOutDir };
 export type { OutDirs };
-import type { UserConfig, ResolvedConfig, Environment } from 'vite';
+import type { UserConfig, ResolvedConfig } from 'vite';
+import { type ViteEnv } from './isViteServerSide.js';
 type OutDirs = {
     /** Absolute path to `outDir` */
     outDirRoot: string;
@@ -10,6 +11,6 @@ type OutDirs = {
     /** Absolute path to `${outDir}/server` */
     outDirServer: string;
 };
-declare function getOutDirs(configGlobal: ResolvedConfig, viteEnv?: Environment): OutDirs;
+declare function getOutDirs(configGlobal: ResolvedConfig, viteEnv: ViteEnv | undefined): OutDirs;
 /** Appends `client/` or `server/` to `config.build.outDir` */
-declare function resolveOutDir(config: UserConfig, isSSR?: true): string;
+declare function resolveOutDir(config: UserConfig, isServerSide: boolean): string;

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

@@ -2,27 +2,23 @@ export { getOutDirs };
 export { resolveOutDir };
 import pc from '@brillout/picocolors';
 import { assert, assertPosixPath, assertUsage, createDebugger, pathJoin, toPosixPath } from '../utils.js';
-import { isViteServerBuild } from './isViteServerBuild.js';
+import { isViteServerSide_viteEnvOptional } from './isViteServerSide.js';
 const debug = createDebugger('vike:outDir');
 function getOutDirs(configGlobal, viteEnv) {
-    const configEnv = viteEnv?.config ?? configGlobal;
     debug('getOutDirs()', new Error().stack);
-    const outDir = getOutDirFromViteResolvedConfig(configEnv);
-    if (!isOutDirRoot(outDir))
-        assertOutDirResolved(outDir, configEnv);
-    const outDirs = getOutDirsAll(outDir, configEnv.root);
+    const outDir = getOutDirFromResolvedConfig(configGlobal, viteEnv);
+    assertOutDirResolved(outDir, configGlobal, viteEnv);
+    const outDirs = getOutDirsAll(outDir, configGlobal.root);
+    assertNormalization(outDirs.outDirRoot);
+    assertNormalization(outDirs.outDirClient);
+    assertNormalization(outDirs.outDirServer);
     return outDirs;
 }
 /** Appends `client/` or `server/` to `config.build.outDir` */
-function resolveOutDir(config, isSSR) {
-    debug('resolveOutDir()', new Error().stack);
-    const isServerSide = isViteServerBuild(config) || isSSR;
-    debug('isServerSide', isServerSide);
+function resolveOutDir(config, isServerSide) {
+    debug('resolveOutDir()');
     const outDir = getOutDirFromViteUserConfig(config) || 'dist';
     debug('outDir', outDir);
-    /* outDir may already be resolved when using Telefunc + Vike (because both Telefunc and Vike use this logic)
-    assert(isOutDirRoot(outDir))
-    */
     const { outDirClient, outDirServer } = getOutDirsAll(outDir);
     if (isServerSide) {
         debug('outDirServer', 'outDirServer');
@@ -86,9 +82,9 @@ function getOutDirsAllFromRootNormalized(outDirRoot, root) {
 }
 function assertNormalization(outDirAny) {
     assertPosixPath(outDirAny);
-    assert(outDirIsAbsolutePath(outDirAny));
-    assert(outDirAny.endsWith('/'));
-    assert(!outDirAny.endsWith('//'));
+    assert(outDirIsAbsolutePath(outDirAny), outDirAny);
+    assert(outDirAny.endsWith('/'), outDirAny);
+    assert(!outDirAny.endsWith('//'), outDirAny);
 }
 function isOutDirRoot(outDirRot) {
     const p = outDirRot.split('/').filter(Boolean);
@@ -98,14 +94,17 @@ function isOutDirRoot(outDirRot) {
 function assertIsNotOutDirRoot(outDir) {
     assert(outDir.endsWith('/client') || outDir.endsWith('/server'));
 }
-/** Assert that `outDir` ends with `/server` or `/client` */
-function assertOutDirResolved(outDir, config) {
+/** Assert that `outDir` ends with the correct directory `/server` or `/client` */
+function assertOutDirResolved(outDir, configGlobal, viteEnv) {
     assertPosixPath(outDir);
-    assertIsNotOutDirRoot(outDir);
+    if (isOutDirRoot(outDir))
+        return;
+    assert(outDir.endsWith('/client') || outDir.endsWith('/server')); // we normalized outDir
     assert('/client'.length === '/server'.length);
     const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
     const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
-    if (isViteServerBuild(config)) {
+    const isServerSide = isViteServerSide_viteEnvOptional(configGlobal, viteEnv);
+    if (isServerSide) {
         assertUsage(outDir.endsWith('/server'), wrongUsage);
     }
     else {
@@ -119,8 +118,8 @@ function getOutDirFromViteUserConfig(config) {
     outDir = normalizeOutDir(outDir);
     return outDir;
 }
-function getOutDirFromViteResolvedConfig(config) {
-    let outDir = config.build.outDir;
+function getOutDirFromResolvedConfig(config, viteEnv) {
+    let outDir = viteEnv?.config.build?.outDir ?? config.build.outDir;
     assert(outDir);
     outDir = normalizeOutDir(outDir);
     return outDir;

package/dist/esm/node/vite/shared/getViteConfigRuntime.js

@@ -3,7 +3,7 @@ import { assert, assertFilePathAbsoluteFilesystem, hasProp } from '../utils.js';
 import { getOutDirs } from './getOutDirs.js';
 function getViteConfigRuntime(config) {
     assert(hasProp(config, '_baseViteOriginal', 'string'));
-    const { outDirRoot } = getOutDirs(config);
+    const { outDirRoot } = getOutDirs(config, undefined);
     assertFilePathAbsoluteFilesystem(outDirRoot);
     const viteConfigRuntime = {
         root: config.root,

package/dist/esm/node/vite/shared/isViteServerSide.d.ts

@@ -0,0 +1,18 @@
+export { isViteServerSide };
+export { isViteClientSide };
+export { isViteServerSide_viteEnvOptional };
+export { isViteServerSide_onlySsrEnv };
+export { isViteServerSide_extraSafe };
+export type { ViteEnv };
+import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig } from 'vite';
+type ViteEnv = {
+    name?: string;
+    config: EnvironmentOptions | Environment['config'];
+};
+declare function isViteServerSide(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerSide_viteEnvOptional(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv | undefined): boolean;
+declare function isViteClientSide(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerSide_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerSide_extraSafe(config: ResolvedConfig, viteEnv: ViteEnv, options: {
+    ssr?: boolean;
+} | undefined): boolean;

package/dist/esm/node/vite/shared/isViteServerSide.js

@@ -0,0 +1,66 @@
+export { isViteServerSide };
+export { isViteClientSide };
+export { isViteServerSide_viteEnvOptional };
+export { isViteServerSide_onlySsrEnv };
+export { isViteServerSide_extraSafe };
+import { assert } from '../../../utils/assert.js';
+function isViteServerSide_impl(configGlobal, viteEnv) {
+    assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
+    const debug = {
+        viteEnvIsUndefined: !viteEnv,
+        viteEnvName: viteEnv?.name ?? null,
+        viteEnvConsumer: viteEnv?.config.consumer ?? null,
+        configEnvBuildSsr: viteEnv?.config.build?.ssr ?? null,
+        configGlobalBuildSsr: configGlobal.build?.ssr ?? null,
+    };
+    if (!viteEnv) {
+        const isServerSide = getBuildSsrValue(configGlobal.build?.ssr);
+        assert(typeof isServerSide === 'boolean', debug);
+        return isServerSide;
+    }
+    else {
+        const isServerSide1 = !viteEnv.config.consumer ? null : viteEnv.config.consumer !== 'client';
+        const isServerSide2 = getBuildSsrValue(viteEnv.config.build?.ssr);
+        const isServerSide3 = viteEnv.name === 'ssr' ? true : viteEnv.name === 'client' ? false : null;
+        const isServerSide = isServerSide1 ?? isServerSide2;
+        assert(isServerSide === isServerSide1 || isServerSide1 === null, debug);
+        assert(isServerSide === isServerSide2 || isServerSide2 === null, debug);
+        assert(isServerSide === isServerSide3 || isServerSide3 === null, debug);
+        assert(isServerSide !== null);
+        return isServerSide;
+    }
+}
+function getBuildSsrValue(buildSsr) {
+    if (buildSsr === undefined)
+        return null;
+    assert(typeof buildSsr === 'boolean' || typeof buildSsr === 'string');
+    return !!buildSsr;
+}
+function isViteServerSide(configGlobal, viteEnv) {
+    return isViteServerSide_impl(configGlobal, viteEnv);
+}
+function isViteServerSide_viteEnvOptional(configGlobal, viteEnv) {
+    return isViteServerSide_impl(configGlobal, viteEnv);
+}
+function isViteClientSide(configGlobal, viteEnv) {
+    return !isViteServerSide(configGlobal, viteEnv);
+}
+// Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
+function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
+    return viteEnv.name ? viteEnv.name === 'ssr' : isViteServerSide(configGlobal, viteEnv);
+}
+// Vite is quite messy about setting config.build.ssr — for security purposes, we use an extra safe implementation with lots of assertions, which is needed for the .client.js and .server.js guarantee.
+function isViteServerSide_extraSafe(config, viteEnv, options) {
+    const isServerSide = isViteServerSide(config, viteEnv);
+    const debug = {
+        isServerSide,
+        configCommand: config.command,
+        configBuildSsr: getBuildSsrValue(config.build.ssr),
+        optionsIsUndefined: options === undefined,
+        optionsSsr: options?.ssr ?? null,
+    };
+    assert(options, debug);
+    assert(typeof options.ssr === 'boolean', debug);
+    assert(options.ssr === isServerSide, debug);
+    return isServerSide;
+}

package/dist/esm/node/vite/shared/loggerVite/removeSuperfluousViteLog.js

@@ -1,11 +1,13 @@
 export { removeSuperfluousViteLog };
 export { removeSuperfluousViteLog_enable };
 export { removeSuperfluousViteLog_disable };
-import { assert } from '../../utils.js';
+import { assert, getGlobalObject } from '../../utils.js';
+const globalObject = getGlobalObject('removeSuperfluousViteLog.ts', {
+    enabled: false,
+});
 const superfluousLog = 'Forced re-optimization of dependencies';
-let enabled = false;
 function removeSuperfluousViteLog(msg) {
-    if (!enabled) {
+    if (!globalObject.enabled) {
         return false;
     }
     if (msg.toLowerCase().includes('forced') && msg.toLowerCase().includes('optimization')) {
@@ -15,8 +17,8 @@ function removeSuperfluousViteLog(msg) {
     return false;
 }
 function removeSuperfluousViteLog_enable() {
-    enabled = true;
+    globalObject.enabled = true;
 }
 function removeSuperfluousViteLog_disable() {
-    enabled = false;
+    globalObject.enabled = false;
 }

package/dist/esm/node/vite/shared/loggerVite.js

@@ -31,7 +31,7 @@ function intercept(logType, config) {
             // We swallow Vite's message: we didn't see it add any value so far.
             //  - It can even be confusing, such as the following:
             //    ```
-            //    Error when evaluating SSR module virtual:vike:pageConfigLazy:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
+            //    Error when evaluating SSR module virtual:vike:page-entry:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
             //    ```
             assert(!isErrorDebug());
             return;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.d.ts

@@ -4,9 +4,10 @@ export type { ConfigDefinitions };
 export type { ConfigDefinitionsInternal };
 export type { ConfigDefinitionInternal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath, PageConfigBuildTime } from '../../../../types/PageConfig.js';
+import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath } from '../../../../types/PageConfig.js';
 import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../types/Config.js';
 import { type ConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
+import type { PageConfigBuildTimeBeforeComputed } from '../resolveVikeConfigInternal.js';
 /** The meta definition of a config.
  *
  * https://vike.dev/meta
@@ -75,7 +76,7 @@ type ConfigEffect = (config: {
 }) => Config | undefined;
 /** For Vike internal use */
 type ConfigDefinitionInternal = Omit<ConfigDefinition_, 'env'> & {
-    _computed?: (pageConfig: Omit<PageConfigBuildTime, 'configValuesComputed'>) => unknown;
+    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
     _valueIsFilePath?: true;
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     env: ConfigEnvInternal;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -1,7 +1,7 @@
 export { configDefinitionsBuiltIn };
 import { assert, assertUsage } from '../../utils.js';
 import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
-import { getConfigValueSourcesRelevant } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+import { getConfigValueSourceRelevantAnyEnv, getConfigValueSourcesRelevant, isConfigSourceValueNull, } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -108,7 +108,9 @@ const configDefinitionsBuiltIn = {
             }, pageConfig))
                 .flat(1)
                 // Server-only
-                .filter((source) => !source.configEnv.client);
+                .filter((source) => !source.configEnv.client)
+                // Config value isn't `null`
+                .filter((source) => !isConfigSourceValueNull(source));
             return sources.length > 0;
         },
     },
@@ -120,22 +122,19 @@ const configDefinitionsBuiltIn = {
         env: { server: true, client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const { configValueSources } = pageConfig;
             {
-                const source = getConfigValueSource(configValueSources, 'clientHooks');
+                const source = getConfigValueSourceRelevantAnyEnv('clientHooks', pageConfig);
                 if (source) {
                     assert(source.valueIsLoaded);
-                    if (source.value !== null) {
-                        const { value } = source;
-                        const definedAt = getConfigDefinedAt('Config', 'clientHooks', source.definedAt);
-                        assertUsage(typeof value === 'boolean', `${definedAt} should be a boolean`);
-                        return value;
-                    }
+                    const { value, definedAt } = source;
+                    const configDefinedAt = getConfigDefinedAt('Config', 'clientHooks', definedAt);
+                    assertUsage(typeof value === 'boolean', `${configDefinedAt} should be a boolean`);
+                    return value;
                 }
             }
-            return (isConfigSet(configValueSources, 'onRenderClient') &&
-                isConfigSet(configValueSources, 'Page') &&
-                !!getConfigEnv(configValueSources, 'Page')?.client);
+            return (isConfigSet(pageConfig, 'onRenderClient') &&
+                isConfigSet(pageConfig, 'Page') &&
+                !!getConfigEnv(pageConfig, 'Page')?.client);
         },
     },
     // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
@@ -143,10 +142,7 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const { configValueSources } = pageConfig;
-            return !isConfigSet(configValueSources, 'onBeforeRender')
-                ? null
-                : getConfigEnv(configValueSources, 'onBeforeRender');
+            return !isConfigSet(pageConfig, 'onBeforeRender') ? null : getConfigEnv(pageConfig, 'onBeforeRender');
         },
     },
     // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
@@ -154,8 +150,7 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const { configValueSources } = pageConfig;
-            return !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data');
+            return !isConfigSet(pageConfig, 'data') ? null : getConfigEnv(pageConfig, 'data');
         },
     },
     hooksTimeout: {
@@ -243,11 +238,11 @@ const configDefinitionsBuiltIn = {
         cumulative: true,
     },
 };
-function getConfigEnv(configValueSources, configName) {
-    const configValueSource = getConfigValueSource(configValueSources, configName);
-    if (!configValueSource)
+function getConfigEnv(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    if (!source)
         return null;
-    const { configEnv } = configValueSource;
+    const { configEnv } = source;
     const env = {};
     if (configEnv.client)
         env.client = true;
@@ -255,18 +250,7 @@ function getConfigEnv(configValueSources, configName) {
         env.server = true;
     return env;
 }
-function isConfigSet(configValueSources, configName) {
-    const source = getConfigValueSource(configValueSources, configName);
-    return (!!source &&
-        !(source.valueIsLoaded &&
-            // Enable users to suppress inherited config by overriding it with `null`
-            source.value === null));
-}
-function getConfigValueSource(configValueSources, configName) {
-    const sources = configValueSources[configName];
-    if (!sources)
-        return null;
-    const configValueSource = sources[0];
-    assert(configValueSource);
-    return configValueSource;
+function isConfigSet(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    return !!source;
 }

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/crawlPlusFiles.js

@@ -1,7 +1,7 @@
 export { crawlPlusFiles };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
-import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, } from '../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, getGlobalObject, } from '../../utils.js';
 import path from 'node:path';
 import { glob } from 'tinyglobby';
 import { exec } from 'node:child_process';
@@ -14,8 +14,9 @@ import { ignorePatternsBuiltIn } from './crawlPlusFiles/ignorePatternsBuiltIn.js
 const execA = promisify(exec);
 const debug = createDebugger('vike:crawl');
 assertIsNotProductionRuntime();
-assertIsSingleModuleInstance('getVikeConfig/crawlPlusFiles.ts');
-let gitIsNotUsable = false;
+const globalObject = getGlobalObject('getVikeConfig/crawlPlusFiles.ts', {
+    gitIsNotUsable: false,
+});
 async function crawlPlusFiles(userRootDir) {
     assertPosixPath(userRootDir);
     assertFilePathAbsoluteFilesystem(userRootDir);
@@ -48,7 +49,7 @@ async function crawlPlusFiles(userRootDir) {
 }
 // Same as tinyglobby() but using `$ git ls-files`
 async function gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers) {
-    if (gitIsNotUsable)
+    if (globalObject.gitIsNotUsable)
         return null;
     // Preserve UTF-8 file paths.
     // https://github.com/vikejs/vike/issues/1658
@@ -82,7 +83,7 @@ async function gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers) {
     }
     catch (err) {
         if (await isGitNotUsable(userRootDir)) {
-            gitIsNotUsable = true;
+            globalObject.gitIsNotUsable = true;
             return null;
         }
         throw err;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -8,11 +8,12 @@ export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 export type { VikeConfigInternal };
+export type { PageConfigBuildTimeBeforeComputed };
 export { getVikeConfig };
 export type { VikeConfig };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../types/PageConfig.js';
 import { type ConfigDefinitionsInternal, type ConfigDefinitionInternal } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
-import { type VikeConfigPublicGlobal, type VikeConfigPublicPageEager } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { type VikeConfigPublicGlobal, type VikeConfigPublicPageEagerLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { type PlusFile } from './resolveVikeConfigInternal/getPlusFilesAll.js';
 import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
 import type { ResolvedConfig, UserConfig } from 'vite';
@@ -33,7 +34,7 @@ type VikeConfigInternal = {
     config: VikeConfigPublicGlobal['config'];
     _from: VikeConfigPublicGlobal['_from'];
     pages: Record<string, // pageId
-    VikeConfigPublicPageEager>;
+    VikeConfigPublicPageEagerLoaded>;
     _vikeConfigDependencies: Set<string>;
     prerenderContext: PrerenderContext;
 };
@@ -57,6 +58,7 @@ declare function getVikeConfigFromCliOrEnv(): {
     configFromCliOptions: import("../../cli/parseCli.js").CliOptions | null;
     configFromEnvVar: Record<string, unknown> | null;
 };
+type PageConfigBuildTimeBeforeComputed = Omit<PageConfigBuildTime, 'configValuesComputed'>;
 declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitionsInternal, configName: string): ConfigDefinitionInternal | null;
 declare function getConfVal(plusFile: PlusFile, configName: string): null | {
     value: unknown;