vike 0.4.266-commit-f1b186a → 0.4.267-commit-b005535

package/dist/node/vite/assertEnvVite.js

@@ -12,7 +12,7 @@ function assertEnvVite() {
     assertIsNotBrowser();
     assertNodeVersion();
     assertViteVersion(viteVersion);
-    assertIsNotProductionRuntime(); // Don't bloat server with heavy dependencies like Vite and esbuild
+    assertIsNotProductionRuntime(); // Don't bloat server with heavy dependencies like Vite
 }
 function onLoad() {
     installUncaughtErrorHandlers();

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

@@ -4,7 +4,7 @@ export type { PlusFileValue };
 export type { PlusFile };
 export type { PlusFilesByLocationId };
 import { type LocationId } from './filesystemRouting.js';
-import { type EsbuildCache } from './transpileAndExecuteFile.js';
+import { type VikeTranspileCache } from './transpileAndExecuteFile.js';
 import { type ConfigFile, PointerImportLoaded } from './loadFileAtConfigTime.js';
 import type { FilePathResolved } from '../../../../types/FilePath.js';
 import '../../assertEnvVite.js';
@@ -40,5 +40,5 @@ type PlusFileValue = PlusFileCommon & {
     isExtensionConfig?: undefined;
 };
 type PlusFilesByLocationId = Record<LocationId, PlusFile[]>;
-declare function getPlusFiles(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;
+declare function getPlusFiles(userRootDir: string, vikeTranspileCache: VikeTranspileCache): Promise<PlusFilesByLocationId>;
 declare function getPlusFileFromConfigFile(configFile: ConfigFile, isExtensionConfig: boolean, locationId: LocationId, userRootDir: string): PlusFileConfig;

package/dist/node/vite/shared/resolveVikeConfigInternal/getPlusFiles.js

@@ -10,7 +10,7 @@ import { resolvePointerImport } from './resolvePointerImport.js';
 import { getFilePathResolved } from '../getFilePath.js';
 import { assertExtensionsConventions, assertExtensionsRequire } from './assertExtensions.js';
 import '../../assertEnvVite.js';
-async function getPlusFiles(userRootDir, esbuildCache) {
+async function getPlusFiles(userRootDir, vikeTranspileCache) {
     const plusFilePaths = (await crawlPlusFiles(userRootDir)).map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     const plusFilesByLocationId = {};
     await Promise.all(plusFilePaths.map(async (filePath) => {
@@ -18,7 +18,7 @@ async function getPlusFiles(userRootDir, esbuildCache) {
             // +config.js files
             const { filePathAbsoluteUserRootDir } = filePath;
             assert(filePathAbsoluteUserRootDir);
-            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false, esbuildCache);
+            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false, vikeTranspileCache);
             assert(filePath.filePathAbsoluteUserRootDir);
             const locationId = getLocationId(filePathAbsoluteUserRootDir);
             const plusFile = getPlusFileFromConfigFile(configFile, false, locationId, userRootDir);
@@ -65,7 +65,7 @@ async function getPlusFiles(userRootDir, esbuildCache) {
             // We don't have access to the custom config definitions defined by the user yet.
             //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
             //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
-            await loadValueFile(plusFile, metaBuiltIn, userRootDir, esbuildCache);
+            await loadValueFile(plusFile, metaBuiltIn, userRootDir, vikeTranspileCache);
         }
     }));
     // Make lists element order deterministic

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

@@ -4,7 +4,7 @@ export { loadConfigFile };
 export type { ConfigFile };
 export type { PointerImportLoaded };
 import type { FilePathResolved } from '../../../../types/FilePath.js';
-import { type EsbuildCache } from './transpileAndExecuteFile.js';
+import { type VikeTranspileCache } from './transpileAndExecuteFile.js';
 import type { PlusFileValue } from './getPlusFiles.js';
 import { PointerImport } from './resolvePointerImport.js';
 import type { ConfigDefinitionsInternal } from './metaBuiltIn.js';
@@ -14,15 +14,15 @@ type ConfigFile = {
     filePath: FilePathResolved;
     extendsFilePaths: string[];
 };
-declare function loadPointerImport(pointerImport: PointerImportLoaded, userRootDir: string, configName: string, configDefinitions: ConfigDefinitionsInternal, esbuildCache: EsbuildCache): Promise<unknown>;
+declare function loadPointerImport(pointerImport: PointerImportLoaded, userRootDir: string, configName: string, configDefinitions: ConfigDefinitionsInternal, vikeTranspileCache: VikeTranspileCache): Promise<unknown>;
 type PointerImportLoaded = PointerImport & ({
     fileExportValueLoaded: true;
     fileExportValue: unknown;
 } | {
     fileExportValueLoaded: false;
 });
-declare function loadValueFile(interfaceValueFile: PlusFileValue, configDefinitions: ConfigDefinitionsInternal, userRootDir: string, esbuildCache: EsbuildCache): Promise<void>;
-declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isExtensionConfig: boolean, esbuildCache: EsbuildCache): Promise<{
+declare function loadValueFile(interfaceValueFile: PlusFileValue, configDefinitions: ConfigDefinitionsInternal, userRootDir: string, vikeTranspileCache: VikeTranspileCache): Promise<void>;
+declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isExtensionConfig: boolean, vikeTranspileCache: VikeTranspileCache): Promise<{
     configFile: ConfigFile;
     extendsConfigs: ConfigFile[];
 }>;

package/dist/node/vite/shared/resolveVikeConfigInternal/loadFileAtConfigTime.js

@@ -17,7 +17,7 @@ import { getConfigDefinedAt } from '../../../../shared-server-client/page-config
 import '../../assertEnvVite.js';
 assertIsNotProductionRuntime();
 // Load pointer import
-async function loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache) {
+async function loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, vikeTranspileCache) {
     // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
     if (configName === 'extends')
         return;
@@ -27,14 +27,14 @@ async function loadPointerImport(pointerImport, userRootDir, configName, configD
         return;
     const configDefinedAt = getConfigDefinedAt('Config', configName, pointerImport.fileExportPath);
     assertUsage(pointerImport.fileExportPath.filePathAbsoluteFilesystem, `${configDefinedAt} cannot be defined over an aliased import`);
-    const { fileExports } = await transpileAndExecuteFile(pointerImport.fileExportPath, userRootDir, false, esbuildCache);
+    const { fileExports } = await transpileAndExecuteFile(pointerImport.fileExportPath, userRootDir, false, vikeTranspileCache);
     const fileExportValue = fileExports[pointerImport.fileExportPath.fileExportName];
     pointerImport.fileExportValueLoaded = true;
     assert(pointerImport.fileExportValueLoaded);
     pointerImport.fileExportValue = fileExportValue;
 }
 // Load +{configName}.js
-async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir, esbuildCache) {
+async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir, vikeTranspileCache) {
     const { configName } = interfaceValueFile;
     const configDef = getConfigDefinitionOptional(configDefinitions, configName);
     // Only load value files with `env.config===true`
@@ -43,7 +43,7 @@ async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir,
     interfaceValueFile.isNotLoaded = false;
     assert(!interfaceValueFile.isNotLoaded);
     interfaceValueFile.fileExportsByConfigName = {};
-    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false, esbuildCache);
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false, vikeTranspileCache);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     assertPlusFileExport(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
@@ -52,11 +52,11 @@ async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir,
     });
 }
 // Load +config.js, including all its extends pointer imports
-async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig, esbuildCache) {
+async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig, vikeTranspileCache) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig, esbuildCache);
-    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [...visited, filePathAbsoluteFilesystem], esbuildCache);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig, vikeTranspileCache);
+    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [...visited, filePathAbsoluteFilesystem], vikeTranspileCache);
     const configFile = {
         fileExports,
         filePath: configFilePath,
@@ -72,7 +72,7 @@ function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
     assert(loop[0] === filePathAbsoluteFilesystem);
     assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
 }
-async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited, esbuildCache) {
+async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited, vikeTranspileCache) {
     const { extendsPointerImportData, extendsConfigs } = getExtendsPointerImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsPointerImportData.map((pointerImportData) => {
@@ -80,7 +80,7 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         assert(filePath.filePathAbsoluteFilesystem);
         extendsConfigFiles.push(filePath);
     });
-    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true, esbuildCache)));
+    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true, vikeTranspileCache)));
     results.forEach((result) => {
         extendsConfigs.push(result.configFile);
         extendsConfigs.push(...result.extendsConfigs);

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

@@ -1,9 +1,11 @@
 export { transformPointerImports };
 export { parsePointerImportData };
 export { assertPointerImportPath };
+export { pointerImportAttributeSuffix };
 export type { PointerImportData };
 import '../../assertEnvVite.js';
-declare function transformPointerImports(code: string, filePathToShowToUser2: string, pointerImports: Record<string, boolean> | 'all', skipWarnings?: true): string | null;
+declare const pointerImportAttributeSuffix = "?vike:pointer";
+declare function transformPointerImports(code: string, pointerImports: Record<string, boolean> | 'all'): string | null;
 /**
  * Data Structure for [pointer imports](https://vike.dev/config#pointer-imports):
  *   `import { someExport as someImport } from './some-file'`

package/dist/node/vite/shared/resolveVikeConfigInternal/pointerImports.js

@@ -1,6 +1,7 @@
 export { transformPointerImports };
 export { parsePointerImportData };
 export { assertPointerImportPath };
+export { pointerImportAttributeSuffix };
 // Playground: https://github.com/brillout/acorn-playground
 // Notes about `with { type: 'pointer' }`
 // - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
@@ -10,24 +11,23 @@ export { assertPointerImportPath };
 //   - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
 // - Using a import path suffix such as `import { Layout } from './Layout?real` breaks TypeScript, and TypeScript isn't working on supporting query params: https://github.com/microsoft/TypeScript/issues/10988#issuecomment-867135453
 // - Node.js >=21 supports import attributes: https://nodejs.org/api/esm.html#import-attributes
-// - Esbuid supports
-//   - Blocker: https://github.com/evanw/esbuild/issues/3646
-//     - Ugly hack to make it work: https://github.com/brillout/esbuild-playground/tree/experiment/import-attribute
-//   - Discussion with esbuild maintainer: https://github.com/evanw/esbuild/issues/3384
+// - Rolldown doesn't pass import attributes to plugins => we parse import attributes ourselves and mark the import path with pointerImportAttributeSuffix, see transpileFile()
 // - Using a magic comment `// @vike-real-import` is probably a bad idea:
-//   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
+//   - Bundlers usually remove comments, e.g. esbuild: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
 //   - Using source maps to track these magic comments is brittle (source maps can easily break)
 import { parseSync } from '@babel/core';
-import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
+import { assert, assertUsage } from '../../../../utils/assert.js';
 import { isFilePathAbsolute } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
 import { isImportPath } from '../../../../utils/isImportPath.js';
-import { styleFileRE } from '../../../../utils/styleFileRE.js';
 import pc from '@brillout/picocolors';
 import { parseImportString, isImportString, serializeImportString } from '../importString.js';
 import '../../assertEnvVite.js';
-function transformPointerImports(code, filePathToShowToUser2, pointerImports, 
-// For ./transformPointerImports.spec.ts
-skipWarnings) {
+// Appended to the import path of imports with the import attribute `with { type: 'vike:pointer' }`, see transpileFile()
+const pointerImportAttributeSuffix = '?vike:pointer';
+function removePointerImportAttributeSuffix(str) {
+    return str.split(pointerImportAttributeSuffix).join('');
+}
+function transformPointerImports(code, pointerImports) {
     const spliceOperations = [];
     // Collect all const declarations to prepend at the top, so that they are
     // available before any code runs (import declarations are hoisted but const
@@ -53,34 +53,8 @@ skipWarnings) {
         }
         const { start, end } = node;
         const importStatementCode = code.slice(start, end);
-        /* Pointer import without importing any value => doesn't make sense and doesn't have any effect.
-        ```js
-        // Useless
-        import './some.css'
-        // Useless
-        import './Layout.jsx'
-        ``` */
-        if (node.specifiers.length === 0) {
-            const isWarning = !styleFileRE.test(importPath);
-            let quote = indent(importStatementCode);
-            if (isWarning) {
-                quote = pc.cyan(quote);
-            }
-            else {
-                quote = pc.bold(pc.red(quote));
-            }
-            const errMsg = [
-                `The following import in ${filePathToShowToUser2} has no effect:`,
-                quote,
-                'See https://vike.dev/config#pointer-imports',
-            ].join('\n');
-            if (!skipWarnings) {
-                if (!isWarning) {
-                    assertUsage(false, errMsg);
-                }
-                assertWarning(false, errMsg, { onlyOnce: true });
-            }
-        }
+        // Pointer import without importing any value, e.g. `import './some.css'` => we remove it (it doesn't have any effect).
+        // - Rolldown transforms unused imports `import { unused } from './some.js'` into `import './some.js'`
         let constDeclaration = '';
         node.specifiers.forEach((specifier) => {
             assert(specifier.type === 'ImportSpecifier' ||
@@ -99,7 +73,11 @@ skipWarnings) {
                 }
                 return importLocalName;
             })();
-            const importString = serializePointerImportData({ importPath, exportName, importStringWasGenerated: true });
+            const importString = serializePointerImportData({
+                importPath: removePointerImportAttributeSuffix(importPath),
+                exportName,
+                importStringWasGenerated: true,
+            });
             constDeclaration += `const ${importLocalName} = '${importString}';`;
         });
         if (constDeclaration)
@@ -162,7 +140,7 @@ function parsePointerImportData(importString) {
 // `importPath` is one of the following:
 // - A relative import path
 // - An npm package import
-// - A filesystem absolute path, see transpileWithEsbuild()
+// - A filesystem absolute path, see transpileFile()
 function assertPointerImportPath(importPath) {
     return isImportPath(importPath) || isFilePathAbsolute(importPath);
 }
@@ -189,9 +167,3 @@ function spliceMany(str, operations) {
     strMod += str.slice(endPrev, str.length);
     return strMod;
 }
-function indent(str) {
-    return str
-        .split('\n')
-        .map((s) => `  ${s}`)
-        .join('\n');
-}

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

@@ -2,18 +2,18 @@ export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
 export { isTemporaryBuildFile };
-export type { EsbuildCache };
+export type { VikeTranspileCache };
 import type { FilePathResolved } from '../../../../types/FilePath.js';
 import '../../assertEnvVite.js';
 type FileExports = {
     fileExports: Record<string, unknown>;
 };
-type EsbuildCache = {
+type VikeTranspileCache = {
     transpileCache: Record<string, // filePathAbsoluteFilesystem
     Promise<FileExports>>;
     vikeConfigDependencies: Set<string>;
 };
-declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isExtensionConfig: boolean, esbuildCache: EsbuildCache): Promise<FileExports>;
+declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isExtensionConfig: boolean, vikeTranspileCache: VikeTranspileCache): Promise<FileExports>;
 declare function getConfigBuildErrorFormatted(err: unknown): `Failed to transpile ${string} because:
 ${string}` | null;
 declare function getConfigExecutionErrorIntroMsg(err: unknown): `Failed to execute ${string} because:` | null;

package/dist/node/vite/shared/resolveVikeConfigInternal/transpileAndExecuteFile.js

@@ -2,13 +2,15 @@ export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
 export { isTemporaryBuildFile };
-import { build, formatMessages, version, } from 'esbuild';
+import { rolldown, VERSION, } from 'rolldown';
+import { parseAst } from 'rolldown/parseAst';
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
 import { assert, assertWarning } from '../../../../utils/assert.js';
+import { nodeVersionMin } from '../../../../utils/assertNodeVersion.js';
 import { assertIsNotProductionRuntime } from '../../../../utils/assertSetup.js';
 import { createDebug } from '../../../../utils/debug.js';
 import { genPromise } from '../../../../utils/genPromise.js';
@@ -19,27 +21,27 @@ import { isPlainJavaScriptFile, isPlainScriptFile } from '../../../../utils/isSc
 import { isVitest } from '../../../../utils/isVitest.js';
 import { assertImportIsNpmPackage, isImportNpmPackageOrPathAlias } from '../../../../utils/parseNpmPackage.js';
 import { assertPosixPath, toPosixPath } from '../../../../utils/path.js';
-import { requireResolveOptionalDir } from '../../../../utils/requireResolve.js';
-import { transformPointerImports } from './pointerImports.js';
+import { pointerImportAttributeSuffix, transformPointerImports } from './pointerImports.js';
 import sourceMapSupport from 'source-map-support';
 import { getFilePathAbsoluteUserRootDir } from '../getFilePath.js';
+import { getMagicString } from '../getMagicString.js';
 import '../../assertEnvVite.js';
 assertIsNotProductionRuntime();
 installSourceMapSupport();
 const debug = createDebug('vike:pointer-imports');
-const debugEsbuildResolve = createDebug('vike:esbuild-resolve');
+const debugResolve = createDebug('vike:transpile-resolve');
 const debugConfig = createDebug('vike:config');
-if (debugEsbuildResolve.isActivated)
-    debugEsbuildResolve('esbuild version', version);
-async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig, esbuildCache) {
+if (debugResolve.isActivated)
+    debugResolve('rolldown version', VERSION);
+async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig, vikeTranspileCache) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     assert(filePathAbsoluteFilesystem);
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
-    if (esbuildCache.transpileCache[filePathAbsoluteFilesystem]) {
-        return await esbuildCache.transpileCache[filePathAbsoluteFilesystem];
+    if (vikeTranspileCache.transpileCache[filePathAbsoluteFilesystem]) {
+        return await vikeTranspileCache.transpileCache[filePathAbsoluteFilesystem];
     }
     const { promise, resolve } = genPromise();
-    esbuildCache.transpileCache[filePathAbsoluteFilesystem] = promise;
+    vikeTranspileCache.transpileCache[filePathAbsoluteFilesystem] = promise;
     /* We tolerate .tsx so that a file can be both a runtime and config file (`meta.env.config === true && meta.env.server === true`), e.g. https://github.com/brillout/docpress/issues/86
     assertUsage(
       isPlainScriptFile(filePathAbsoluteFilesystem),
@@ -52,15 +54,15 @@ async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig,
     }
     let fileExports;
     if (isExtensionConfig && !isHeader && fileExtension.endsWith('js')) {
-        // This doesn't track dependencies => we should never use this for user land configs
         if (debugConfig.isActivated) {
-            debugConfig(filePathToShowToUserResolved, 'executed directly (no esbuild transpilation)');
+            debugConfig(filePathToShowToUserResolved, 'executed directly (no transpilation)');
         }
+        // This doesn't track dependencies => we should never use this for user land configs
         fileExports = await executeFile(filePathAbsoluteFilesystem, filePath);
     }
     else {
         const transformImports = isHeader ? 'all' : true;
-        const code = await transpileFile(filePath, transformImports, userRootDir, esbuildCache);
+        const code = await transpileFileAndTransformPointerImports(filePath, transformImports, userRootDir, vikeTranspileCache);
         if (debugConfig.isActivated) {
             debugConfig(filePathToShowToUserResolved, code);
         }
@@ -69,19 +71,19 @@ async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig,
     resolve({ fileExports });
     return { fileExports };
 }
-async function transpileFile(filePath, transformImports, userRootDir, esbuildCache) {
+async function transpileFileAndTransformPointerImports(filePath, transformImports, userRootDir, vikeTranspileCache) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     assert(filePathAbsoluteFilesystem);
     assertPosixPath(filePathAbsoluteFilesystem);
-    esbuildCache.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+    vikeTranspileCache.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     if (debug.isActivated)
         debug('transpile', filePathToShowToUserResolved);
-    let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports, esbuildCache);
+    let { code, pointerImports } = await transpileFile(filePath, userRootDir, transformImports, vikeTranspileCache);
     if (debug.isActivated)
-        debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
+        debug(`code, post transpilation (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
     if (transformImports) {
-        const codeMod = transformPointerImports(code, filePathToShowToUserResolved, pointerImports);
+        const codeMod = transformPointerImports(code, pointerImports);
         if (codeMod) {
             code = codeMod;
             isImportTransformed = true;
@@ -95,200 +97,316 @@ async function transpileFile(filePath, transformImports, userRootDir, esbuildCac
     }
     return code;
 }
-async function transpileWithEsbuild(filePath, userRootDir, transformImports, esbuildCache) {
+async function transpileFile(filePath, userRootDir, transformImports, vikeTranspileCache) {
     const entryFilePath = filePath.filePathAbsoluteFilesystem;
     const entryFileDir = path.posix.dirname(entryFilePath);
-    const options = {
-        platform: 'node',
-        entryPoints: [entryFilePath],
-        sourcemap: 'inline',
-        write: false,
-        target: ['node14.18', 'node16'],
-        outfile: path.posix.join(
-        // Needed for correct inline source map
-        entryFileDir, 
-        // `write: false` => no file is actually emitted
-        'NEVER_EMITTED.js'),
-        logLevel: 'silent',
-        format: 'esm',
-        absWorkingDir: userRootDir,
-        // Disable tree-shaking to avoid dead-code elimination, so that unused imports aren't removed.
-        // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
-        treeShaking: false,
-        minify: false,
-        metafile: true,
-        bundle: true,
-    };
     const pointerImports = {};
-    options.plugins = [
+    const unresolvedImports = [];
+    const 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';
-                    if (args.pluginData?.[useEsbuildResolver])
-                        return;
-                    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
-                    // - Still required for esbuild@0.24.0 (November 2024).
-                    // - Let's try to remove this workaround again later.
-                    if (resolved.errors.length > 0) {
-                        const resolvedWithNode = requireResolveOptionalDir({
-                            importPath: path,
-                            importerDir: toPosixPath(args.resolveDir),
-                            userRootDir,
-                        });
-                        if (debugEsbuildResolve.isActivated)
-                            debugEsbuildResolve('resolvedWithNode', resolvedWithNode);
-                        if (resolvedWithNode)
-                            resolved = { path: resolvedWithNode };
-                    }
-                    if (resolved.errors && 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 whereas esbuild refers to the source +config.ts file.
-                        pointerImports[args.path] = false
-                        return { external: true }
-                        */
-                        // Let esbuild throw the error
-                        cleanEsbuildErrors(resolved.errors);
-                        return resolved;
-                    }
-                    assert(resolved.path);
-                    // Built-in modules e.g. node:fs
-                    if (resolved.path === args.path) {
-                        const isPointerImport = false;
-                        pointerImports[args.path] = isPointerImport;
-                        if (debug.isActivated)
-                            debug('onResolve() [built-in module]', { args, resolved });
-                        assert(resolved.external);
-                        return resolved;
-                    }
-                    const importPathResolved = toPosixPath(resolved.path);
-                    const importPathOriginal = args.path;
-                    // Esbuild resolves path aliases.
-                    // - Enabling us to use:
-                    //   - assertImportIsNpmPackage()
-                    //   - isImportNpmPackage(str, { cannotBePathAlias: true })
-                    assertFilePathAbsoluteFilesystem(importPathResolved);
-                    //  Should we remove this? See comment below.
-                    const isVikeExtensionImport = (path.startsWith('vike-') && path.endsWith('/config')) || importPathResolved.endsWith('+config.js');
-                    const isPointerImport = transformImports === 'all' ||
-                        // .jsx, .vue, .svg, ... => obviously not config code => pointer import
-                        !isPlainScriptFile(importPathResolved) ||
-                        // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a config has been set by the user or by a Vike extension).
-                        //  - Should we stop doing this? (And instead let Node.js directly load Vike extensions.)
-                        //    - In principle, we can use the setting 'name' value of Vike extensions.
-                        //      - 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 ||
-                        args.with?.['type'] === 'vike:pointer';
-                    assertPosixPath(importPathResolved);
-                    // 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.
-                    // - For example: https://github.com/vikejs/vike/issues/2326
-                    const isMostLikelyNpmPkgImport = isImportNpmPackageOrPathAlias(importPathOriginal) &&
-                        (importPathResolved.includes('/node_modules/') ||
-                            // Linked npm package
-                            !importPathResolved.startsWith(userRootDir));
-                    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.)
-                        (isMostLikelyNpmPkgImport && isPlainJavaScriptFile(importPathResolved));
-                    if (!isExternal) {
-                        // User-land config code (i.e. not runtime code) => let esbuild transpile it
-                        assert(!isPointerImport);
-                        if (debug.isActivated)
-                            debug('onResolve() [non-external]', { args, resolved, isPointerImport, isExternal });
-                        return resolved;
-                    }
-                    let importPathTranspiled;
-                    assertPosixPath(importPathOriginal);
-                    if (isImportPathRelative(importPathOriginal)) {
-                        importPathTranspiled = importPathResolved;
-                    }
-                    else {
-                        // `importPathOriginal` is either:
-                        //  - Npm package import
-                        //  - Path alias
-                        const filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({
-                            filePathAbsoluteFilesystem: importPathResolved,
-                            userRootDir,
-                        });
-                        if (filePathAbsoluteUserRootDir && !isMostLikelyNpmPkgImport) {
-                            // `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 reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
-                            importPathTranspiled = importPathResolved;
-                        }
-                        else {
-                            // `importPathOriginal` is most likely an npm package import.
-                            assertImportIsNpmPackage(importPathOriginal);
-                            // For improved error messages, let the resolution be handled by Vike or Node.js.
-                            importPathTranspiled = importPathOriginal;
-                        }
-                    }
-                    if (debug.isActivated)
-                        debug('onResolve() [external]', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
+            name: 'vike:pointer-imports',
+            async resolveId(importPath, importer, options) {
+                if (options.isEntry || options.kind !== 'import-statement')
+                    return;
+                assert(importer);
+                // Import with the import attribute `with { type: 'vike:pointer' }`, see transform() below
+                const isPointerImportAttribute = importPath.endsWith(pointerImportAttributeSuffix);
+                const importPathOriginal = isPointerImportAttribute
+                    ? importPath.slice(0, -pointerImportAttributeSuffix.length)
+                    : importPath;
+                const resolved = await resolveImport(this, importPathOriginal, importer, options);
+                if (!resolved) {
+                    /* We could do the following to let Node.js throw the error, but we don't because the error shown by Rolldown is prettier: the Node.js error refers to the transpiled +config.ts.build-f7i251e0iwnw.mjs whereas Rolldown refers to the source +config.ts file.
+                    pointerImports[importPathOriginal] = false
+                    return { id: importPathOriginal, external: true }
+                    */
+                    // Let Rolldown throw the error (see onLog() below)
+                    return null;
+                }
+                // Built-in modules e.g. node:fs
+                // - Rolldown externalizes only built-in modules and HTTP URLs (which Node.js can't import anyway): resolveImport() skips Vike's plugin and we don't use Rolldown's `external` option.
+                if (resolved.external) {
+                    const importPathTranspiled = resolved.id;
+                    const isPointerImport = false;
                     pointerImports[importPathTranspiled] = isPointerImport;
-                    return { external: true, path: importPathTranspiled };
-                });
+                    if (debug.isActivated)
+                        debug('resolveId() [built-in module]', { importPathOriginal, importer, resolved });
+                    return resolved;
+                }
+                // Rolldown's internal modules, e.g. helpers injected by Oxc's transformer
+                if (isVirtualModule(resolved.id))
+                    return resolved;
+                const importPathResolved = toPosixPath(resolved.id);
+                const classified = classifyImport(importPathOriginal, importPathResolved, isPointerImportAttribute, transformImports, userRootDir);
+                if (!classified.isExternal) {
+                    if (debug.isActivated)
+                        debug('resolveId() [non-external]', { importPathOriginal, importer, resolved });
+                    return resolved;
+                }
+                let { isPointerImport, importPathTranspiled } = classified;
+                // Keep the mark, so that the ID is different than the ID of the same file loaded and executed at config-time, see transform() below.
+                // - The mark is removed by transformPointerImports()
+                if (isPointerImportAttribute)
+                    importPathTranspiled += pointerImportAttributeSuffix;
+                if (debug.isActivated)
+                    debug('resolveId() [external]', {
+                        importPathOriginal,
+                        importer,
+                        resolved,
+                        importPathTranspiled,
+                        isPointerImport,
+                    });
+                pointerImports[importPathTranspiled] = isPointerImport;
+                return { id: importPathTranspiled, external: true };
+            },
+            async transform(code, id) {
+                // Rolldown's internal modules, e.g. \0rolldown/runtime.js
+                if (isVirtualModule(id))
+                    return;
+                // Rolldown doesn't pass import attributes `with { type: 'vike:pointer' }` to resolveId() => we parse the imports ourselves.
+                const importsWithPointerAttribute = parseImportsWithPointerAttribute(code, id);
+                // Rolldown calls resolveId() only once per import path of a module, and a file cannot be both external and bundled => we mark the import path of imports that have the import attribute, so that they're resolved separately. For example:
+                //   ```js
+                //   // Pointer import
+                //   import { Page } from './Page.ts' with { type: 'vike:pointer' }
+                //   // Loaded and executed at config-time
+                //   import { title } from './Page.ts'
+                //   ```
+                const { magicString, getMagicStringResult } = getMagicString(code, id);
+                for (const { importPath, importPathSpan } of importsWithPointerAttribute) {
+                    // We don't mark import paths that cannot be resolved: we let Rolldown throw the resolve error, which then shows the original code
+                    if (!(await resolveImport(this, importPath, id)))
+                        continue;
+                    // Mark the import path, right before its closing quote
+                    magicString.appendLeft(importPathSpan.end - 1, pointerImportAttributeSuffix);
+                }
+                return {
+                    ...getMagicStringResult(),
+                    // Disable tree-shaking of user-land code: we want to execute user-land code as-is. (Rolldown's internal modules, such as its runtime helpers, are tree-shaken.)
+                    moduleSideEffects: 'no-treeshake',
+                };
             },
         },
         // Track dependencies
+        // - We collect the dependencies with the load() hook (instead of using Rolldown's output), so that we also collect them if the build fails
         {
             name: 'vike:dependency-tracker',
-            setup(b) {
-                b.onLoad({ filter: /./ }, (args) => {
-                    // We collect the dependency `args.path` in case the build fails (upon build error => error is thrown => no metafile)
-                    let { path } = args;
-                    path = toPosixPath(path);
-                    esbuildCache.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.
+            load(id) {
+                if (isVirtualModule(id))
+                    return;
+                vikeTranspileCache.vikeConfigDependencies.add(toPosixPath(id));
+                /* To exhaustively collect all dependencies upon build failure, we would also need to use resolveId().
+                 *  - Because load() 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(...)
+                resolveId(...)
                 */
             },
         },
     ];
-    let result;
+    let bundle;
+    let output;
     try {
-        result = await build(options);
+        bundle = await rolldown({
+            input: entryFilePath,
+            cwd: userRootDir,
+            platform: 'node',
+            // Resolve path aliases defined in tsconfig.json
+            tsconfig: true,
+            transform: {
+                target: `node${nodeVersionMin}`,
+            },
+            // Keep the absolute path of pointer imports, so that the import paths of Rolldown's output match `pointerImports`
+            makeAbsoluteExternalsRelative: false,
+            plugins,
+            onLog(level, log, defaultHandler) {
+                if (debugResolve.isActivated)
+                    debugResolve('log', { level, log });
+                // Rolldown treats unresolved imports that aren't relative (e.g. npm packages and path aliases) as external, but we want the build to fail instead (as with esbuild):
+                // - Rolldown's error shows the import in the source file, whereas the error thrown by Node.js would refer to the temporary build file, see resolveId() above.
+                // - Such an external import wouldn't be classified by resolveId() (it wouldn't be in `pointerImports`).
+                if (log.code === 'UNRESOLVED_IMPORT') {
+                    unresolvedImports.push(log);
+                    return;
+                }
+                defaultHandler(level, log);
+            },
+        });
+        output = await bundle.generate({
+            format: 'esm',
+            sourcemap: 'inline',
+            // Needed for correct inline source map (bundle.generate() doesn't emit any file)
+            dir: entryFileDir,
+            // Avoid dead-code elimination (Rolldown's default is `minify: 'dce-only'`)
+            minify: false,
+            // Single chunk
+            codeSplitting: false,
+        });
     }
     catch (err) {
-        await formatBuildErr(err, filePath);
+        // Error thrown by one of our plugins, e.g. a failing assert()
+        const errVikePlugin = getErrVikePlugin(err);
+        if (errVikePlugin)
+            throw errVikePlugin;
+        formatBuildErr(err, filePath);
         throw err;
     }
-    // Track dependencies
-    assert(result.metafile);
-    Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
-        filePathRelative = toPosixPath(filePathRelative);
-        assertPosixPath(userRootDir);
-        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
-        esbuildCache.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    });
-    const code = result.outputFiles[0].text;
+    finally {
+        await bundle?.close();
+    }
+    if (unresolvedImports.length > 0)
+        throw getErrUnresolvedImports(unresolvedImports, filePath);
+    const chunk = output.output[0];
+    assert(output.output.length === 1);
+    assert(chunk.type === 'chunk');
+    const { code } = chunk;
     assert(typeof code === 'string');
     return { code, pointerImports };
 }
+// Resolve with Rolldown
+async function resolveImport(pluginContext, importPath, importer, options = { kind: 'import-statement' }) {
+    const resolved = await pluginContext.resolve(importPath, importer, {
+        ...options,
+        skipSelf: true,
+    });
+    if (debugResolve.isActivated)
+        debugResolve('args', { importPath, importer, options });
+    if (debugResolve.isActivated)
+        debugResolve('resolved', resolved);
+    return resolved;
+}
+// Determine whether an import should be:
+//  - A pointer import
+//  - Externalized
+function classifyImport(importPathOriginal, importPathResolved, isPointerImportAttribute, transformImports, userRootDir) {
+    // Rolldown resolves path aliases.
+    // - Enabling us to use:
+    //   - assertImportIsNpmPackage()
+    //   - isImportNpmPackage(str, { cannotBePathAlias: true })
+    assertFilePathAbsoluteFilesystem(importPathResolved);
+    //  Should we remove this? See comment below.
+    const isVikeExtensionImport = (importPathOriginal.startsWith('vike-') && importPathOriginal.endsWith('/config')) ||
+        importPathResolved.endsWith('+config.js');
+    const isPointerImport = transformImports === 'all' ||
+        // .jsx, .vue, .svg, ... => obviously not config code => pointer import
+        !isPlainScriptFile(importPathResolved) ||
+        // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a config has been set by the user or by a Vike extension).
+        //  - Should we stop doing this? (And instead let Node.js directly load Vike extensions.)
+        //    - In principle, we can use the setting 'name' value of Vike extensions.
+        //      - 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 ||
+        isPointerImportAttribute;
+    assertPosixPath(importPathResolved);
+    // 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.
+    // - For example: https://github.com/vikejs/vike/issues/2326
+    const isMostLikelyNpmPkgImport = isImportNpmPackageOrPathAlias(importPathOriginal) &&
+        (importPathResolved.includes('/node_modules/') ||
+            // Linked npm package
+            !importPathResolved.startsWith(userRootDir));
+    const isExternal = isPointerImport ||
+        // Performance: npm package imports can be externalized. (We could as well let Rolldown transpile /node_modules/ code but it's useless as /node_modules/ code is already built. It would unnecessarily slow down transpilation.)
+        (isMostLikelyNpmPkgImport && isPlainJavaScriptFile(importPathResolved));
+    if (!isExternal) {
+        // User-land config code (i.e. not runtime code) => let Rolldown transpile it
+        assert(!isPointerImport);
+        return { isExternal, isPointerImport };
+    }
+    let importPathTranspiled;
+    assertPosixPath(importPathOriginal);
+    if (isImportPathRelative(importPathOriginal)) {
+        importPathTranspiled = importPathResolved;
+    }
+    else {
+        // `importPathOriginal` is either:
+        //  - Npm package import
+        //  - Path alias
+        const filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({
+            filePathAbsoluteFilesystem: importPathResolved,
+            userRootDir,
+        });
+        if (filePathAbsoluteUserRootDir && !isMostLikelyNpmPkgImport) {
+            // `importPathOriginal` is most likely a path alias.
+            // - We have to use Rolldown's path alias resolution, because:
+            //   - Vike doesn't resolve path aliases at all.
+            //   - Node.js doesn't support `tsconfig.js#compilerOptions.paths`.
+            // - Rolldown path alias resolution seems reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
+            importPathTranspiled = importPathResolved;
+        }
+        else {
+            // `importPathOriginal` is most likely an npm package import.
+            assertImportIsNpmPackage(importPathOriginal);
+            // For improved error messages, let the resolution be handled by Vike or Node.js.
+            importPathTranspiled = importPathOriginal;
+        }
+    }
+    return { isExternal, isPointerImport, importPathTranspiled };
+}
+// Imports with the import attribute `with { type: 'vike:pointer' }`
+function parseImportsWithPointerAttribute(code, id) {
+    // Performance trick
+    if (!code.includes('vike:pointer'))
+        return [];
+    let program;
+    try {
+        program = parseAst(code, { lang: getLang(id), sourceType: 'module' }, id);
+    }
+    catch {
+        // Let Rolldown throw the parse error (Rolldown shows a prettier error)
+        return [];
+    }
+    const imports = [];
+    program.body.forEach((node) => {
+        if (node.type === 'ImportDeclaration') {
+            // Removed by TypeScript transpilation
+            if (node.importKind === 'type')
+                return;
+            if (!hasPointerImportAttribute(node.attributes))
+                return;
+            imports.push({
+                importPath: node.source.value,
+                importPathSpan: { start: node.source.start, end: node.source.end },
+            });
+        }
+        if ((node.type === 'ExportNamedDeclaration' || node.type === 'ExportAllDeclaration') && node.source) {
+            // Removed by TypeScript transpilation
+            if (node.exportKind === 'type')
+                return;
+            if (!hasPointerImportAttribute(node.attributes))
+                return;
+            imports.push({
+                importPath: node.source.value,
+                importPathSpan: { start: node.source.start, end: node.source.end },
+            });
+        }
+    });
+    return imports;
+}
+function hasPointerImportAttribute(attributes) {
+    return attributes.some(({ key, value }) => {
+        const keyName = key.type === 'Identifier' ? key.name : key.value;
+        return keyName === 'type' && value.value === 'vike:pointer';
+    });
+}
+function getLang(filePath) {
+    const fileExtension = getFileExtension(filePath);
+    if (['ts', 'mts', 'cts'].includes(fileExtension))
+        return 'ts';
+    if (fileExtension === 'tsx')
+        return 'tsx';
+    if (fileExtension === 'jsx')
+        return 'jsx';
+    return 'js';
+}
+function isVirtualModule(id) {
+    return id.startsWith('\0');
+}
 async function executeTranspiledFile(filePath, code) {
     const { filePathAbsoluteFilesystem } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
@@ -345,17 +463,40 @@ function getConfigBuildErrorFormatted(err) {
     const errMsgFormatted = err[formatted];
     return errMsgFormatted;
 }
-async function formatBuildErr(err, filePath) {
-    assert(isObject(err) && err.errors);
-    const msgEsbuild = (await formatMessages(err.errors, {
-        kind: 'error',
-        color: true,
-    }))
-        .map((m) => m.trim())
-        .join('\n');
+function formatBuildErr(err, filePath) {
+    if (!isRolldownBuildError(err))
+        return;
+    const msgRolldown = err.errors.map((e) => e.message.trim()).join('\n');
     const msgIntro = getErrIntroMsg('transpile', filePath);
-    const errMsgFormatted = `${msgIntro}\n${msgEsbuild}`;
-    err[formatted] = errMsgFormatted;
+    const errMsgFormatted = `${msgIntro}\n${msgRolldown}`;
+    // Non-enumerable, otherwise `$ vike build` prints it in addition to the error message
+    Object.defineProperty(err, formatted, { value: errMsgFormatted, enumerable: false, configurable: true });
+}
+function isRolldownBuildError(err) {
+    return (isObject(err) && Array.isArray(err.errors) && err.errors.every((e) => isObject(e) && typeof e.message === 'string'));
+}
+function getErrVikePlugin(err) {
+    if (!isRolldownBuildError(err))
+        return null;
+    const errVikePlugin = err.errors.find((e) => e.code === 'PLUGIN_ERROR' && e.plugin?.startsWith('vike:'));
+    return errVikePlugin ?? null;
+}
+function getErrUnresolvedImports(logs, filePath) {
+    const errors = logs.map((log) => ({
+        ...log,
+        // We make the build fail, thus:
+        // - Color it as an error (instead of as a warning)
+        // - Remove `, treating it as an external dependency` from the message `Module not found, treating it as an external dependency`
+        message: log.message
+            .replace('\x1b[33m[UNRESOLVED_IMPORT]', '\x1b[31m[UNRESOLVED_IMPORT]')
+            .replace(', treating it as an external dependency', '.'),
+    }));
+    const msg = `Build failed with ${errors.length} error${errors.length === 1 ? '' : 's'}:\n\n${errors.map((e) => e.message).join('\n')}`;
+    const err = new Error(msg);
+    // Getter (like Rolldown's errors), otherwise `$ vike build` prints it in addition to the error message (Node.js's util.inspect() always prints `error.errors` if it's an array)
+    Object.defineProperty(err, 'errors', { get: () => errors, enumerable: true, configurable: true });
+    formatBuildErr(err, filePath);
+    return err;
 }
 const execErrIntroMsg = new WeakMap();
 function getConfigExecutionErrorIntroMsg(err) {
@@ -418,26 +559,6 @@ function getErrIntroMsg(operation, filePath) {
     const msg = `${pc.red(`Failed to ${operation}`)} ${pc.bold(pc.red(filePathToShowToUserResolved))} ${pc.red(`because:`)}`;
     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'))));
-}
 function installSourceMapSupport() {
     // Don't break Vitest's source mapping
     if (isVitest())

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

@@ -134,7 +134,7 @@ function isV1Design() {
 async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     const { promise, resolve, reject } = genPromise();
     globalObject.vikeConfigPromise = promise;
-    const esbuildCache = {
+    const vikeTranspileCache = {
         transpileCache: {},
         vikeConfigDependencies: new Set(),
     };
@@ -143,7 +143,7 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     let ret;
     let err;
     try {
-        ret = await resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache);
+        ret = await resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, vikeTranspileCache);
     }
     catch (err_) {
         hasError = true;
@@ -193,7 +193,7 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
         }
         else {
             logErrorServerDev(err, null);
-            resolve(await getVikeConfigDummy(esbuildCache));
+            resolve(await getVikeConfigDummy(vikeTranspileCache));
         }
     }
 }
@@ -215,9 +215,9 @@ function hasViteConfigChanged(vikeConfigOld, vikeConfigNew) {
     }
     return false;
 }
-async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache) {
-    const plusFilesByLocationId = await getPlusFiles(userRootDir, esbuildCache);
-    const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbuildCache);
+async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, vikeTranspileCache) {
+    const plusFilesByLocationId = await getPlusFiles(userRootDir, vikeTranspileCache);
+    const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesByLocationId, userRootDir, vikeTranspileCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesByLocationId, userRootDir);
     if (!globalObject.isV1Design_)
         globalObject.isV1Design_ = pageConfigs.length > 0;
@@ -239,7 +239,7 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
         prerenderContext,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
-        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
+        _vikeConfigDependencies: vikeTranspileCache.vikeConfigDependencies,
         _extensions,
     };
     globalObject.vikeConfigSync = vikeConfig;
@@ -249,14 +249,14 @@ function resolveGlobalConfig(pageConfigGlobal, pageConfigs) {
     const globalConfigPublic = resolveGlobalConfigPublic(pageConfigs, pageConfigGlobal, getConfigValues);
     return globalConfigPublic;
 }
-async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbuildCache) {
+async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, vikeTranspileCache) {
     const plusFilesByLocationIdOrdered = Object.values(plusFilesByLocationId)
         .flat()
         .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderGlobal(plusFile1, plusFile2, plusFilesByLocationId, null));
     const configDefinitionsGlobal = getConfigDefinitions(
     // We use `plusFilesByLocationId` in order to allow non-global Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
     plusFilesByLocationIdOrdered, (configDef) => !!configDef.global);
-    await loadCustomConfigBuildTimeFiles(plusFilesByLocationId, configDefinitionsGlobal, userRootDir, esbuildCache);
+    await loadCustomConfigBuildTimeFiles(plusFilesByLocationId, configDefinitionsGlobal, userRootDir, vikeTranspileCache);
     const configNamesKnownAll = getConfigNames(Object.values(plusFilesByLocationId).flat());
     const configNamesKnownGlobal = Object.keys(configDefinitionsGlobal);
     assert(configNamesKnownGlobal.every((configName) => configNamesKnownAll.includes(configName)));
@@ -268,7 +268,7 @@ async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbu
             .flat()
             .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderPage(plusFile1, plusFile2, locationIdPage, null));
         const { configDefinitions, peerDependencyConfigNames } = collectConfigDefinitions(plusFilesRelevant, (configDef) => configDef.global !== true);
-        await loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache);
+        await loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, vikeTranspileCache);
         const configNamesKnownLocal = unique([
             ...Object.keys(configDefinitions),
             ...peerDependencyConfigNames,
@@ -293,15 +293,15 @@ async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbu
 }
 // Load value files (with `env.config===true`) of *custom* configs.
 // - The value files of *built-in* configs are already loaded at `getPlusFiles()`.
-async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache) {
+async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, vikeTranspileCache) {
     const plusFileList = Object.values(plusFiles).flat(1);
     await Promise.all(plusFileList.map(async (plusFile) => {
         if (!plusFile.isConfigFile) {
-            await loadValueFile(plusFile, configDefinitions, userRootDir, esbuildCache);
+            await loadValueFile(plusFile, configDefinitions, userRootDir, vikeTranspileCache);
         }
         else {
             await Promise.all(Object.entries(plusFile.pointerImportsByConfigName).map(async ([configName, pointerImports]) => {
-                await Promise.all(pointerImports.map((pointerImport) => loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache)));
+                await Promise.all(pointerImports.map((pointerImport) => loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, vikeTranspileCache)));
             }));
         }
     }));
@@ -1325,7 +1325,7 @@ function restartViteDevServer() {
     })();
     swallowViteLogForceOptimization_disable();
 }
-async function getVikeConfigDummy(esbuildCache) {
+async function getVikeConfigDummy(vikeTranspileCache) {
     const pageConfigsDummy = [];
     const pageConfigGlobalDummy = {
         configValueSources: {},
@@ -1345,7 +1345,7 @@ async function getVikeConfigDummy(esbuildCache) {
         },
         ...globalConfigPublicDummy,
         prerenderContext: prerenderContextDummy,
-        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
+        _vikeConfigDependencies: vikeTranspileCache.vikeConfigDependencies,
         _extensions: [],
     };
     globalObject.vikeConfigSync = vikeConfigDummy;

package/dist/server/runtime/renderPageServer/csp.d.ts

@@ -3,9 +3,10 @@ export { inferNonceAttr };
 export { addCspResponseHeader };
 export type { PageContextCspNonce };
 import type { PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
+import type { PageContextPublicMinimum } from '../../../shared-server-client/getPageContextPublicShared.js';
 import type { PageContextServer } from '../../../types/PageContext.js';
 import '../../assertEnvServer.js';
-declare function resolvePageContextCspNone(pageContext: PageContextConfig & Partial<PageContextCspNonce>): Promise<null | {
+declare function resolvePageContextCspNone(pageContext: PageContextConfig & PageContextPublicMinimum & Partial<PageContextCspNonce>): Promise<null | {
     cspNonce: string | null;
 }>;
 type PageContextCspNonce = Pick<PageContextServer, 'cspNonce'>;

package/dist/server/runtime/renderPageServer/csp.js

@@ -3,6 +3,7 @@ export { inferNonceAttr };
 export { addCspResponseHeader };
 import { import_ } from '@brillout/import';
 import { assert } from '../../../utils/assert.js';
+import { getPageContextPublicServer } from './getPageContextPublicServer.js';
 import '../../assertEnvServer.js';
 async function resolvePageContextCspNone(pageContext) {
     if (pageContext.cspNonce)
@@ -14,7 +15,7 @@ async function resolvePageContextCspNone(pageContext) {
             pageContextAddendum.cspNonce = await generateNonce();
         }
         else {
-            pageContextAddendum.cspNonce = await csp.nonce(pageContext);
+            pageContextAddendum.cspNonce = await csp.nonce(getPageContextPublicServer(pageContext));
         }
     }
     return pageContextAddendum;

package/dist/server/runtime/renderPageServer/headersResponse.js

@@ -3,6 +3,7 @@ export { resolveHeadersResponseFinal };
 import { addCspResponseHeader } from './csp.js';
 import { isCallable } from '../../../utils/isCallable.js';
 import { cacheControlDisable, getCacheControl } from './getCacheControl.js';
+import { getPageContextPublicServer } from './getPageContextPublicServer.js';
 import '../../assertEnvServer.js';
 function resolveHeadersResponseFinal(pageContext, statusCode) {
     const headersResponse = pageContext.headersResponse || new Headers();
@@ -34,7 +35,7 @@ async function resolveHeadersResponseConfig(pageContext) {
     await Promise.all((pageContext.config.headersResponse ?? []).map(async (headers) => {
         let headersInit;
         if (isCallable(headers)) {
-            headersInit = await headers(pageContext);
+            headersInit = await headers(getPageContextPublicServer(pageContext));
         }
         else {
             headersInit = headers;

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: '0.4.266-commit-f1b186a';
+export declare const PROJECT_VERSION: '0.4.267-commit-b005535';

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.266-commit-f1b186a';
+export const PROJECT_VERSION = '0.4.267-commit-b005535';

package/dist/utils/assertNodeVersion.d.ts

@@ -1,2 +1,4 @@
 export { assertNodeVersion };
+export { nodeVersionMin };
+declare const nodeVersionMin = "20.19.0";
 declare function assertNodeVersion(): void;

package/dist/utils/assertNodeVersion.js

@@ -1,6 +1,9 @@
 export { assertNodeVersion };
+export { nodeVersionMin };
 import { isNodeJS } from './isNodeJS.js';
 import { assertVersion } from './assertVersion.js';
+// Vike's minimum supported Node.js version
+const nodeVersionMin = '20.19.0';
 // node_modules/vike/package.json#engines.node isn't enough, as users often ignore it
 function assertNodeVersion() {
     if (!isNodeJS())
@@ -8,5 +11,5 @@ function assertNodeVersion() {
     const version = process.versions.node;
     assertVersion('Node.js', version, 
     // https://gist.github.com/brillout/8e0133716e169b981b6c4e8a938b0134
-    ['20.19.0', '22.12.0']);
+    [nodeVersionMin, '22.12.0']);
 }

package/dist/utils/debug.d.ts

@@ -2,7 +2,7 @@ export { createDebug };
 export { isDebug };
 export { isDebugError };
 export { debug };
-declare const flags: ["vike", "vike:config", "vike:crawl", "vike:file-change", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:requireResolve", "vike:routing", "vike:setup", "vike:staticReplace", "vike:stream", "vike:virtualFiles", "vike:vite-config-user", "vike:vite-rpc"];
+declare const flags: ["vike", "vike:config", "vike:crawl", "vike:file-change", "vike:error", "vike:transpile-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:requireResolve", "vike:routing", "vike:setup", "vike:staticReplace", "vike:stream", "vike:virtualFiles", "vike:vite-config-user", "vike:vite-rpc"];
 type Flag = (typeof flags)[number];
 type Options = {
     serialization?: {

package/dist/utils/debug.js

@@ -15,7 +15,7 @@ const flags = [
     'vike:crawl',
     'vike:file-change',
     'vike:error',
-    'vike:esbuild-resolve',
+    'vike:transpile-resolve',
     'vike:pluginExtractAssets',
     'vike:pluginExtractExportNames',
     'vike:glob',

package/dist/utils/requireResolve.d.ts

@@ -1,5 +1,4 @@
 export { requireResolveOptional };
-export { requireResolveOptionalDir };
 export { requireResolveNpmPackage };
 export { requireResolveDistFile };
 export { getPackageNodeModulesDirectory };
@@ -8,11 +7,6 @@ declare function requireResolveOptional({ importPath, importerFilePath, userRoot
     importerFilePath: string | null;
     userRootDir: string;
 }): string | null;
-declare function requireResolveOptionalDir({ importPath, importerDir, userRootDir, }: {
-    importPath: string;
-    importerDir: string;
-    userRootDir: string;
-}): string | null;
 declare function requireResolveNpmPackage({ importPathNpmPackage, userRootDir, }: {
     importPathNpmPackage: string;
     userRootDir: string;

package/dist/utils/requireResolve.js

@@ -1,5 +1,4 @@
 export { requireResolveOptional };
-export { requireResolveOptionalDir };
 export { requireResolveNpmPackage };
 export { requireResolveDistFile };
 export { getPackageNodeModulesDirectory };
@@ -88,13 +87,6 @@ function requireResolveOptional({ importPath, importerFilePath, userRootDir, })
         return null;
     return res.importPathResolvedFilePath;
 }
-function requireResolveOptionalDir({ importPath, importerDir, userRootDir, }) {
-    const importerFilePath = getFakeImporterFile(importerDir);
-    const res = requireResolve_(importPath, importerFilePath, userRootDir);
-    if (res.hasFailed)
-        return null;
-    return res.importPathResolvedFilePath;
-}
 function requireResolveNpmPackage({ importPathNpmPackage, userRootDir, }) {
     assertImportIsNpmPackage(importPathNpmPackage);
     const importerFilePath = getFakeImporterFile(userRootDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.266-commit-f1b186a",
+  "version": "0.4.267-commit-b005535",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -135,10 +135,10 @@
     "cac": "^6.0.0",
     "convert-route": "^1.1.1",
     "es-module-lexer": "^1.0.0",
-    "esbuild": ">=0.19.0",
     "json5": "^2.0.0",
-    "magic-string": "^1.4.1",
+    "magic-string": "^1.4.2",
     "picomatch": "^4.0.7",
+    "rolldown": ">=1.0.0",
     "semver": "^7.8.5",
     "sirv": "^3.0.2",
     "source-map-support": "^0.5.0",
@@ -269,7 +269,6 @@
     "@types/source-map-support": "^0.5.10",
     "react-streaming": "^0.4.20",
     "rimraf": "^6.1.3",
-    "rolldown": "1.0.0-rc.17",
     "typescript": "^7.0.2",
     "vite": "^7.2.6"
   },