vike 0.4.144 → 0.4.145-commit-2520555

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

@@ -1,3 +1,3 @@
 export { getVirtualFilePageConfigValuesAll };
-import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
-declare function getVirtualFilePageConfigValuesAll(id: string, userRootDir: string, outDirRoot: string, isDev: boolean, configVike: ConfigVikeResolved): Promise<string>;
+import type { ResolvedConfig } from 'vite';
+declare function getVirtualFilePageConfigValuesAll(id: string, isDev: boolean, config: ResolvedConfig): Promise<string>;

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

@@ -4,11 +4,12 @@ import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll
 import { getVikeConfig } from './getVikeConfig.js';
 import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
-import { getConfigValue } from '../../../../../shared/page-configs/utils.js';
+import { getConfigValue } from '../../../../../shared/page-configs/helpers.js';
 import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSourcesRelevant.js';
-import { isConfigEnvMatch } from './isConfigEnvMatch.js';
+import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
-async function getVirtualFilePageConfigValuesAll(id, userRootDir, outDirRoot, isDev, configVike) {
+import { getConfigVike } from '../../../../shared/getConfigVike.js';
+async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
     assert(result);
     /* This assertion fails when using includeAssetsImportedByServer
@@ -18,9 +19,10 @@ async function getVirtualFilePageConfigValuesAll(id, userRootDir, outDirRoot, is
     }
     */
     const { pageId, isForClientSide } = result;
-    const { pageConfigs } = await getVikeConfig(userRootDir, outDirRoot, isDev, configVike.extensions, true);
+    const { pageConfigs } = await getVikeConfig(config, isDev, true);
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     assert(pageConfig);
+    const configVike = await getConfigVike(config);
     const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
@@ -38,7 +40,7 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
             return;
         if (configValueSource.valueIsFilePath)
             return;
-        if (!isConfigEnvMatch(configEnv, isForClientSide, isClientRouting))
+        if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: false }))
             return;
         const whitespace = '  ';
         lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));

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

@@ -1,6 +1,6 @@
 export { getVirtualFilePageConfigs };
 export { getConfigValueSerialized };
 import type { DefinedAt } from '../../../../../shared/page-configs/PageConfig.js';
-import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
-declare function getVirtualFilePageConfigs(userRootDir: string, outDirRoot: string, isForClientSide: boolean, isDev: boolean, id: string, configVike: ConfigVikeResolved, isClientRouting: boolean): Promise<string>;
+import type { ResolvedConfig } from 'vite';
+declare function getVirtualFilePageConfigs(isForClientSide: boolean, isDev: boolean, id: string, isClientRouting: boolean, config: ResolvedConfig): Promise<string>;
 declare function getConfigValueSerialized(value: unknown, configName: string, definedAt: DefinedAt): string;

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

@@ -1,23 +1,31 @@
 export { getVirtualFilePageConfigs };
 export { getConfigValueSerialized };
-import { assert, assertUsage, getPropAccessNotation, hasProp, objectEntries } from '../../../utils.js';
+import { assert, assertUsage, getPropAccessNotation, objectEntries } from '../../../utils.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { debug } from './debug.js';
-import { stringify } from '@brillout/json-serializer/stringify';
+import { isJsonSerializerError, stringify } from '@brillout/json-serializer/stringify';
 import { getConfigEnv } from './helpers.js';
 import pc from '@brillout/picocolors';
 import { getVikeConfig } from './getVikeConfig.js';
-import { isConfigEnvMatch } from './isConfigEnvMatch.js';
-import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/utils.js';
+import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
+import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
 import { serializeConfigValue, serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
-async function getVirtualFilePageConfigs(userRootDir, outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting) {
-    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, outDirRoot, isDev, configVike.extensions, true);
-    return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
+async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
+    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, isDev, true);
+    return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
-function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
+function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
     const lines = [];
     const importStatements = [];
     const varCounterContainer = { varCounter: 0 };
+    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements, varCounterContainer));
+    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements, varCounterContainer));
+    const code = [...importStatements, ...lines].join('\n');
+    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    return code;
+}
+function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements, varCounterContainer) {
+    const lines = [];
     lines.push('export const pageConfigsSerialized = [');
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
@@ -30,7 +38,7 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
         lines.push(`    configValuesSerialized: {`);
         Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
             const { value, configEnv } = configValuesComputed;
-            if (!isConfigEnvMatch(configEnv, isForClientSide, isClientRouting))
+            if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true }))
                 return;
             if (pageConfig.configValueSources[configName])
                 return;
@@ -45,7 +53,8 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
             if (configValue) {
                 const configEnv = getConfigEnv(pageConfig.configValueSources, configName);
                 assert(configEnv, configName);
-                if (!isConfigEnvMatch(configEnv, isForClientSide, isClientRouting))
+                const isEnvMatch = isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true });
+                if (!isEnvMatch)
                     return;
                 const { value, definedAt } = configValue;
                 const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
@@ -70,6 +79,11 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
         lines.push(`  },`);
     });
     lines.push('];');
+    const code = lines.join('\n');
+    return code;
+}
+function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements, varCounterContainer) {
+    const lines = [];
     lines.push('export const pageConfigGlobalSerialized = {');
     /* Nothing (yet)
     lines.push(`  configValuesSerialized: {`)
@@ -96,23 +110,31 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
     });
     lines.push(`  ],`);
     lines.push('};');
-    const code = [...importStatements, ...lines].join('\n');
-    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    const code = lines.join('\n');
     return code;
 }
 function getConfigValueSerialized(value, configName, definedAt) {
     const valueName = `config${getPropAccessNotation(configName)}`;
     let configValueSerialized;
     try {
-        configValueSerialized = stringify(value, { valueName });
+        configValueSerialized = stringify(value, { valueName, forbidReactElements: true });
     }
     catch (err) {
-        assert(hasProp(err, 'messageCore', 'string'));
+        let serializationErrMsg = '';
+        if (isJsonSerializerError(err)) {
+            serializationErrMsg = err.messageCore;
+        }
+        else {
+            // When a property getter throws an error
+            console.error('Serialization error:');
+            console.error(err);
+            serializationErrMsg = 'see serialization error printed above';
+        }
         const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
         assert(configValueFilePathToShowToUser);
         assertUsage(false, [
             `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
-            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because the value isn't serializable: ${err.messageCore}.)`,
+            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
             `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
         ].join(' '));
     }

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

@@ -6,20 +6,7 @@ function getConfigEnv(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);
     if (!configValueSource)
         return null;
-    if (configValueSource) {
-        return configValueSource.configEnv;
-    }
-    else {
-        // In case of effect/computed config values, there isn't any configValueSource
-        // TODO: make it work for custom config definitions
-        //  - Ideally set configValueSource also for effect/computed config values?
-        assert(false, 'TODO');
-        /*
-        const configDef = configDefinitionsBuiltIn[configName as keyof typeof configDefinitionsBuiltIn]
-        if (!configDef) return null
-        return configDef.env
-        */
-    }
+    return configValueSource.configEnv;
 }
 function isConfigSet(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);

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

@@ -0,0 +1,7 @@
+export { isRuntimeEnvMatch };
+import type { ConfigEnvInternal } from '../../../../../shared/page-configs/PageConfig.js';
+declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtime: {
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+    isEager: boolean;
+}): boolean;

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

@@ -0,0 +1,15 @@
+export { isRuntimeEnvMatch };
+function isRuntimeEnvMatch(configEnv, runtime) {
+    const { isForClientSide, isClientRouting, isEager } = runtime;
+    if (configEnv === 'config-only')
+        return false;
+    if (configEnv === (isForClientSide ? 'server-only' : 'client-only'))
+        return false;
+    if (configEnv === '_routing-eager' || configEnv === '_routing-lazy') {
+        if (isForClientSide && !isClientRouting)
+            return false;
+        if (isEager !== (configEnv === '_routing-eager'))
+            return false;
+    }
+    return true;
+}

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

@@ -3,8 +3,8 @@ export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg as getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import 'source-map-support/register.js';
-import { type FilePath } from './getFilePathToShowToUser.js';
-declare function transpileAndExecuteFile(filePath: FilePath, isValueFile: boolean, userRootDir: string): Promise<{
+import type { FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
+declare function transpileAndExecuteFile(filePath: FilePathResolved, isValueFile: boolean, userRootDir: string): Promise<{
     fileExports: Record<string, unknown>;
 }>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;

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

@@ -7,11 +7,10 @@ import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, unique, assertWarning, isObject, toPosixPath, assertUsage } from '../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, unique, assertWarning, isObject, toPosixPath } from '../../../utils.js';
 import { isImportData, replaceImportStatements } from './replaceImportStatements.js';
 import { vikeConfigDependencies } from './getVikeConfig.js';
 import 'source-map-support/register.js';
-import { getFilePathToShowToUser } from './getFilePathToShowToUser.js';
 import { assertExportsOfConfigFile } from '../../../../../shared/page-configs/assertExports.js';
 assertIsNotProductionRuntime();
 async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
@@ -20,9 +19,9 @@ async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
     return { fileExports };
 }
 async function transpileFile(filePath, isValueFile, userRootDir) {
-    const { filePathAbsolute } = filePath;
-    assertPosixPath(filePathAbsolute);
-    vikeConfigDependencies.add(filePathAbsolute);
+    const { filePathAbsoluteFilesystem } = filePath;
+    assertPosixPath(filePathAbsoluteFilesystem);
+    vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     let code = await transpileWithEsbuild(filePath, isValueFile, userRootDir);
     let fileImports = null;
     {
@@ -36,14 +35,13 @@ async function transpileFile(filePath, isValueFile, userRootDir) {
 }
 function transpileImports(codeOriginal, filePath, isValueFile) {
     // Do we need to remove the imports?
-    const { filePathAbsolute } = filePath;
-    assertPosixPath(filePathAbsolute);
-    const isHeader = isHeaderFile(filePathAbsolute);
+    const { filePathAbsoluteFilesystem, filePathToShowToUser } = filePath;
+    assertPosixPath(filePathAbsoluteFilesystem);
+    const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     const isPageConfigFile = !isValueFile;
     if (!isHeader && !isPageConfigFile) {
         return null;
     }
-    const filePathToShowToUser = getFilePathToShowToUser(filePath);
     assertWarning(isPageConfigFile, `${filePathToShowToUser} is a JavaScript header file (.h.js), but JavaScript header files should only be used for +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
     // Remove the imports
     const res = replaceImportStatements(codeOriginal, filePathToShowToUser);
@@ -60,7 +58,7 @@ function transpileImports(codeOriginal, filePath, isValueFile) {
     return { code, fileImports };
 }
 async function transpileWithEsbuild(filePath, bundle, userRootDir) {
-    const entryFilePath = filePath.filePathAbsolute;
+    const entryFilePath = filePath.filePathAbsoluteFilesystem;
     const entryFileDir = path.posix.dirname(entryFilePath);
     const options = {
         platform: 'node',
@@ -125,8 +123,8 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
         Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
             filePathRelative = toPosixPath(filePathRelative);
             assertPosixPath(userRootDir);
-            const filePathAbsolute = path.posix.join(userRootDir, filePathRelative);
-            vikeConfigDependencies.add(filePathAbsolute);
+            const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
+            vikeConfigDependencies.add(filePathAbsoluteFilesystem);
         });
     }
     const code = result.outputFiles[0].text;
@@ -134,10 +132,10 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
     return code;
 }
 async function executeFile(filePath, code, fileImports, isValueFile) {
-    const { filePathAbsolute, filePathRelativeToUserRootDir } = filePath;
+    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
-    const filePathTmp = getFilePathTmp(filePathAbsolute);
+    const filePathTmp = getFilePathTmp(filePathAbsoluteFilesystem);
     fs.writeFileSync(filePathTmp, code);
     const clean = () => fs.unlinkSync(filePathTmp);
     let fileExports = {};
@@ -160,7 +158,7 @@ async function executeFile(filePath, code, fileImports, isValueFile) {
     fileExports = { ...fileExports };
     if (fileImports && !isValueFile) {
         assert(filePathRelativeToUserRootDir !== undefined);
-        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsolute;
+        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsoluteFilesystem;
         assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser);
     }
     return { fileExports };
@@ -228,11 +226,11 @@ function assertImportsAreReExported(fileImports, fileExports, filePathToShowToUs
     const importStatements = unique(fileImportsUnused.map((fi) => fi.importStatementCode));
     const importNamesUnused = fileImportsUnused.map((fi) => pc.cyan(fi.importLocalName)).join(', ');
     const singular = fileImportsUnused.length === 1;
-    assertUsage(fileImportsUnused.length === 0, [
+    assertWarning(fileImportsUnused.length === 0, [
         `${filePathToShowToUser} imports the following:`,
         ...importStatements.map((s) => pc.cyan(`  ${s}`)),
         `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${pc.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
-    ].join('\n'));
+    ].join('\n'), { onlyOnce: true });
 }
 function getExportedStrings(obj) {
     const exportedStrings = [];
@@ -273,7 +271,7 @@ function triggerPrepareStackTrace(err) {
 function getErrIntroMsg(operation, filePath) {
     const msg = [
         pc.red(`Failed to ${operation}`),
-        pc.bold(pc.red(getFilePathToShowToUser(filePath))),
+        pc.bold(pc.red(filePath.filePathToShowToUser)),
         pc.red(`because:`)
     ].join(' ');
     return msg;

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

@@ -13,6 +13,7 @@ function previewConfig() {
         apply: 'serve',
         config(config) {
             return {
+                appType: 'custom',
                 build: {
                     outDir: resolveOutDir(config)
                 }
@@ -23,12 +24,20 @@ function previewConfig() {
             configVike = await getConfigVike(config);
         },
         configurePreviewServer(server) {
+            /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
+               - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
+            config.appType = 'mpa'
+            */
             markEnvAsPreview();
             return () => {
                 assertDist();
-                if (!configVike.prerender) {
-                    addSsrMiddleware(server.middlewares);
+                /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
+                if (!configVike.prerender || configVike.prerender.partial) {
+                  addSsrMiddleware(server.middlewares)
                 }
+                /*/
+                addSsrMiddleware(server.middlewares);
+                //*/
                 addStatic404Middleware(server.middlewares);
             };
         }

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

@@ -5,7 +5,7 @@ export { prerenderForceExit };
 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, hasPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
@@ -16,7 +16,7 @@ import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
-import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/utils.js';
+import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
@@ -24,6 +24,8 @@ import { assertPathIsFilesystemAbsolute } from '../../utils/assertPathIsFilesyst
 import { isAbortError } from '../../shared/route/abort.js';
 import { loadPageFilesServerSide } from '../runtime/renderPage/loadPageFilesServerSide.js';
 import { assertHookFn } from '../../shared/hooks/getHook.js';
+import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
+import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 async function prerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
 }
@@ -67,7 +69,8 @@ async function runPrerender(options, manuallyTriggered) {
         pageContextInit: options.pageContextInit ?? null
     });
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(renderContext, doNotPrerenderList, concurrencyLimit);
+    const vikeConfig = await getVikeConfig(viteConfig, false);
+    await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
     await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit);
     await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext, renderContext);
@@ -82,8 +85,9 @@ async function runPrerender(options, manuallyTriggered) {
     await Promise.all(htmlFiles.map((htmlFile) => writeHtmlFile(htmlFile, root, outDirClient, concurrencyLimit, options.onPagePrerender, logLevel)));
     warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, partial);
 }
-async function collectDoNoPrerenderList(renderContext, doNotPrerenderList, concurrencyLimit) {
-    renderContext.pageConfigs.forEach((pageConfig) => {
+async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
+    // V1 design
+    pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
         const configValue = getConfigValue(pageConfig, configName, 'boolean');
         if (configValue?.value === false) {
@@ -97,6 +101,8 @@ async function collectDoNoPrerenderList(renderContext, doNotPrerenderList, concu
             });
         }
     });
+    // Old design
+    // TODO/v1-release: remove
     await Promise.all(renderContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
@@ -244,7 +250,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             _providedByHook: null,
             routeParams,
             _pageId: pageId,
-            _routeMatches: [
+            _debugRouteMatches: [
                 {
                     pageId,
                     routeType: pageRoute.routeType,
@@ -285,7 +291,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         const configValue = pageConfigGlobal.configValues.onPrerenderStart;
         if (configValue?.value) {
             const { value: hookFn } = configValue;
-            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAtInfo should always be defined
+            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAt should always be defined
             const hookFilePath = getHookFilePathToShowToUser(configValue);
             assert(hookFilePath);
             onPrerenderStartHook = {
@@ -343,7 +349,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             enumerable: false,
             configurable: true
         });
-        assert(hasPropertyGetter(pageContext, 'url'));
+        assert(isPropertyGetter(pageContext, 'url'));
         assert(pageContext.urlOriginal);
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
@@ -382,7 +388,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     prerenderContext.pageContexts = result.prerenderContext.pageContexts;
     prerenderContext.pageContexts.forEach((pageContext) => {
         // TODO/v1-release: remove
-        if (!hasPropertyGetter(pageContext, 'url') && pageContext.url) {
+        if (pageContext.url && !isPropertyGetter(pageContext, 'url')) {
             assertWarning(false, msgPrefix +
                 ' provided pageContext.url but it should provide pageContext.urlOriginal instead, see https://vike.dev/migration/0.4.23', { onlyOnce: true });
             pageContext.urlOriginal = pageContext.url;
@@ -407,10 +413,9 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
     await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
         const { urlOriginal } = pageContext;
         assert(urlOriginal);
-        const routeResult = await route(pageContext);
-        assert(hasProp(routeResult.pageContextAddendum, '_pageId', 'null') ||
-            hasProp(routeResult.pageContextAddendum, '_pageId', 'string'));
-        if (routeResult.pageContextAddendum._pageId === null) {
+        const pageContextFromRoute = await route(pageContext);
+        assert(hasProp(pageContextFromRoute, '_pageId', 'null') || hasProp(pageContextFromRoute, '_pageId', 'string'));
+        if (pageContextFromRoute._pageId === null) {
             let hookName;
             let hookFilePath;
             if (pageContext._providedByHook) {
@@ -423,17 +428,17 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             }
             if (hookName) {
                 assert(hookFilePath);
-                assertUsage(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${pc.cyan(urlOriginal)} that doesn't match any of your page routes. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
+                assertUsage(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${pc.cyan(urlOriginal)} that ${noRouteMatch}. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
             }
             else {
                 // `prerenderHookFile` is `null` when the URL was deduced by the Filesytem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
-                assert(routeResult.pageContextAddendum._routingProvidedByOnBeforeRouteHook);
+                assert(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
                 // Abort since the URL doesn't correspond to any page
                 return;
             }
         }
-        assert(routeResult.pageContextAddendum._pageId);
-        objectAssign(pageContext, routeResult.pageContextAddendum);
+        assert(pageContextFromRoute._pageId);
+        objectAssign(pageContext, pageContextFromRoute);
         const { _pageId: pageId } = pageContext;
         objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
         let usesClientRouter;
@@ -487,15 +492,18 @@ function warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList)
 }
 function warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, partial) {
     const isV1 = renderContext.pageConfigs.length > 0;
-    const hookName = isV1 ? 'prerender' : 'onBeforePrerenderStart';
-    const getPageAt = isV1 ? (pageId) => `defined at ${pageId}` : (pageId) => `\`${pageId}.page.*\``;
+    const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
+    /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
+    const optOutName = isV1 ? 'prerender' : 'doNotPrerender'
+    const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
+    */
     renderContext.allPageIds
         .filter((pageId) => !prerenderPageIds[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
         .filter((pageId) => !isErrorPage(pageId, renderContext.pageConfigs))
         .forEach((pageId) => {
-        const pageAt = getPageAt(pageId);
-        assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, and no ${hookName}() hook returned (an) URL(s) matching the page's route. Either use a ${hookName}() hook to pre-render the page, or use the option ${pc.cyan('prerender.partial')} to suppress this warning, see https://vike.dev/prerender-config`, { onlyOnce: true });
+        const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
+        assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender-config#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
 async function prerender404(htmlFiles, renderContext, prerenderContext) {

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

@@ -5,7 +5,7 @@ export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';
 export * from '../../utils/getOutDirs.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../shared/hooks/executeHook.js';

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

@@ -7,7 +7,7 @@ export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';
 export * from '../../utils/getOutDirs.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../shared/hooks/executeHook.js';

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

@@ -1,6 +1,6 @@
 export { serializePageContextClientSide };
 export { serializePageContextAbort };
-import { stringify } from '@brillout/json-serializer/stringify';
+import { stringify, isJsonSerializerError } from '@brillout/json-serializer/stringify';
 import { assert, assertWarning, hasProp, unique } from '../utils.js';
 import { isErrorPage } from '../../../shared/error-page.js';
 import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
@@ -46,19 +46,33 @@ function serializePageContextClientSide(pageContext) {
             catch (err) {
                 hasWarned = true;
                 propsNonSerializable.push(prop);
-                assert(hasProp(err, 'messageCore', 'string'));
-                assertWarning(false, [
+                let msg = [
                     `${varName} cannot be serialized and, therefore, cannot be passed to the client.`,
-                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`,
-                    `Serialization error: ${err.messageCore}.`
-                ].join(' '), { onlyOnce: false });
+                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`
+                ].join(' ');
+                if (isJsonSerializerError(err)) {
+                    msg = `${msg} Serialization error: ${err.messageCore}.`;
+                }
+                else {
+                    // When a property getter throws an error
+                    console.warn('Serialization error:');
+                    console.warn(err);
+                    msg = `${msg} The serialization failed because of the error printed above.`;
+                }
+                // We warn (instead of throwing an error) since Vike's client runtime throws an error (with `assertUsage()`) if the user's client code tries to access the property that cannot be serialized
+                assertWarning(false, msg, { onlyOnce: false });
             }
         });
         assert(hasWarned);
         propsNonSerializable.forEach((prop) => {
             pageContextClient[prop] = notSerializable;
         });
-        pageContextSerialized = serialize(pageContextClient);
+        try {
+            pageContextSerialized = serialize(pageContextClient);
+        }
+        catch (err) {
+            assert(false);
+        }
     }
     return pageContextSerialized;
 }

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

@@ -1,11 +1,11 @@
 export { debugPageFiles };
-export type { PageContextDebug };
-import { RouteMatches } from '../../../shared/route/index.js';
+export type { PageContextDebugRouteMatches };
+import type { RouteMatches } from '../../../shared/route/index.js';
 import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
 import type { PageFile } from '../../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-type PageContextDebug = {
-    _routeMatches: 'ROUTE_ERROR' | RouteMatches;
+type PageContextDebugRouteMatches = {
+    _debugRouteMatches: 'ROUTING_ERROR' | RouteMatches;
 };
 declare function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoaded, pageFilesServerSide, pageFilesClientSide, clientEntries, clientDependencies }: {
     pageContext: {
@@ -13,7 +13,7 @@ declare function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, page
         _pageId: string;
         _pageFilesAll: PageFile[];
         _pageConfigs: PageConfigRuntime[];
-    } & PageContextDebug;
+    } & PageContextDebugRouteMatches;
     isHtmlOnly: boolean;
     isClientRouting: boolean;
     pageFilesLoaded: PageFile[];