vike 0.4.223 → 0.4.224

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

@@ -6,7 +6,7 @@ import { extractAssetsAddQuery } from '../../../../../shared/extractAssetsQuery.
 import { debug } from './debug.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../../../shared/page-configs/serialize/serializeConfigValues.js';
-import { fixServerAssets_isEnabled } from '../../../buildConfig/fixServerAssets.js';
+import { handleAssetsManifest_isFixEnabled } from '../../../build/handleAssetsManifest.js';
 import { getConfigValueBuildTime } from '../../../../../../shared/page-configs/getConfigValueBuildTime.js';
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
@@ -24,11 +24,11 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     assert(pageConfig, { id, pageId });
     const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, 
     // TODO/now: add meta.default
-    vikeConfig.global.config.includeAssetsImportedByServer ?? true, isDev);
+    vikeConfig.global.config.includeAssetsImportedByServer ?? true, config, isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
-function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
+function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, config, isDev) {
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
@@ -36,7 +36,7 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     lines.push('export const configValuesSerialized = {');
     lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '', false));
     lines.push('};');
-    if (!fixServerAssets_isEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
+    if (!handleAssetsManifest_isFixEnabled(config) && includeAssetsImportedByServer && isForClientSide && !isDev) {
         importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');

package/dist/esm/node/plugin/shared/findPageFiles.js

@@ -1,5 +1,5 @@
 export { findPageFiles };
-import glob from 'fast-glob';
+import { glob } from 'tinyglobby';
 import { assertWarning, toPosixPath, scriptFileExtensions } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { getOutDirs } from './getOutDirs.js';
@@ -7,11 +7,11 @@ async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
     const { outDirRoot } = getOutDirs(config);
     const timeBase = new Date().getTime();
-    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false });
+    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false, expandDirectories: false });
     pageFiles = pageFiles.map((p) => '/' + toPosixPath(p));
     const time = new Date().getTime() - timeBase;
     if (isDev) {
-        // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
+        // We only warn in dev, because while building it's expected to take a long time as tinyglobby is competing for resources with other tasks
         assertWarning(time < 1.5 * 1000, `Finding your page files ${pc.cyan('**/*.page.*')} took an unexpected long time (${time}ms). Reach out to the vike maintainer.`, {
             onlyOnce: 'slow-page-files-search'
         });

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

@@ -1,9 +1,7 @@
 // Purpose of this file:
 //  - Swallow redundant error messages (Vite is buggy and emits the same error multiple times)
 //  - Prepend "[request(n)]" tag to Vite logs
-// The mechanism is skipped if the runtime doesn't support Async Hooks:
-//  - Bun doesn't support Async Hooks: https://github.com/oven-sh/bun/issues/1832
-//  - Node.js and Deno support Async Hooks
+// The mechanism is skipped if the development environment doesn't support Async Hooks.
 // We purposely don't use config.logger.hasErrorLogged(err) because:
 // - We don't trust Vite with such details
 //   - Example of Vite bug leading to swallowing of errors: https://github.com/vitejs/vite/issues/12631

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

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

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

@@ -2,20 +2,21 @@ export { getOutDirs };
 export { resolveOutDir };
 import pc from '@brillout/picocolors';
 import { assert, assertPosixPath, assertUsage, createDebugger, pathJoin, toPosixPath } from '../utils.js';
-import { viteIsSSR } from './viteIsSSR.js';
+import { isViteServerBuild } from './isViteServerBuild.js';
 const debug = createDebugger('vike:outDir');
-function getOutDirs(config) {
+function getOutDirs(configGlobal, viteEnv) {
+    const configEnv = viteEnv?.config ?? configGlobal;
     debug('getOutDirs()', new Error().stack);
-    const outDir = getOutDirFromViteResolvedConfig(config);
+    const outDir = getOutDirFromViteResolvedConfig(configEnv);
     if (!isOutDirRoot(outDir))
-        assertOutDirResolved(outDir, config);
-    const outDirs = getOutDirsAll(outDir, config.root);
+        assertOutDirResolved(outDir, configEnv);
+    const outDirs = getOutDirsAll(outDir, configEnv.root);
     return outDirs;
 }
 /** Appends `client/` or `server/` to `config.build.outDir` */
 function resolveOutDir(config, isSSR) {
     debug('resolveOutDir()', new Error().stack);
-    const isServerSide = viteIsSSR(config) || isSSR;
+    const isServerSide = isViteServerBuild(config) || isSSR;
     debug('isServerSide', isServerSide);
     const outDir = getOutDirFromViteUserConfig(config) || 'dist';
     debug('outDir', outDir);
@@ -104,7 +105,7 @@ function assertOutDirResolved(outDir, config) {
     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 (viteIsSSR(config)) {
+    if (isViteServerBuild(config)) {
         assertUsage(outDir.endsWith('/server'), wrongUsage);
     }
     else {

package/dist/esm/node/plugin/shared/isViteServerBuild.d.ts

@@ -0,0 +1,15 @@
+export { isViteServerBuild };
+export { isViteClientBuild };
+export { isViteServerBuild_options };
+export { isViteServerBuild_safe };
+export { isViteServerBuild_onlySsrEnv };
+import type { Environment, ResolvedConfig, UserConfig } from 'vite';
+declare function isViteServerBuild(configGlobal: ResolvedConfig | UserConfig, viteEnv?: Environment): boolean;
+declare function isViteServerBuild_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: Environment | undefined): boolean;
+declare function isViteClientBuild(configGlobal: ResolvedConfig, viteEnv: Environment): boolean;
+declare function isViteServerBuild_options(options: {
+    ssr?: boolean;
+} | undefined): boolean;
+declare function isViteServerBuild_safe(config: ResolvedConfig, options: {
+    ssr?: boolean;
+} | undefined): boolean;

package/dist/esm/node/plugin/shared/isViteServerBuild.js

@@ -0,0 +1,45 @@
+export { isViteServerBuild };
+export { isViteClientBuild };
+export { isViteServerBuild_options };
+export { isViteServerBuild_safe };
+export { isViteServerBuild_onlySsrEnv };
+import { assert } from '../../../utils/assert.js';
+function isViteServerBuild(configGlobal, viteEnv) {
+    const configEnv = viteEnv?.config ?? configGlobal;
+    return !!configEnv?.build?.ssr;
+}
+// Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
+function isViteServerBuild_onlySsrEnv(configGlobal, viteEnv) {
+    return viteEnv ? viteEnv.name === 'ssr' : isViteServerBuild(configGlobal);
+}
+function isViteClientBuild(configGlobal, viteEnv) {
+    const yes = !isViteServerBuild(configGlobal, viteEnv);
+    const isVite5 = viteEnv === undefined;
+    if (!isVite5) {
+        const yes2 = viteEnv.name === 'client';
+        assert(yes === yes2);
+    }
+    return yes;
+}
+function isViteServerBuild_options(options) {
+    return !!options?.ssr;
+}
+// Vite is quite messy about setting `ssr: boolean`, thus we use an extra safe implemention for security purposes.
+// It's used for .client.js and .server.js guarantee thus we use agressive assert() calls for added safety.
+function isViteServerBuild_safe(config, options) {
+    if (config.command === 'build') {
+        assert(typeof config.build.ssr === 'boolean');
+        const val = config.build.ssr;
+        if (options?.ssr !== undefined)
+            assert(val === options.ssr);
+        return val;
+    }
+    else {
+        assert(typeof options?.ssr === 'boolean');
+        const val = options.ssr;
+        /* This assert() fails (which is very unexpected).
+        if (typeof config.build.ssr === 'boolean') assert(val === config.build.ssr)
+        //*/
+        return val;
+    }
+}

package/dist/esm/node/plugin/shared/resolveClientEntriesDev.js

@@ -1,7 +1,7 @@
 export { resolveClientEntriesDev };
 import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsNpmPackageImport, assertIsNotProductionRuntime } from '../utils.js';
 import { createRequire } from 'module';
-// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 assertIsNotProductionRuntime();

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

@@ -22,3 +22,4 @@ export * from '../../utils/isArray.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/isEqualStringList.js';
 export * from '../../utils/isDocker.js';
+export * from '../../utils/isVitest.js';

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

@@ -28,3 +28,4 @@ export * from '../../utils/isArray.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/isEqualStringList.js';
 export * from '../../utils/isDocker.js';
+export * from '../../utils/isVitest.js';

package/dist/esm/node/prerender/context.d.ts

@@ -1,10 +1,8 @@
-export { isPrerenderEnabled };
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
 export { isPrerendering };
 export { setContextIsPrerendering };
 import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-declare function isPrerenderEnabled(vikeConfig: VikeConfigObject): boolean;
 declare function isPrerenderAutoRunEnabled(vikeConfig: VikeConfigObject): boolean;
 declare function temp_disablePrerenderAutoRun(): void;
 declare function isPrerendering(): boolean;

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

@@ -1,19 +1,14 @@
-export { isPrerenderEnabled };
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
 export { isPrerendering };
 export { setContextIsPrerendering };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
-import { resolvePrerenderConfig } from './resolvePrerenderConfig.js';
+import { resolvePrerenderConfigGlobal } from './resolvePrerenderConfig.js';
 const globalObject = getGlobalObject('prerender/context.ts', {});
-function isPrerenderEnabled(vikeConfig) {
-    const prerenderConfig = resolvePrerenderConfig(vikeConfig);
-    return !!prerenderConfig;
-}
 function isPrerenderAutoRunEnabled(vikeConfig) {
-    const prerenderConfig = resolvePrerenderConfig(vikeConfig);
-    return (isPrerenderEnabled(vikeConfig) &&
-        !(prerenderConfig || {}).disableAutoRun &&
+    const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
+    return (prerenderConfigGlobal.isEnabled &&
+        !(prerenderConfigGlobal || {}).disableAutoRun &&
         !globalObject.isDisabled &&
         vikeConfig.global.config.disableAutoFullBuild !== 'prerender');
 }

package/dist/esm/node/prerender/resolvePrerenderConfig.d.ts

@@ -1,12 +1,16 @@
-export { resolvePrerenderConfig };
+export { resolvePrerenderConfigGlobal };
 export { resolvePrerenderConfigLocal };
-import type { ConfigResolved } from '../../shared/page-configs/Config/PageContextConfig.js';
 import { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
-type PrerenderConfigSemiResolved = ConfigResolved['prerender'];
-type PrerenderConfig = false | Exclude<Required<NonNullable<PrerenderConfigSemiResolved>[number]>, boolean>;
-declare function resolvePrerenderConfig(vikeConfig: VikeConfigObject): PrerenderConfig;
+declare function resolvePrerenderConfigGlobal(vikeConfig: VikeConfigObject): {
+    partial: boolean;
+    noExtraDir: boolean;
+    parallel: number | boolean;
+    disableAutoRun: boolean;
+} & {
+    defaultLocalValue: boolean;
+    isEnabled: boolean;
+};
 declare function resolvePrerenderConfigLocal(pageConfig: PageConfigBuildTime): {
     value: boolean;
-    configValueFilePathToShowToUser: string;
 } | null;

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

@@ -1,27 +1,30 @@
-export { resolvePrerenderConfig };
+export { resolvePrerenderConfigGlobal };
 export { resolvePrerenderConfigLocal };
-import { assert, isArray } from './utils.js';
+import { assert, isArray, objectAssign } from './utils.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
-import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
-// TODO/now:
-// - prerender.value
-function resolvePrerenderConfig(vikeConfig) {
+function resolvePrerenderConfigGlobal(vikeConfig) {
     const prerenderConfigs = vikeConfig.global.config.prerender;
-    if (!prerenderConfigs &&
-        !vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value)) {
-        return false;
-    }
-    let prerenderSettings = prerenderConfigs || [];
+    let prerenderConfigList = prerenderConfigs || [];
     // Needed because of backwards compatibility of `vike({prerender:true})` in `vite.config.js`; after we remove it we can remove this line.
-    prerenderSettings = prerenderSettings.filter(isObject2);
-    assert(prerenderSettings.every(isObject2));
-    const prerenderConfig = {
-        partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
-        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
-        parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
-        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
+    prerenderConfigList = prerenderConfigList.filter(isObject2);
+    assert(prerenderConfigList.every(isObject2)); // Help TS
+    const prerenderConfigGlobal = {
+        partial: pickFirst(prerenderConfigList.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(prerenderConfigList.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(prerenderConfigList.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(prerenderConfigList.map((c) => c.disableAutoRun)) ?? false
     };
-    return prerenderConfig;
+    const prerenderConfigGlobalLocalValue = prerenderConfigList.map((c) => c.value).filter((v) => v !== null);
+    const defaultLocalValue = pickFirst(prerenderConfigGlobalLocalValue) ??
+        (prerenderConfigGlobalLocalValue.length > 0 ||
+            // Backwards compatibility for with vike({ prerender: true }) in vite.config.js
+            prerenderConfigs?.some((p) => p === true) ||
+            false);
+    objectAssign(prerenderConfigGlobal, {
+        defaultLocalValue,
+        isEnabled: defaultLocalValue || vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value)
+    });
+    return prerenderConfigGlobal;
 }
 function resolvePrerenderConfigLocal(pageConfig) {
     const configValue = getConfigValueBuildTime(pageConfig, 'prerender');
@@ -32,9 +35,8 @@ function resolvePrerenderConfigLocal(pageConfig) {
     const value = values[0];
     assert(typeof value === 'boolean');
     assert(isArray(configValue.definedAtData));
-    const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData[0]);
-    assert(configValueFilePathToShowToUser);
-    return { value, configValueFilePathToShowToUser };
+    const prerenderConfigLocal = { value };
+    return prerenderConfigLocal;
 }
 function isObject2(p) {
     return typeof p === 'object' && p !== null;

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -4,46 +4,24 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
 export type { PrerenderContextPublic };
-import { PageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
-import { PageContextUrlInternal } from '../../shared/getPageContextUrlComputed.js';
 import type { APIOptions } from '../api/types.js';
+import type { PageContextServer } from '../../shared/types.js';
 type ProvidedByHook = null | {
     hookFilePath: string;
     hookName: 'onBeforePrerenderStart' | 'prerender';
 };
-type TransformerHook = {
-    hookFilePath: string;
-    hookName: 'onPrerenderStart' | 'onBeforePrerender';
-};
 type PageContextPrerendered = {
     urlOriginal: string;
     _providedByHook?: ProvidedByHook;
 };
-type PrerenderedPageContexts = Record<string, PageContextPrerendered>;
-type PrerenderContext = {
-    pageContexts: PageContext[];
-    pageContextInit: Record<string, unknown> | null;
-    noExtraDir: boolean;
-    prerenderedPageContexts: PrerenderedPageContexts;
-    output: Output;
-};
-type Output = {
+type Output<PageContext = PageContextPrerendered> = {
     filePath: string;
     fileType: FileType;
     fileContent: string;
-    pageContext: PageContextPrerendered;
+    pageContext: PageContext;
 }[];
 type FileType = 'HTML' | 'JSON';
-type PrerenderContextPublic = Pick<PrerenderContext, 'pageContexts'>;
-type PageContext = PageContextInitEnhanced & {
-    _urlRewrite: null;
-    _urlHandler: null;
-    _urlOriginalBeforeHook?: string;
-    _urlOriginalModifiedByHook?: TransformerHook;
-    _providedByHook: ProvidedByHook;
-    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
-} & PageContextUrlInternal;
 type PrerenderOptions = APIOptions & {
     /** Initial `pageContext` values */
     pageContextInit?: Record<string, unknown>;
@@ -72,3 +50,7 @@ declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined, c
     forceExit: boolean;
 }>;
 declare function runPrerender_forceExit(): void;
+type PrerenderContextPublic = {
+    output: Output<PageContextServer>;
+    pageContexts: PageContextServer[];
+};

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

@@ -26,10 +26,11 @@ import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 import { setContextIsPrerendering } from './context.js';
-import { resolvePrerenderConfig, resolvePrerenderConfigLocal } from './resolvePrerenderConfig.js';
+import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal } from './resolvePrerenderConfig.js';
 import { getOutDirs } from '../plugin/shared/getOutDirs.js';
 import { isVikeCli } from '../cli/context.js';
 import { isViteCliCall } from '../plugin/shared/isViteCliCall.js';
+import { getVikeConfigPublic } from '../plugin/plugins/commonConfig.js';
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -56,11 +57,13 @@ async function runPrerenderFromAutoRun(viteConfig, config) {
         prerenderContextPublic = ret.prerenderContextPublic;
     }
     catch (err) {
+        // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
         console.error(err);
         logErrorHint(err);
         process.exit(1);
     }
-    config.vike.prerenderContext = prerenderContextPublic;
+    const vike = getVikeConfigPublic(config);
+    vike.prerenderContext = prerenderContextPublic;
     const forceExit = isVikeCli() || isViteCliCall();
     return { forceExit };
 }
@@ -79,15 +82,16 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const vikeConfig = await getVikeConfig(viteConfig);
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
-    const prerenderConfig = resolvePrerenderConfig(vikeConfig);
-    validatePrerenderConfig(prerenderConfig);
-    if (!prerenderConfig) {
+    const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
+    validatePrerenderConfig(prerenderConfigGlobal);
+    const { partial, noExtraDir, parallel, defaultLocalValue, isEnabled } = prerenderConfigGlobal;
+    if (!isEnabled) {
         assert(standaloneTrigger);
-        assertWarning(prerenderConfig, `You're executing ${pc.cyan(standaloneTrigger)} but the config ${pc.cyan('prerender')} isn't set to true`, {
+        // TODO/now: make it assertUsage() and remove dist/server/entry.mjs whenever possible
+        assertWarning(prerenderConfigGlobal, `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the config ${pc.cyan('prerender')} (${pc.underline('https://vike.dev/prerender')}) to enable it.`, {
             onlyOnce: true
         });
     }
-    const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
     const globalContext = await getGlobalContextInternal();
@@ -100,7 +104,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
         output: []
     };
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit, globalContext);
+    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext);
     await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, globalContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext, globalContext);
@@ -123,20 +127,21 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const prerenderContextPublic = makePublic(prerenderContext);
     return { viteConfig, prerenderContextPublic };
 }
-async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit, globalContext) {
+async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext) {
     // V1 design
     pageConfigs.forEach((pageConfig) => {
-        const configValue = resolvePrerenderConfigLocal(pageConfig);
-        if (!configValue)
-            return;
-        const { value, configValueFilePathToShowToUser } = configValue;
-        if (value === false) {
-            doNotPrerenderList.push({
-                pageId: pageConfig.pageId,
-                setByConfigName: 'prerender',
-                setByConfigValue: false,
-                setByConfigFile: configValueFilePathToShowToUser
-            });
+        const prerenderConfigLocal = resolvePrerenderConfigLocal(pageConfig);
+        const { pageId } = pageConfig;
+        if (!prerenderConfigLocal) {
+            if (!defaultLocalValue) {
+                doNotPrerenderList.push({ pageId });
+            }
+        }
+        else {
+            const { value } = prerenderConfigLocal;
+            if (value === false) {
+                doNotPrerenderList.push({ pageId });
+            }
         }
     });
     // Old design
@@ -169,12 +174,7 @@ async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurr
             }
             else {
                 // Don't pre-render `pageId`
-                doNotPrerenderList.push({
-                    pageId,
-                    setByConfigFile: p.filePath,
-                    setByConfigName: 'doNotPrerender',
-                    setByConfigValue: doNotPrerender
-                });
+                doNotPrerenderList.push({ pageId });
             }
         }
     });
@@ -527,8 +527,7 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
             if (!isContradictory)
                 return;
         }
-        const { setByConfigName, setByConfigValue, setByConfigFile } = doNotPrerenderListEntry;
-        assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
+        assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)} matching the route of the page ${pc.cyan(pageId)} which isn't configured to be pre-rendered. This is contradictory: either enable pre-rendering for ${pc.cyan(pageId)} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
 async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPrerenderList, partial) {
@@ -775,7 +774,8 @@ prerenderConfig) {
 }
 function makePublic(prerenderContext) {
     const prerenderContextPublic = makePublicCopy(prerenderContext, 'prerenderContext', [
-        'pageContexts'
+        'output', // vite-plugin-vercel
+        'pageContexts' // https://vike.dev/i18n#pre-rendering
     ]);
     return prerenderContextPublic;
 }

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

@@ -15,3 +15,4 @@ export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/isNotNullish.js';

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

@@ -17,3 +17,4 @@ export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/isNotNullish.js';

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

@@ -23,7 +23,6 @@ import type { ResolvedConfig, ViteDevServer } from 'vite';
 import type { PageConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 import type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
 import { type BaseUrlsResolved } from '../shared/resolveBase.js';
-type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig' | 'pages' | 'baseAssets' | 'baseServer'>;
 type PageRuntimeInfo = Awaited<ReturnType<typeof getUserFiles>>;
 type GlobalContextInternal = GlobalContext & {
     globalContext_public: GlobalContextPublic;
@@ -57,6 +56,8 @@ declare function getGlobalContextInternal(): Promise<GlobalContextInternal>;
 declare function getGlobalContextSync(): GlobalContextPublic;
 /** @experimental https://vike.dev/getGlobalContext */
 declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
+type GlobalContextPublic = ReturnType<typeof makePublic>;
+declare function makePublic(globalContext: GlobalContext): Pick<GlobalContext, "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig">;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): Promise<void>;
 declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
 declare function setGlobalContext_isPrerendering(): void;

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

@@ -25,13 +25,19 @@ const errorsMisc = [
         mustMentionNodeModules: false
     }
 ];
+const reactInvalidEelement = 'https://vike.dev/broken-npm-package#react-invalid-component';
 const errorsReact = [
     {
         errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
-        link: 'https://vike.dev/broken-npm-package#react-invalid-component',
+        link: reactInvalidEelement,
         // The stack trace can be user-land while the import is coming from node_modules
         mustMentionNodeModules: false
     },
+    {
+        errMsg: 'Objects are not valid as a React child',
+        link: reactInvalidEelement,
+        mustMentionNodeModules: false
+    },
     {
         // React's "Invalid hook call.", see https://github.com/vikejs/vike/discussions/1637#discussioncomment-9424712
         errMsg: "Cannot read properties of null (reading 'useContext')"