vike 0.4.227 → 0.4.228

package/dist/esm/node/plugin/plugins/build/pluginBuildEntry.js

@@ -2,16 +2,15 @@ export { pluginBuildEntry };
 export { set_macro_ASSETS_MANIFEST };
 import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
 import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { assert, PROJECT_VERSION, toPosixPath } from '../../utils.js';
+import { assert, PROJECT_VERSION, requireResolveNonUserFile } from '../../utils.js';
 import fs from 'fs/promises';
 import path from 'path';
-import { createRequire } from 'module';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
-const require_ = createRequire(importMetaUrl);
 import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
-import { assertBuildInfo, getViteConfigRuntime } from '../../../runtime/globalContext.js';
+import { assertBuildInfo } from '../../../runtime/globalContext.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
+import { getViteConfigRuntime } from '../../shared/getViteConfigRuntime.js';
 const ASSETS_MANIFEST = '__VITE_ASSETS_MANIFEST__';
 function pluginBuildEntry() {
     let config;
@@ -87,9 +86,8 @@ function find_ASSETS_MANIFEST(bundle) {
 }
 function getImportPath(config) {
     // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
-    const filePathAbsolute = toPosixPath(
     // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/pluginBuildEntry/index.js
-    require_.resolve(`../../../../../../dist/esm/__internal/index.js`));
+    const filePathAbsolute = requireResolveNonUserFile(`../../../../../../dist/esm/__internal/index.js`, importMetaUrl);
     if (
     // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
     true) {

package/dist/esm/node/plugin/plugins/build/pluginModuleBanner.js

@@ -1,10 +1,9 @@
 export { pluginModuleBanner };
-import { assert } from '../../utils.js';
+import MagicString from 'magic-string';
 import { removeVirtualIdTag } from '../../../shared/virtual-files.js';
-import { isViteServerBuild, isViteServerBuild_safe } from '../../shared/isViteServerBuild.js';
+import { isViteServerBuild_safe } from '../../shared/isViteServerBuild.js';
 // Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
 // But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
-const vikeModuleBannerPlaceholder = 'vikeModuleBannerPlaceholder';
 function pluginModuleBanner() {
     let config;
     return {
@@ -14,24 +13,6 @@ function pluginModuleBanner() {
         configResolved(config_) {
             config = config_;
         },
-        generateBundle: {
-            order: 'post',
-            handler(_options, bundle) {
-                for (const module of Object.values(bundle)) {
-                    if (module.type === 'chunk') {
-                        if (isViteServerBuild(config)) {
-                            const codeOld = module.code;
-                            const codeNew = codeOld.replace(/vikeModuleBannerPlaceholder\("([^"]*)"\);/g, '/* $1 [vike:pluginModuleBanner] */');
-                            assert(!codeNew.includes(vikeModuleBannerPlaceholder));
-                            module.code = codeNew;
-                        }
-                        else {
-                            assert(!module.code.includes(vikeModuleBannerPlaceholder));
-                        }
-                    }
-                }
-            }
-        },
         transform: {
             order: 'post',
             handler(code, id, options) {
@@ -42,7 +23,15 @@ function pluginModuleBanner() {
                 id = removeVirtualIdTag(id);
                 if (id.startsWith(config.root))
                     id = id.slice(config.root.length + 1);
-                return `${vikeModuleBannerPlaceholder}(${JSON.stringify(id)}); ${code}`;
+                const s = new MagicString(code);
+                // Use legal comment so that esbuild doesn't remove it.
+                // - Terser still removes the comment, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
+                // - https://esbuild.github.io/api/#legal-comments
+                s.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
+                return {
+                    code: s.toString(),
+                    map: s.generateMap({ hires: true, source: id })
+                };
             }
         }
     };

package/dist/esm/node/plugin/plugins/devConfig/determineFsAllowList.js

@@ -1,14 +1,13 @@
 export { determineFsAllowList };
 import { searchForWorkspaceRoot } from 'vite';
-import path from 'path';
-import { assert } from '../../utils.js';
-import { createRequire } from 'module';
-import { dirname } from 'path';
+import path from 'node:path';
+import { assert, assertPosixPath, requireResolveNonUserFile } from '../../utils.js';
 import { fileURLToPath } from 'url';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
-const require_ = createRequire(importMetaUrl);
-const __dirname_ = dirname(fileURLToPath(importMetaUrl));
+assertPosixPath(importMetaUrl);
+const __dirname_ = path.posix.dirname(fileURLToPath(importMetaUrl));
+assertPosixPath(__dirname_);
 async function determineFsAllowList(config) {
     const fsAllow = config.server.fs.allow;
     // fsAllow should already contain searchForWorkspaceRoot()
@@ -21,9 +20,9 @@ async function determineFsAllowList(config) {
     // Add node_modules/vike/
     {
         // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/config/
-        const vikeRoot = path.join(__dirname_, '../../../../../../');
+        const vikeRoot = path.posix.join(__dirname_, '../../../../../../');
         // Assert that `vikeRoot` is indeed pointing to `node_modules/vike/`
-        require_.resolve(`${vikeRoot}/dist/esm/node/plugin/plugins/devConfig/index.js`);
+        requireResolveNonUserFile(`${vikeRoot}/dist/esm/node/plugin/plugins/devConfig/index.js`, importMetaUrl);
         fsAllow.push(vikeRoot);
     }
 }

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

@@ -1,7 +1,7 @@
 export { envVarsPlugin };
+import MagicString from 'magic-string';
 import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, lowerFirst } from '../utils.js';
-import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
@@ -10,7 +10,7 @@ import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
 //   - Or stop using Vite's `mode` implemention and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
 const PUBLIC_ENV_PREFIX = 'PUBLIC_ENV__';
-const PUBLIC_ENV_WHITELIST = [
+const PUBLIC_ENV_ALLOWLIST = [
     // https://github.com/vikejs/vike/issues/1724
     'STORYBOOK'
 ];
@@ -38,6 +38,7 @@ function envVarsPlugin() {
                 return;
             const isBuild = config.command === 'build';
             const isClientSide = !isViteServerBuild_safe(config, options);
+            const s = new MagicString(code);
             Object.entries(envsAll)
                 .filter(([key]) => {
                 // Already handled by Vite
@@ -46,12 +47,12 @@ function envVarsPlugin() {
             })
                 .forEach(([envName, envVal]) => {
                 const envStatement = `import.meta.env.${envName}`;
-                const envStatementRegEx = new RegExp(escapeRegex(envStatement) + '\\b', 'g');
+                const envStatementRegExStr = escapeRegex(envStatement) + '\\b';
                 // Security check
                 {
-                    const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_WHITELIST.includes(envName);
+                    const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_ALLOWLIST.includes(envName);
                     if (isPrivate && isClientSide) {
-                        if (!envStatementRegEx.test(code))
+                        if (!new RegExp(envStatementRegExStr).test(code))
                             return;
                         const modulePath = getModuleFilePathAbsolute(id, config);
                         const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
@@ -70,16 +71,21 @@ function envVarsPlugin() {
                     assert(!(isPrivate && isClientSide) || !isBuild);
                 }
                 // Apply
-                code = applyEnvVar(envStatementRegEx, envVal, code);
+                applyEnvVar(s, envStatementRegExStr, envVal);
             });
-            // Line numbers didn't change.
-            //  - We only break the column number of a couple of lines, wich is acceptable.
-            //  - Anyways, I'm not even sure Vite supports high-resolution column number source mapping.
-            const ret = sourceMapPassthrough(code);
-            return ret;
+            if (!s.hasChanged())
+                return null;
+            return {
+                code: s.toString(),
+                map: s.generateMap({ hires: true, source: id })
+            };
         }
     };
 }
-function applyEnvVar(envStatementRegEx, envVal, code) {
-    return code.replace(envStatementRegEx, JSON.stringify(envVal));
+function applyEnvVar(s, envStatementRegExStr, envVal) {
+    const envStatementRegEx = new RegExp(envStatementRegExStr, 'g');
+    let match;
+    while ((match = envStatementRegEx.exec(s.original))) {
+        s.overwrite(match.index, match.index + match[0].length, JSON.stringify(envVal));
+    }
 }

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

@@ -6,12 +6,11 @@
 //  - This appraoch supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
 export { extractAssetsPlugin };
 export { extractAssetsRE };
-import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage } from '../utils.js';
+import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage, rollupSourceMapRemove } from '../utils.js';
 import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtual-files.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
-import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import pc from '@brillout/picocolors';
 import { handleAssetsManifest_isFixEnabled } from './build/handleAssetsManifest.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
@@ -51,7 +50,7 @@ function extractAssetsPlugin() {
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
                 debugTransformResult(id, code, importStatements);
-                return sourceMapRemove(code);
+                return rollupSourceMapRemove(code);
             }
         },
         // This plugin appends `?extractAssets` to module IDs

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

@@ -1,9 +1,8 @@
 export { extractExportNamesPlugin };
 export { isUsingClientRouter };
 export { extractExportNamesRE };
-import { assert, getFileExtension, createDebugger, getGlobalObject, assertUsage } from '../utils.js';
+import { assert, getFileExtension, createDebugger, getGlobalObject, assertUsage, rollupSourceMapRemove } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
-import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerBuild_options } from '../shared/isViteServerBuild.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
@@ -39,7 +38,7 @@ async function getExtractExportNamesCode(src, isClientSide, isProduction, id) {
         globalObject.usesClientRouter = true;
     }
     const code = getCode(exportNames, wildcardReExports, isClientSide, isProduction, id);
-    return sourceMapRemove(code);
+    return rollupSourceMapRemove(code);
 }
 function getCode(exportNames, wildcardReExports, isClientSide, isProduction, id) {
     let code = '';

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

@@ -1,10 +1,9 @@
 export { fileEnv };
-import { assert, assertUsage, assertWarning, capitalizeFirstLetter, joinEnglish } from '../utils.js';
+import { assert, assertUsage, assertWarning, capitalizeFirstLetter, joinEnglish, rollupSourceMapRemove } from '../utils.js';
 import { extractAssetsRE } from './extractAssetsPlugin.js';
 import { extractExportNamesRE } from './extractExportNamesPlugin.js';
 import pc from '@brillout/picocolors';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
-import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
@@ -49,7 +48,7 @@ function fileEnv() {
             const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
             // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
             const { exportNames } = await getExportNames(code);
-            return sourceMapRemove([
+            return rollupSourceMapRemove([
                 `throw new Error(${JSON.stringify(errMsg)});`,
                 ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`)
             ].join('\n'));

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

@@ -1,7 +1,7 @@
 export { resolvePointerImport };
 export { resolvePointerImportData };
 import pc from '@brillout/picocolors';
-import { assert, assertPosixPath, assertUsage, isFilePathAbsolute, pathIsRelative, requireResolve } from '../../../../utils.js';
+import { assert, assertPosixPath, assertUsage, isFilePathAbsolute, pathIsRelative, requireResolveOptional } from '../../../../utils.js';
 import { parsePointerImportData } from './transformPointerImports.js';
 import path from 'path';
 import { getFilePathAbsoluteUserRootDir, getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
@@ -72,10 +72,8 @@ function resolveImportPathWithNode(pointerImportData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     assertPosixPath(importerFilePathAbsolute);
     const cwd = path.posix.dirname(importerFilePathAbsolute);
-    // We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
-    // - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
     // filePathAbsoluteFilesystem is expected to be null when pointerImportData.importPath is a Vite path alias
-    const filePathAbsoluteFilesystem = requireResolve(pointerImportData.importPath, cwd);
+    const filePathAbsoluteFilesystem = requireResolveOptional(pointerImportData.importPath, cwd);
     return filePathAbsoluteFilesystem;
 }
 function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath) {

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

@@ -7,14 +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, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport, genPromise, isVitest } from '../../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport, genPromise, isVitest, requireResolveOptional, isNpmPackageImport_unreliable } from '../../../../utils.js';
 import { transformPointerImports } from './transformPointerImports.js';
 import sourceMapSupport from 'source-map-support';
 import { getFilePathAbsoluteUserRootDir } from '../../../../shared/getFilePath.js';
-import { createRequire } from 'module';
-// @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
-const importMetaUrl = import.meta.url;
-const require_ = createRequire(importMetaUrl);
 assertIsNotProductionRuntime();
 installSourceMapSupport();
 const debug = createDebugger('vike:pointer-imports');
@@ -110,8 +106,6 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                 build.onResolve({ filter: /.*/ }, async (args) => {
                     if (args.kind !== 'import-statement')
                         return;
-                    if (debugEsbuildResolve.isActivated)
-                        debugEsbuildResolve('args', args);
                     // Avoid infinite loop: https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
                     const useEsbuildResolver = 'useEsbuildResolver';
                     if (args.pluginData?.[useEsbuildResolver])
@@ -119,17 +113,15 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     const { path, ...opts } = args;
                     opts.pluginData = { [useEsbuildResolver]: true };
                     let resolved = await build.resolve(path, opts);
+                    if (debugEsbuildResolve.isActivated)
+                        debugEsbuildResolve('args', args);
                     if (debugEsbuildResolve.isActivated)
                         debugEsbuildResolve('resolved', resolved);
                     // Temporary workaround for https://github.com/evanw/esbuild/issues/3973
                     // - Sitll required for esbuild@0.24.0 (November 2024).
                     // - Let's try to remove this workaround again later.
                     if (resolved.errors.length > 0) {
-                        let resolvedWithNode;
-                        try {
-                            resolvedWithNode = require_.resolve(path, { paths: [args.resolveDir] });
-                        }
-                        catch { }
+                        const resolvedWithNode = requireResolveOptional(path, args.resolveDir);
                         if (debugEsbuildResolve.isActivated)
                             debugEsbuildResolve('resolvedWithNode', resolvedWithNode);
                         if (resolvedWithNode)
@@ -163,11 +155,25 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         //      - vike@0.4.162 started soft-requiring Vike extensions to set the name config.
                         //    - In practice, it seems like it requires some (non-trivial?) refactoring.
                         isVikeExtensionImport;
-                    // Externalize npm package imports
                     assertPosixPath(importPathResolved);
-                    const isNpmPkgImport = importPathResolved.includes('/node_modules/') ||
+                    // `isNpmPkgImport` => `importPathOriginal` is most likely an npm package import, but it can also be a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir`.
+                    const isNpmPkgImport = (() => {
+                        if (importPathResolved.includes('/node_modules/')) {
+                            // So far I can't think of a use case where this assertion would fail, but let's eventually remove it to avoid artificially restricting the user.
+                            assert(isNpmPackageImport_unreliable(importPathOriginal));
+                            return true;
+                        }
                         // Linked npm packages
-                        !importPathResolved.startsWith(userRootDir);
+                        if (
+                        // Assuming path aliases usually resolve inside `userRootDir`.
+                        // - This isn't always the case: https://github.com/vikejs/vike/issues/2326
+                        !importPathResolved.startsWith(userRootDir) &&
+                            // False positive if `importPathOriginal` is a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir` => we then we wrongfully assume that `importPathOriginal` is an npm package import.
+                            isNpmPackageImport_unreliable(importPathOriginal)) {
+                            return true;
+                        }
+                        return false;
+                    })();
                     const isExternal = isPointerImport ||
                         // Performance: npm package imports can be externalized. (We could as well let esbuild transpile /node_modules/ code but it's useless as /node_modules/ code is already built. It would unnecessarily slow down transpilation.)
                         isNpmPkgImport;
@@ -191,19 +197,19 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                             filePathAbsoluteFilesystem: importPathResolved,
                             userRootDir
                         });
-                        // We assuming that path aliases always resolve inside `userRootDir`.
                         if (filePathAbsoluteUserRootDir && !isNpmPkgImport) {
-                            // `importPathOriginal` is a path alias.
+                            // `importPathOriginal` is most likely a path alias.
                             // - We have to use esbuild's path alias resolution, because:
                             //   - Vike doesn't resolve path aliases at all.
                             //   - Node.js doesn't support `tsconfig.js#compilerOptions.paths`.
-                            // - Esbuild path alias resolution seems to be reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
+                            // - Esbuild path alias resolution seems reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
+                            assert(!isNpmPackageImport_unreliable(importPathOriginal));
                             importPathTranspiled = importPathResolved;
                         }
                         else {
-                            // `importPathOriginal` is an npm package import.
+                            // `importPathOriginal` is most likely an npm package import.
                             assertIsNpmPackageImport(importPathOriginal);
-                            // For less confusing error messages, let the resolution be handled by Vike or Node.js.
+                            // For improved error messages, let the resolution be handled by Vike or Node.js.
                             importPathTranspiled = importPathOriginal;
                         }
                     }

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

@@ -896,7 +896,7 @@ function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitio
     if (configNamesKnownAll.includes(configName)) {
         assertUsage(false, `${sourceName} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`, { exitOnError });
     }
-    const errMsg = `${sourceName} sets an unknown config ${configNameColored}`;
+    const errMsg = `${sourceName} sets an unknown Vike config, see ${pc.underline('https://vike.dev/cli')} for the list of CLI options.`;
     // Missing vike-{react,vue,solid} installation
     {
         const ui = ['vike-react', 'vike-vue', 'vike-solid'];

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

@@ -1,8 +1,8 @@
 export { setGlobalContext };
 import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProduction } from '../../runtime/globalContext.js';
-import { assert, assertFilePathAbsoluteFilesystem, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
-import { getOutDirs } from '../shared/getOutDirs.js';
+import { assert, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
 import { reloadVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
 function setGlobalContext() {
     let isServerReload = false;
     let config;
@@ -41,9 +41,8 @@ function setGlobalContext() {
                 order: 'post',
                 async handler(config_) {
                     config = config_;
-                    const { outDirRoot } = getOutDirs(config);
-                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for `importServerProductionEntry({ outDir })` of @brillout/vite-plugin-server-entry
-                    setGlobalContext_viteConfig(config, outDirRoot);
+                    const viteConfigRuntime = getViteConfigRuntime(config);
+                    setGlobalContext_viteConfig(config, viteConfigRuntime);
                 }
             }
         }

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

@@ -0,0 +1,14 @@
+export { getViteConfigRuntime };
+export type { ViteConfigRuntime };
+import type { ResolvedConfig } from 'vite';
+type ViteConfigRuntime = ReturnType<typeof getViteConfigRuntime>;
+declare function getViteConfigRuntime(config: ResolvedConfig): {
+    root: string;
+    build: {
+        outDir: string;
+    };
+    _baseViteOriginal: string;
+    vitePluginServerEntry: {
+        inject: boolean | undefined;
+    };
+};

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

@@ -0,0 +1,19 @@
+export { getViteConfigRuntime };
+import { assert, assertFilePathAbsoluteFilesystem, hasProp } from '../utils.js';
+import { getOutDirs } from './getOutDirs.js';
+function getViteConfigRuntime(config) {
+    assert(hasProp(config, '_baseViteOriginal', 'string'));
+    const { outDirRoot } = getOutDirs(config);
+    assertFilePathAbsoluteFilesystem(outDirRoot);
+    const viteConfigRuntime = {
+        root: config.root,
+        build: {
+            outDir: outDirRoot
+        },
+        _baseViteOriginal: config._baseViteOriginal,
+        vitePluginServerEntry: {
+            inject: config.vitePluginServerEntry?.inject
+        }
+    };
+    return viteConfigRuntime;
+}

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

@@ -1,9 +1,7 @@
 export { resolveClientEntriesDev };
-import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsNpmPackageImport, assertIsNotProductionRuntime } from '../utils.js';
-import { createRequire } from 'module';
+import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsNpmPackageImport, assertIsNotProductionRuntime, requireResolveOptionalNonUserFile, requireResolve } from '../utils.js';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
-const require_ = createRequire(importMetaUrl);
 assertIsNotProductionRuntime();
 async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     let root = viteDevServer.config.root;
@@ -27,20 +25,21 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     else {
         if (clientEntry.startsWith('@@vike/')) {
             assert(clientEntry.endsWith('.js'));
-            try {
-                // For Vitest (which doesn't resolve vike to its dist but to its source files)
-                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/plugin/shared/resolveClientEntriesDev.js
-                filePath = toPosixPath(require_.resolve(clientEntry.replace('@@vike/dist/esm/client/', '../../../client/').replace('.js', '.ts')));
-            }
-            catch {
+            let filePath_;
+            // For Vitest (which doesn't resolve vike to its dist but to its source files)
+            // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/plugin/shared/resolveClientEntriesDev.js
+            filePath_ = requireResolveOptionalNonUserFile(clientEntry.replace('@@vike/dist/esm/client/', '../../../client/').replace('.js', '.ts'), importMetaUrl);
+            if (!filePath_) {
                 // For users
                 // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/shared/resolveClientEntriesDev.js
-                filePath = toPosixPath(require_.resolve(clientEntry.replace('@@vike/dist/esm/client/', '../../../../../dist/esm/client/')));
+                filePath_ = requireResolveOptionalNonUserFile(clientEntry.replace('@@vike/dist/esm/client/', '../../../../../dist/esm/client/'), importMetaUrl);
             }
+            assert(filePath_);
+            filePath = filePath_;
         }
         else {
             assertIsNpmPackageImport(clientEntry);
-            filePath = require_.resolve(clientEntry);
+            filePath = requireResolve(clientEntry, root);
         }
     }
     if (!filePath.startsWith('/')) {

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

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

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

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

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

@@ -4,7 +4,7 @@ import { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/get
 import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
 declare function resolvePrerenderConfigGlobal(vikeConfig: VikeConfigObject): {
     partial: boolean;
-    noExtraDir: boolean;
+    noExtraDir: boolean | null;
     keepDistServer: boolean;
     parallel: number | boolean;
     disableAutoRun: boolean;

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

@@ -9,7 +9,7 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
     const prerenderSettings = prerenderConfigs.filter(isObject2);
     const prerenderConfigGlobal = {
         partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
-        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? null,
         keepDistServer: pickFirst(prerenderSettings.map((c) => c.keepDistServer)) ?? false,
         parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
         disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false

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

@@ -14,6 +14,7 @@ type ProvidedByHook = null | {
 type PageContextPrerendered = {
     urlOriginal: string;
     _providedByHook?: ProvidedByHook;
+    pageId: string;
 };
 type Output<PageContext = PageContextPrerendered> = {
     filePath: string;