vike 0.4.266 → 0.4.267

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())