vike 0.4.167 → 0.4.168

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -10,6 +10,7 @@ const fast_glob_1 = __importDefault(require("fast-glob"));
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const transpileAndExecuteFile_js_1 = require("./transpileAndExecuteFile.js");
 const execA = (0, util_1.promisify)(child_process_1.exec);
 (0, utils_js_1.assertIsNotProductionRuntime)();
 (0, utils_js_1.assertIsSingleModuleInstance)('crawlPlusFiles.ts');
@@ -34,6 +35,7 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     else {
         files = await fastGlob(userRootDir, outDirRelativeFromUserRootDir);
     }
+    files = files.filter((file) => !(0, transpileAndExecuteFile_js_1.isTemporaryBuildFile)(file));
     {
         const timeAfter = new Date().getTime();
         const timeSpent = timeAfter - timeBefore;

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/loadFileAtConfigTime.js

@@ -68,7 +68,6 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         const { importPath: importPathAbsolute } = importData;
         const filePathAbsoluteFilesystem = (0, resolveImportPath_js_1.resolveImportPath)(importData, configFilePath);
         (0, resolveImportPath_js_1.assertImportPath)(filePathAbsoluteFilesystem, importData, configFilePath);
-        warnUserLandExtension(importPathAbsolute, configFilePath);
         const filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteFilesystem, userRootDir, importPathAbsolute });
         extendsConfigFiles.push(filePath);
     });
@@ -81,13 +80,6 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }
-function warnUserLandExtension(importPath, configFilePath) {
-    // We preserve this feature because we may need it for eject
-    (0, utils_js_1.assertWarning)((0, utils_js_1.isNpmPackageImport)(importPath, {
-        // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
-        cannotBePathAlias: true
-    }) || importPath.includes('/node_modules/'), `${configFilePath.filePathToShowToUser} uses ${picocolors_1.default.cyan('extends')} to inherit from ${picocolors_1.default.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this.`, { onlyOnce: true });
-}
 function getExtendsImportData(configFileExports, configFilePath) {
     const { filePathToShowToUser } = configFilePath;
     const configFileExport = (0, getConfigFileExport_js_1.getConfigFileExport)(configFileExports, filePathToShowToUser);

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTmpFile = exports.getConfigExecutionErrorIntroMsg = exports.getConfigBuildErrorFormatted = exports.transpileAndExecuteFile = void 0;
+exports.isTemporaryBuildFile = exports.getConfigExecutionErrorIntroMsg = exports.getConfigBuildErrorFormatted = exports.transpileAndExecuteFile = void 0;
 const esbuild_1 = require("esbuild");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -82,87 +82,96 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
         treeShaking: false,
         minify: false,
-        metafile: transformImports !== 'all',
-        bundle: transformImports !== 'all'
+        metafile: true,
+        bundle: true
     };
-    let pointerImports;
-    if (transformImports === 'all') {
-        pointerImports = 'all';
-        options.packages = 'external';
-    }
-    else {
-        const pointerImports_ = (pointerImports = {});
-        options.plugins = [
-            // Determine what import should be externalized (and then transformed to a pointer/fake import)
-            {
-                name: 'vike:externalize-heuristic',
-                setup(build) {
-                    // https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
+    let pointerImports = {};
+    options.plugins = [
+        // Determine whether an import should be:
+        //  - A pointer import
+        //  - Externalized
+        {
+            name: 'vike-esbuild',
+            setup(build) {
+                // https://github.com/brillout/esbuild-playground
+                build.onResolve({ filter: /.*/ }, async (args) => {
+                    if (args.kind !== 'import-statement')
+                        return;
+                    // Avoid infinite loop: https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
                     const useEsbuildResolver = 'useEsbuildResolver';
-                    // https://github.com/brillout/esbuild-playground
-                    build.onResolve({ filter: /.*/ }, async (args) => {
-                        if (args.kind !== 'import-statement')
-                            return;
-                        if (args.pluginData?.[useEsbuildResolver])
-                            return;
-                        const { path, ...opts } = args;
-                        opts.pluginData = { [useEsbuildResolver]: true };
-                        const resolved = await build.resolve(path, opts);
-                        resolved.path = (0, utils_js_1.toPosixPath)(resolved.path);
-                        // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
-                        //  - This is temporary, see comment below.
-                        const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
-                        const isPointerImport = 
+                    if (args.pluginData?.[useEsbuildResolver])
+                        return;
+                    const { path, ...opts } = args;
+                    opts.pluginData = { [useEsbuildResolver]: true };
+                    const resolved = await build.resolve(path, opts);
+                    if (resolved.errors.length > 0) {
+                        /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs file which isn't that nice, whereas esbuild refers to the source +config.ts file.
+                        pointerImports[args.path] = false
+                        return { external: true }
+                        */
+                        // Let esbuild throw the error. (It throws a nice & pretty error.)
+                        cleanEsbuildErrors(resolved.errors);
+                        return resolved;
+                    }
+                    (0, utils_js_1.assert)(resolved.path);
+                    resolved.path = (0, utils_js_1.toPosixPath)(resolved.path);
+                    // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
+                    //  - This is temporary, see comment below.
+                    const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
+                    const isPointerImport = transformImports === 'all' ||
                         // .jsx, .vue, .svg, ... => obviously not config code
                         !(0, utils_js_1.isJavaScriptFile)(resolved.path) ||
-                            // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a configas been set by the user or by a Vike extension).
-                            //  - We should have Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
-                            //    - vike@0.4.162 already started soft-requiring Vike extensions to set the name config
-                            isVikeExtensionConfigImport ||
-                            // Cannot be resolved by esbuild => take a leap of faith and make it a pointer import.
-                            //  - For example if esbuild cannot resolve a path alias while Vite can.
-                            //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
-                            resolved.errors.length > 0;
-                        pointerImports_[resolved.path] = isPointerImport;
-                        (0, utils_js_1.assertPosixPath)(resolved.path);
-                        const isExternal = isPointerImport ||
-                            // npm package imports that aren't pointer imports (e.g. importing a Vite plugin)
-                            resolved.path.includes('/node_modules/');
-                        if (debug.isActivated)
-                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
-                        if (isExternal) {
-                            return { external: true, path: resolved.path };
-                        }
-                        else {
-                            return resolved;
-                        }
-                    });
-                }
-            },
-            // Track dependencies
-            {
-                name: 'vike:dependency-tracker',
-                setup(b) {
-                    b.onLoad({ filter: /./ }, (args) => {
-                        // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
-                        let { path } = args;
-                        path = (0, utils_js_1.toPosixPath)(path);
-                        getVikeConfig_js_1.vikeConfigDependencies.add(path);
-                        return undefined;
-                    });
-                    /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
-                     *  - Because onLoad() isn't call if the config dependency can't be resolved.
-                     *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
-                     *    ```bash
-                     *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
-                     *    ```
-                     *  - But implementing a fix is complex and isn't worth it.
-                    b.onResolve(...)
-                    */
-                }
+                        // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a configas been set by the user or by a Vike extension).
+                        //  - We should have Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
+                        //    - vike@0.4.162 already started soft-requiring Vike extensions to set the name config
+                        isVikeExtensionConfigImport ||
+                        // Cannot be resolved by esbuild => take a leap of faith and make it a pointer import.
+                        //  - For example if esbuild cannot resolve a path alias while Vite can.
+                        //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
+                        resolved.errors.length > 0;
+                    pointerImports[resolved.path] = isPointerImport;
+                    (0, utils_js_1.assertPosixPath)(resolved.path);
+                    const isExternal = isPointerImport ||
+                        // Performance: npm package imports that aren't pointer imports can be externalized. For example, if Vike eventually adds support for setting Vite configs in the vike.config.js file, then the user may import a Vite plugin in his vike.config.js file. (We could as well let esbuild always transpile /node_modules/ code but it would be useless and would unnecessarily slow down transpilation.)
+                        resolved.path.includes('/node_modules/');
+                    if (debug.isActivated)
+                        debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                    // We need esbuild to resolve path aliases so that we can use:
+                    //   isNpmPackageImport(str, { cannotBePathAlias: true })
+                    //   assertIsNpmPackageImport()
+                    (0, utils_js_1.assertPathIsFilesystemAbsolute)(resolved.path);
+                    if (isExternal) {
+                        return { external: true, path: resolved.path };
+                    }
+                    else {
+                        return resolved;
+                    }
+                });
             }
-        ];
-    }
+        },
+        // Track dependencies
+        {
+            name: 'vike:dependency-tracker',
+            setup(b) {
+                b.onLoad({ filter: /./ }, (args) => {
+                    // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
+                    let { path } = args;
+                    path = (0, utils_js_1.toPosixPath)(path);
+                    getVikeConfig_js_1.vikeConfigDependencies.add(path);
+                    return undefined;
+                });
+                /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
+                 *  - Because onLoad() isn't call if the config dependency can't be resolved.
+                 *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
+                 *    ```bash
+                 *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
+                 *    ```
+                 *  - But implementing a fix is complex and isn't worth it.
+                b.onResolve(...)
+                */
+            }
+        }
+    ];
     let result;
     try {
         result = await (0, esbuild_1.build)(options);
@@ -172,15 +181,13 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         throw err;
     }
     // Track dependencies
-    if (transformImports !== 'all') {
-        (0, utils_js_1.assert)(result.metafile);
-        Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
-            filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
-            (0, utils_js_1.assertPosixPath)(userRootDir);
-            const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathRelative);
-            getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-        });
-    }
+    (0, utils_js_1.assert)(result.metafile);
+    Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
+        filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
+        (0, utils_js_1.assertPosixPath)(userRootDir);
+        const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathRelative);
+        getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+    });
     const code = result.outputFiles[0].text;
     (0, utils_js_1.assert)(typeof code === 'string');
     return { code, pointerImports };
@@ -189,7 +196,7 @@ async function executeTranspiledFile(filePath, code) {
     const { filePathAbsoluteFilesystem } = 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(filePathAbsoluteFilesystem);
+    const filePathTmp = getTemporaryBuildFilePath(filePathAbsoluteFilesystem);
     fs_1.default.writeFileSync(filePathTmp, code);
     const clean = () => fs_1.default.unlinkSync(filePathTmp);
     let fileExports = {};
@@ -248,22 +255,21 @@ function getConfigExecutionErrorIntroMsg(err) {
     return errIntroMsg ?? null;
 }
 exports.getConfigExecutionErrorIntroMsg = getConfigExecutionErrorIntroMsg;
-const tmpPrefix = `[build-`;
-function getFilePathTmp(filePathAbsoluteFilesystem) {
+function getTemporaryBuildFilePath(filePathAbsoluteFilesystem) {
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     const dirname = path_1.default.posix.dirname(filePathAbsoluteFilesystem);
     const filename = path_1.default.posix.basename(filePathAbsoluteFilesystem);
-    // Syntax with semicolon `[build:${/*...*/}]` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
-    const tag = `${tmpPrefix}${(0, utils_js_1.getRandomId)(12)}]`;
-    const filePathTmp = path_1.default.posix.join(dirname, `${tag}${filename}.mjs`);
+    // Syntax with semicolon `build:${/*...*/}` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
+    const filePathTmp = path_1.default.posix.join(dirname, `${filename}.build-${(0, utils_js_1.getRandomId)(12)}.mjs`);
+    (0, utils_js_1.assert)(isTemporaryBuildFile(filePathTmp));
     return filePathTmp;
 }
-function isTmpFile(filePath) {
+function isTemporaryBuildFile(filePath) {
     (0, utils_js_1.assertPosixPath)(filePath);
     const fileName = path_1.default.posix.basename(filePath);
-    return fileName.startsWith(tmpPrefix);
+    return /\.build-[a-z0-9]{12}\.mjs$/.test(fileName);
 }
-exports.isTmpFile = isTmpFile;
+exports.isTemporaryBuildFile = isTemporaryBuildFile;
 function isHeaderFile(filePath) {
     (0, utils_js_1.assertPosixPath)(filePath);
     const fileExtensions = getFileExtensions(filePath);
@@ -306,3 +312,23 @@ function getErrIntroMsg(operation, filePath) {
     ].join(' ');
     return msg;
 }
+function cleanEsbuildErrors(errors) {
+    errors.forEach((e) => (e.notes = e.notes.filter((note) => 
+    // Remove note:
+    // ```shell
+    // You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
+    // ```
+    //
+    // From error:
+    // ```shell
+    // ✘ [ERROR] Could not resolve "#root/renderer/onRenderHtml_typo" [plugin vike-esbuild]
+    //
+    //    renderer/+config.h.js:1:29:
+    //      1 │ import { onRenderHtml } from "#root/renderer/onRenderHtml_typo"
+    //        ╵                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    //
+    //  You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
+    //
+    // ```
+    !note.text.includes('as external to exclude it from the bundle'))));
+}

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -750,7 +750,7 @@ async function findPlusFiles(userRootDir, outDirRoot, isDev) {
 }
 function getConfigName(filePath) {
     (0, utils_js_1.assertPosixPath)(filePath);
-    if ((0, transpileAndExecuteFile_js_1.isTmpFile)(filePath))
+    if ((0, transpileAndExecuteFile_js_1.isTemporaryBuildFile)(filePath))
         return null;
     const fileName = path_1.default.posix.basename(filePath);
     // assertNoUnexpectedPlusSign(filePath, fileName)
@@ -781,7 +781,30 @@ function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
 }
 */
 function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
-    let errMsg = `${filePathToShowToUser} defines an unknown config ${picocolors_1.default.cyan(configName)}`;
+    {
+        const ui = ['vike-react', 'vike-vue', 'vike-solid'];
+        const knownVikeExntensionConfigs = {
+            description: ui,
+            favicon: ui,
+            Head: ui,
+            Layout: ui,
+            onCreateApp: ['vike-vue'],
+            title: ui,
+            ssr: ui,
+            stream: ui,
+            Wrapper: ui
+        };
+        if (configName in knownVikeExntensionConfigs) {
+            const requiredVikeExtension = knownVikeExntensionConfigs[configName];
+            (0, utils_js_1.assertUsage)(false, [
+                `${filePathToShowToUser} uses the config ${picocolors_1.default.cyan(configName)} (https://vike.dev/${configName})`,
+                `which requires the Vike extension ${requiredVikeExtension.map((e) => picocolors_1.default.bold(e)).join('/')}.`,
+                `Make sure to install the Vike extension,`,
+                `and make sure it applies to ${filePathToShowToUser} as explained at https://vike.dev/extends#inheritance.`
+            ].join(' '));
+        }
+    }
+    let errMsg = `${filePathToShowToUser} sets an unknown config ${picocolors_1.default.cyan(configName)}`;
     let configNameSimilar = null;
     if (configName === 'page') {
         configNameSimilar = 'Page';
@@ -789,17 +812,13 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
     else {
         configNameSimilar = (0, utils_js_1.getMostSimilar)(configName, configNames);
     }
-    if (configNameSimilar || configName === 'page') {
-        (0, utils_js_1.assert)(configNameSimilar);
+    if (configNameSimilar) {
         (0, utils_js_1.assert)(configNameSimilar !== configName);
-        errMsg += `, did you mean to define ${picocolors_1.default.cyan(configNameSimilar)} instead?`;
+        errMsg += `, did you mean to set ${picocolors_1.default.cyan(configNameSimilar)} instead?`;
         if (configName === 'page') {
             errMsg += ` (The name of the config ${picocolors_1.default.cyan('Page')} starts with a capital letter ${picocolors_1.default.cyan('P')} because it usually defines a UI component: a ubiquitous JavaScript convention is to start the name of UI components with a capital letter.)`;
         }
     }
-    else {
-        errMsg += `, you need to define the config ${picocolors_1.default.cyan(configName)} by using ${picocolors_1.default.cyan('config.meta')} https://vike.dev/meta`;
-    }
     (0, utils_js_1.assertUsage)(false, errMsg);
 }
 function determineRouteFilesystem(locationId, configValueSources) {

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

@@ -15,7 +15,7 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
         const clientDependencies = [];
         clientDependencies.push({
             id: (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageConfig.pageId, true),
-            onlyAssets: false,
+            onlyAssets: isClientSideRenderable ? false : true,
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module

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

@@ -21,6 +21,10 @@ const knownErrors = [
         // ```
         errMsg: 'assets.json',
         link: 'https://vike.dev/getGlobalContext'
+    },
+    {
+        errMsg: /Named export.*not found/i,
+        link: 'https://vike.dev/broken-npm-package#named-export-not-found'
     }
 ];
 function logErrorHint(error) {
@@ -290,7 +294,15 @@ function extractFromNodeModulesPath(str) {
     return packageName;
 }
 function includes(str1, str2) {
-    return !!str1 && str1.toLowerCase().includes(str2.toLowerCase());
+    if (!str1)
+        return false;
+    if (str2 instanceof RegExp) {
+        return str2.test(str1.toLowerCase());
+    }
+    if (typeof str2 === 'string') {
+        return str1.toLowerCase().includes(str2.toLowerCase());
+    }
+    return false;
 }
 function includesNodeModules(str) {
     if (!str)

package/dist/cjs/utils/assertPathIsFilesystemAbsolute.js

@@ -11,11 +11,11 @@ const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 function assertPathIsFilesystemAbsolute(p) {
     (0, filesystemPathHandling_js_1.assertPosixPath)(p);
     (0, assert_js_1.assert)(!p.startsWith('/@fs/'));
-    if (process.platform === 'win32') {
-        (0, assert_js_1.assert)(path_1.default.win32.isAbsolute(p));
+    if (process.platform !== 'win32') {
+        (0, assert_js_1.assert)(p.startsWith('/'));
     }
     else {
-        (0, assert_js_1.assert)(p.startsWith('/'));
+        (0, assert_js_1.assert)(path_1.default.win32.isAbsolute(p));
     }
 }
 exports.assertPathIsFilesystemAbsolute = assertPathIsFilesystemAbsolute;

package/dist/cjs/utils/projectInfo.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.167';
+const PROJECT_VERSION = '0.4.168';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/history.d.ts

@@ -3,6 +3,7 @@ type HistoryState = {
     timestamp?: number;
     scrollPosition?: null | ScrollPosition;
     triggeredBy?: 'user' | 'vike' | 'browser';
+    _isVikeEnhanced: true;
 };
 type ScrollPosition = {
     x: number;

package/dist/esm/client/client-routing-runtime/history.js

@@ -1,6 +1,5 @@
 export { initHistoryState, getHistoryState, pushHistory, saveScrollPosition, monkeyPatchHistoryPushState };
-import { assert, assertUsage, getGlobalObject, hasProp, isObject } from './utils.js';
-const globalObject = getGlobalObject('history.ts', {});
+import { assert, assertUsage, hasProp, isObject } from './utils.js';
 // Fill missing state information:
 //  - `history.state` can uninitialized (i.e. `null`):
 //    - The very first render
@@ -8,9 +7,10 @@ const globalObject = getGlobalObject('history.ts', {});
 //    - The user clicks on an anchor link `<a href="#section">Section</a>` (Vike's `onLinkClick()` handler skips hash links).
 //  - State information may be incomplete if `history.state` is set by an old Vike version. (E.g. `state.timestamp` was introduced for `pageContext.isBackwardNavigation` in `0.4.19`.)
 function initHistoryState() {
+    // No way found to add TypeScript types to `window.history.state`: https://github.com/microsoft/TypeScript/issues/36178
     let state = window.history.state;
     if (!state) {
-        state = {};
+        state = { _isVikeEnhanced: true };
     }
     let hasModifications = false;
     if (!('timestamp' in state)) {
@@ -49,7 +49,7 @@ function saveScrollPosition() {
 function pushHistory(url, overwriteLastHistoryEntry) {
     if (!overwriteLastHistoryEntry) {
         const timestamp = getTimestamp();
-        pushHistoryState({ timestamp, scrollPosition: null, triggeredBy: 'vike' }, url);
+        pushHistoryState({ timestamp, scrollPosition: null, triggeredBy: 'vike', _isVikeEnhanced: true }, url);
     }
     else {
         replaceHistoryState(getHistoryState(), url);
@@ -69,25 +69,29 @@ function assertState(state) {
     }
 }
 function replaceHistoryState(state, url) {
-    window.history.replaceState(state, '', url ?? /* Passing `undefined` chokes older Edge versions */ null);
+    const url_ = url ?? null; // Passing `undefined` chokes older Edge versions.
+    window.history.replaceState(state, '', url_);
 }
 function pushHistoryState(state, url) {
-    pushStateOriginal(state, '', url);
+    // Vike should call window.history.pushState() (and not the orignal `pushStateOriginal()`) so that other tools (e.g. user tracking) can listen to Vike's pushState() calls, see https://github.com/vikejs/vike/issues/1582.
+    window.history.pushState(state, '', url);
 }
 function monkeyPatchHistoryPushState() {
-    globalObject.pushStateOriginal = globalObject.pushStateOriginal ?? window.history.pushState;
-    window.history.pushState = (stateFromUser = {}, ...rest) => {
-        assertUsage(null === stateFromUser || undefined === stateFromUser || isObject(stateFromUser), 'history.pushState(state) argument state must be an object');
-        const state = {
-            scrollPosition: getScrollPosition(),
-            timestamp: getTimestamp(),
-            ...stateFromUser,
-            // Don't allow user to overwrite triggeredBy as it would break Vike's handling of the 'popstate' event
-            triggeredBy: 'user'
-        };
-        return pushStateOriginal(state, ...rest);
+    const pushStateOriginal = window.history.pushState.bind(window.history);
+    window.history.pushState = (stateOriginal = {}, ...rest) => {
+        assertUsage(stateOriginal === undefined || stateOriginal === null || isObject(stateOriginal), 'history.pushState(state) argument state must be an object');
+        const stateEnhanced = isVikeEnhanced(stateOriginal)
+            ? stateOriginal
+            : {
+                _isVikeEnhanced: true,
+                scrollPosition: getScrollPosition(),
+                timestamp: getTimestamp(),
+                triggeredBy: 'user',
+                ...stateOriginal
+            };
+        return pushStateOriginal(stateEnhanced, ...rest);
     };
 }
-function pushStateOriginal(...args) {
-    globalObject.pushStateOriginal.apply(history, args);
+function isVikeEnhanced(state) {
+    return isObject(state) && '_isVikeEnhanced' in state;
 }

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

@@ -5,6 +5,7 @@ import glob from 'fast-glob';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import pc from '@brillout/picocolors';
+import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
 const execA = promisify(exec);
 assertIsNotProductionRuntime();
 assertIsSingleModuleInstance('crawlPlusFiles.ts');
@@ -29,6 +30,7 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     else {
         files = await fastGlob(userRootDir, outDirRelativeFromUserRootDir);
     }
+    files = files.filter((file) => !isTemporaryBuildFile(file));
     {
         const timeAfter = new Date().getTime();
         const timeSpent = timeAfter - timeBefore;

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

@@ -2,7 +2,7 @@
 export { loadImportedFile };
 export { loadValueFile };
 export { loadConfigFile };
-import { assert, assertUsage, assertWarning, hasProp, assertIsNotProductionRuntime, isNpmPackageImport } from '../../../../utils.js';
+import { assert, assertUsage, hasProp, assertIsNotProductionRuntime } from '../../../../utils.js';
 import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
 import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
 import pc from '@brillout/picocolors';
@@ -62,7 +62,6 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         const { importPath: importPathAbsolute } = importData;
         const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
         assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
-        warnUserLandExtension(importPathAbsolute, configFilePath);
         const filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir, importPathAbsolute });
         extendsConfigFiles.push(filePath);
     });
@@ -75,13 +74,6 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }
-function warnUserLandExtension(importPath, configFilePath) {
-    // We preserve this feature because we may need it for eject
-    assertWarning(isNpmPackageImport(importPath, {
-        // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
-        cannotBePathAlias: true
-    }) || importPath.includes('/node_modules/'), `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this.`, { onlyOnce: true });
-}
 function getExtendsImportData(configFileExports, configFilePath) {
     const { filePathToShowToUser } = configFilePath;
     const configFileExport = getConfigFileExport(configFileExports, filePathToShowToUser);

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

@@ -2,7 +2,7 @@ export { transformFileImports };
 export { parseImportData };
 export { isImportData };
 export type { ImportData };
-declare function transformFileImports(code: string, filePathToShowToUser2: string, pointerImports: 'all' | Record<string, boolean>, skipWarnings?: true): string | null;
+declare function transformFileImports(code: string, filePathToShowToUser2: string, pointerImports: Record<string, boolean> | 'all', skipWarnings?: true): string | null;
 /**
  * Data Structure holding info about import statement:
  *   `import { someExport as someImport } from './some-file'`

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

@@ -1,7 +1,7 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
-export { isTmpFile };
+export { isTemporaryBuildFile };
 import 'source-map-support/register.js';
 import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
 declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isConfigFile: boolean | 'is-extension-config'): Promise<{
@@ -9,4 +9,4 @@ declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir
 }>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;
 declare function getConfigExecutionErrorIntroMsg(err: unknown): string | null;
-declare function isTmpFile(filePath: string): boolean;
+declare function isTemporaryBuildFile(filePath: string): boolean;

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

@@ -1,13 +1,13 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
-export { isTmpFile };
+export { isTemporaryBuildFile };
 import { build, formatMessages } from 'esbuild';
 import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isJavaScriptFile, createDebugger } from '../../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isJavaScriptFile, createDebugger, assertPathIsFilesystemAbsolute } from '../../../../utils.js';
 import { transformFileImports } from './transformFileImports.js';
 import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
@@ -79,87 +79,96 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
         treeShaking: false,
         minify: false,
-        metafile: transformImports !== 'all',
-        bundle: transformImports !== 'all'
+        metafile: true,
+        bundle: true
     };
-    let pointerImports;
-    if (transformImports === 'all') {
-        pointerImports = 'all';
-        options.packages = 'external';
-    }
-    else {
-        const pointerImports_ = (pointerImports = {});
-        options.plugins = [
-            // Determine what import should be externalized (and then transformed to a pointer/fake import)
-            {
-                name: 'vike:externalize-heuristic',
-                setup(build) {
-                    // https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
+    let pointerImports = {};
+    options.plugins = [
+        // Determine whether an import should be:
+        //  - A pointer import
+        //  - Externalized
+        {
+            name: 'vike-esbuild',
+            setup(build) {
+                // https://github.com/brillout/esbuild-playground
+                build.onResolve({ filter: /.*/ }, async (args) => {
+                    if (args.kind !== 'import-statement')
+                        return;
+                    // Avoid infinite loop: https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
                     const useEsbuildResolver = 'useEsbuildResolver';
-                    // https://github.com/brillout/esbuild-playground
-                    build.onResolve({ filter: /.*/ }, async (args) => {
-                        if (args.kind !== 'import-statement')
-                            return;
-                        if (args.pluginData?.[useEsbuildResolver])
-                            return;
-                        const { path, ...opts } = args;
-                        opts.pluginData = { [useEsbuildResolver]: true };
-                        const resolved = await build.resolve(path, opts);
-                        resolved.path = toPosixPath(resolved.path);
-                        // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
-                        //  - This is temporary, see comment below.
-                        const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
-                        const isPointerImport = 
+                    if (args.pluginData?.[useEsbuildResolver])
+                        return;
+                    const { path, ...opts } = args;
+                    opts.pluginData = { [useEsbuildResolver]: true };
+                    const resolved = await build.resolve(path, opts);
+                    if (resolved.errors.length > 0) {
+                        /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs file which isn't that nice, whereas esbuild refers to the source +config.ts file.
+                        pointerImports[args.path] = false
+                        return { external: true }
+                        */
+                        // Let esbuild throw the error. (It throws a nice & pretty error.)
+                        cleanEsbuildErrors(resolved.errors);
+                        return resolved;
+                    }
+                    assert(resolved.path);
+                    resolved.path = toPosixPath(resolved.path);
+                    // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
+                    //  - This is temporary, see comment below.
+                    const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
+                    const isPointerImport = transformImports === 'all' ||
                         // .jsx, .vue, .svg, ... => obviously not config code
                         !isJavaScriptFile(resolved.path) ||
-                            // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a configas been set by the user or by a Vike extension).
-                            //  - We should have Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
-                            //    - vike@0.4.162 already started soft-requiring Vike extensions to set the name config
-                            isVikeExtensionConfigImport ||
-                            // Cannot be resolved by esbuild => take a leap of faith and make it a pointer import.
-                            //  - For example if esbuild cannot resolve a path alias while Vite can.
-                            //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
-                            resolved.errors.length > 0;
-                        pointerImports_[resolved.path] = isPointerImport;
-                        assertPosixPath(resolved.path);
-                        const isExternal = isPointerImport ||
-                            // npm package imports that aren't pointer imports (e.g. importing a Vite plugin)
-                            resolved.path.includes('/node_modules/');
-                        if (debug.isActivated)
-                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
-                        if (isExternal) {
-                            return { external: true, path: resolved.path };
-                        }
-                        else {
-                            return resolved;
-                        }
-                    });
-                }
-            },
-            // Track dependencies
-            {
-                name: 'vike:dependency-tracker',
-                setup(b) {
-                    b.onLoad({ filter: /./ }, (args) => {
-                        // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
-                        let { path } = args;
-                        path = toPosixPath(path);
-                        vikeConfigDependencies.add(path);
-                        return undefined;
-                    });
-                    /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
-                     *  - Because onLoad() isn't call if the config dependency can't be resolved.
-                     *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
-                     *    ```bash
-                     *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
-                     *    ```
-                     *  - But implementing a fix is complex and isn't worth it.
-                    b.onResolve(...)
-                    */
-                }
+                        // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a configas been set by the user or by a Vike extension).
+                        //  - We should have Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
+                        //    - vike@0.4.162 already started soft-requiring Vike extensions to set the name config
+                        isVikeExtensionConfigImport ||
+                        // Cannot be resolved by esbuild => take a leap of faith and make it a pointer import.
+                        //  - For example if esbuild cannot resolve a path alias while Vite can.
+                        //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
+                        resolved.errors.length > 0;
+                    pointerImports[resolved.path] = isPointerImport;
+                    assertPosixPath(resolved.path);
+                    const isExternal = isPointerImport ||
+                        // Performance: npm package imports that aren't pointer imports can be externalized. For example, if Vike eventually adds support for setting Vite configs in the vike.config.js file, then the user may import a Vite plugin in his vike.config.js file. (We could as well let esbuild always transpile /node_modules/ code but it would be useless and would unnecessarily slow down transpilation.)
+                        resolved.path.includes('/node_modules/');
+                    if (debug.isActivated)
+                        debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                    // We need esbuild to resolve path aliases so that we can use:
+                    //   isNpmPackageImport(str, { cannotBePathAlias: true })
+                    //   assertIsNpmPackageImport()
+                    assertPathIsFilesystemAbsolute(resolved.path);
+                    if (isExternal) {
+                        return { external: true, path: resolved.path };
+                    }
+                    else {
+                        return resolved;
+                    }
+                });
             }
-        ];
-    }
+        },
+        // Track dependencies
+        {
+            name: 'vike:dependency-tracker',
+            setup(b) {
+                b.onLoad({ filter: /./ }, (args) => {
+                    // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
+                    let { path } = args;
+                    path = toPosixPath(path);
+                    vikeConfigDependencies.add(path);
+                    return undefined;
+                });
+                /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
+                 *  - Because onLoad() isn't call if the config dependency can't be resolved.
+                 *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
+                 *    ```bash
+                 *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
+                 *    ```
+                 *  - But implementing a fix is complex and isn't worth it.
+                b.onResolve(...)
+                */
+            }
+        }
+    ];
     let result;
     try {
         result = await build(options);
@@ -169,15 +178,13 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         throw err;
     }
     // Track dependencies
-    if (transformImports !== 'all') {
-        assert(result.metafile);
-        Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
-            filePathRelative = toPosixPath(filePathRelative);
-            assertPosixPath(userRootDir);
-            const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
-            vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-        });
-    }
+    assert(result.metafile);
+    Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
+        filePathRelative = toPosixPath(filePathRelative);
+        assertPosixPath(userRootDir);
+        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
+        vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+    });
     const code = result.outputFiles[0].text;
     assert(typeof code === 'string');
     return { code, pointerImports };
@@ -186,7 +193,7 @@ async function executeTranspiledFile(filePath, code) {
     const { filePathAbsoluteFilesystem } = 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(filePathAbsoluteFilesystem);
+    const filePathTmp = getTemporaryBuildFilePath(filePathAbsoluteFilesystem);
     fs.writeFileSync(filePathTmp, code);
     const clean = () => fs.unlinkSync(filePathTmp);
     let fileExports = {};
@@ -243,20 +250,19 @@ function getConfigExecutionErrorIntroMsg(err) {
     const errIntroMsg = execErrIntroMsg.get(err);
     return errIntroMsg ?? null;
 }
-const tmpPrefix = `[build-`;
-function getFilePathTmp(filePathAbsoluteFilesystem) {
+function getTemporaryBuildFilePath(filePathAbsoluteFilesystem) {
     assertPosixPath(filePathAbsoluteFilesystem);
     const dirname = path.posix.dirname(filePathAbsoluteFilesystem);
     const filename = path.posix.basename(filePathAbsoluteFilesystem);
-    // Syntax with semicolon `[build:${/*...*/}]` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
-    const tag = `${tmpPrefix}${getRandomId(12)}]`;
-    const filePathTmp = path.posix.join(dirname, `${tag}${filename}.mjs`);
+    // Syntax with semicolon `build:${/*...*/}` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
+    const filePathTmp = path.posix.join(dirname, `${filename}.build-${getRandomId(12)}.mjs`);
+    assert(isTemporaryBuildFile(filePathTmp));
     return filePathTmp;
 }
-function isTmpFile(filePath) {
+function isTemporaryBuildFile(filePath) {
     assertPosixPath(filePath);
     const fileName = path.posix.basename(filePath);
-    return fileName.startsWith(tmpPrefix);
+    return /\.build-[a-z0-9]{12}\.mjs$/.test(fileName);
 }
 function isHeaderFile(filePath) {
     assertPosixPath(filePath);
@@ -300,3 +306,23 @@ function getErrIntroMsg(operation, filePath) {
     ].join(' ');
     return msg;
 }
+function cleanEsbuildErrors(errors) {
+    errors.forEach((e) => (e.notes = e.notes.filter((note) => 
+    // Remove note:
+    // ```shell
+    // You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
+    // ```
+    //
+    // From error:
+    // ```shell
+    // ✘ [ERROR] Could not resolve "#root/renderer/onRenderHtml_typo" [plugin vike-esbuild]
+    //
+    //    renderer/+config.h.js:1:29:
+    //      1 │ import { onRenderHtml } from "#root/renderer/onRenderHtml_typo"
+    //        ╵                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    //
+    //  You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
+    //
+    // ```
+    !note.text.includes('as external to exclude it from the bundle'))));
+}

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

@@ -7,7 +7,7 @@ import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEn
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isTmpFile } from './getVikeConfig/transpileAndExecuteFile.js';
+import { isTemporaryBuildFile } from './getVikeConfig/transpileAndExecuteFile.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
@@ -745,7 +745,7 @@ async function findPlusFiles(userRootDir, outDirRoot, isDev) {
 }
 function getConfigName(filePath) {
     assertPosixPath(filePath);
-    if (isTmpFile(filePath))
+    if (isTemporaryBuildFile(filePath))
         return null;
     const fileName = path.posix.basename(filePath);
     // assertNoUnexpectedPlusSign(filePath, fileName)
@@ -776,7 +776,30 @@ function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
 }
 */
 function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
-    let errMsg = `${filePathToShowToUser} defines an unknown config ${pc.cyan(configName)}`;
+    {
+        const ui = ['vike-react', 'vike-vue', 'vike-solid'];
+        const knownVikeExntensionConfigs = {
+            description: ui,
+            favicon: ui,
+            Head: ui,
+            Layout: ui,
+            onCreateApp: ['vike-vue'],
+            title: ui,
+            ssr: ui,
+            stream: ui,
+            Wrapper: ui
+        };
+        if (configName in knownVikeExntensionConfigs) {
+            const requiredVikeExtension = knownVikeExntensionConfigs[configName];
+            assertUsage(false, [
+                `${filePathToShowToUser} uses the config ${pc.cyan(configName)} (https://vike.dev/${configName})`,
+                `which requires the Vike extension ${requiredVikeExtension.map((e) => pc.bold(e)).join('/')}.`,
+                `Make sure to install the Vike extension,`,
+                `and make sure it applies to ${filePathToShowToUser} as explained at https://vike.dev/extends#inheritance.`
+            ].join(' '));
+        }
+    }
+    let errMsg = `${filePathToShowToUser} sets an unknown config ${pc.cyan(configName)}`;
     let configNameSimilar = null;
     if (configName === 'page') {
         configNameSimilar = 'Page';
@@ -784,17 +807,13 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
     else {
         configNameSimilar = getMostSimilar(configName, configNames);
     }
-    if (configNameSimilar || configName === 'page') {
-        assert(configNameSimilar);
+    if (configNameSimilar) {
         assert(configNameSimilar !== configName);
-        errMsg += `, did you mean to define ${pc.cyan(configNameSimilar)} instead?`;
+        errMsg += `, did you mean to set ${pc.cyan(configNameSimilar)} instead?`;
         if (configName === 'page') {
             errMsg += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.cyan('P')} because it usually defines a UI component: a ubiquitous JavaScript convention is to start the name of UI components with a capital letter.)`;
         }
     }
-    else {
-        errMsg += `, you need to define the config ${pc.cyan(configName)} by using ${pc.cyan('config.meta')} https://vike.dev/meta`;
-    }
     assertUsage(false, errMsg);
 }
 function determineRouteFilesystem(locationId, configValueSources) {

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

@@ -13,7 +13,7 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
         const clientDependencies = [];
         clientDependencies.push({
             id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
-            onlyAssets: false,
+            onlyAssets: isClientSideRenderable ? false : true,
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module

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

@@ -20,6 +20,10 @@ const knownErrors = [
         // ```
         errMsg: 'assets.json',
         link: 'https://vike.dev/getGlobalContext'
+    },
+    {
+        errMsg: /Named export.*not found/i,
+        link: 'https://vike.dev/broken-npm-package#named-export-not-found'
     }
 ];
 function logErrorHint(error) {
@@ -285,7 +289,15 @@ function extractFromNodeModulesPath(str) {
     return packageName;
 }
 function includes(str1, str2) {
-    return !!str1 && str1.toLowerCase().includes(str2.toLowerCase());
+    if (!str1)
+        return false;
+    if (str2 instanceof RegExp) {
+        return str2.test(str1.toLowerCase());
+    }
+    if (typeof str2 === 'string') {
+        return str1.toLowerCase().includes(str2.toLowerCase());
+    }
+    return false;
 }
 function includesNodeModules(str) {
     if (!str)

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

@@ -18,14 +18,14 @@ type Url = {
     searchAll: Record<string, string[]>;
     /** The URL search parameterer string, e.g. `?details=yes` of `https://example.com/product/42?details=yes#reviews` */
     searchOriginal: null | string;
-    /** @deprecated */
-    searchString: null | string;
     /** The URL hash, e.g. `reviews` of `https://example.com/product/42?details=yes#reviews` */
     hash: string;
     /** The URL hash string, e.g. `#reviews` of `https://example.com/product/42?details=yes#reviews` */
     hashOriginal: null | string;
     /** @deprecated */
     hashString: null | string;
+    /** @deprecated */
+    searchString: null | string;
 };
 type PageContextUrlComputedPropsClient = {
     /** @deprecated */

package/dist/esm/utils/assertPathIsFilesystemAbsolute.js

@@ -6,10 +6,10 @@ import { assertPosixPath } from './filesystemPathHandling.js';
 function assertPathIsFilesystemAbsolute(p) {
     assertPosixPath(p);
     assert(!p.startsWith('/@fs/'));
-    if (process.platform === 'win32') {
-        assert(path.win32.isAbsolute(p));
+    if (process.platform !== 'win32') {
+        assert(p.startsWith('/'));
     }
     else {
-        assert(p.startsWith('/'));
+        assert(path.win32.isAbsolute(p));
     }
 }

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

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.167";
+declare const PROJECT_VERSION: "0.4.168";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.167";
+    projectVersion: "0.4.168";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-const PROJECT_VERSION = '0.4.167';
+const PROJECT_VERSION = '0.4.168';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.167",
+  "version": "0.4.168",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -16,7 +16,7 @@
     "@brillout/json-serializer": "^0.5.8",
     "@brillout/picocolors": "^1.0.10",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.4.4",
+    "@brillout/vite-plugin-server-entry": "^0.4.5",
     "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",