vike 0.4.239 → 0.4.240

package/dist/esm/node/vite/plugins/build/pluginDistFileNames.js

@@ -0,0 +1,253 @@
+export { pluginDistFileNames };
+// Attempt to preserve file structure of `.page.js` files:
+//  - https://github.com/vikejs/vike/commit/11a4c49e5403aa7c37c8020c462b499425b41854
+//  - Blocker: https://github.com/rollup/rollup/issues/4724
+import { assertPosixPath, assert, assertUsage, isArray, isCallable } from '../../utils.js';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { getAssetsDir } from '../../shared/getAssetsDir.js';
+import { assertModuleId, getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
+function pluginDistFileNames() {
+    return [
+        {
+            name: 'vike:build:pluginDistFileNames',
+            apply: 'build',
+            enforce: 'post',
+            configResolved: {
+                handler(config) {
+                    const rollupOutputs = getRollupOutputs(config);
+                    // We need to support multiple outputs: @vite/plugin-legacy adds an output, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
+                    rollupOutputs.forEach((rollupOutput) => {
+                        if (!('entryFileNames' in rollupOutput)) {
+                            rollupOutput.entryFileNames = (chunkInfo) => getEntryFileName(chunkInfo, config, true);
+                        }
+                        if (!('chunkFileNames' in rollupOutput)) {
+                            rollupOutput.chunkFileNames = (chunkInfo) => getChunkFileName(chunkInfo, config);
+                        }
+                        if (!('assetFileNames' in rollupOutput)) {
+                            rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config);
+                            rollupOutput.assetFileNames.isTheOneSetByVike = true;
+                            assert(rollupOutput.assetFileNames.isTheOneSetByVike);
+                        }
+                        else {
+                            // If a user needs this:
+                            //  - assertUsage() that the naming provided by the user ends with `.[hash][extname]`
+                            //    - It's needed for getHash() of handleAssetsManifest()
+                            //    - Asset URLs should always contain a hash: it's paramount for caching assets.
+                            //    - If rollupOutput.assetFileNames is a function then use a wrapper function to apply the assertUsage()
+                            assertUsage(rollupOutput.assetFileNames.isTheOneSetByVike, "Setting Vite's configuration build.rollupOptions.output.assetFileNames is currently forbidden. Reach out if you need to use it.");
+                        }
+                        {
+                            const manualChunksOriginal = rollupOutput.manualChunks;
+                            rollupOutput.manualChunks = function (id, ...args) {
+                                if (manualChunksOriginal) {
+                                    if (isCallable(manualChunksOriginal)) {
+                                        const result = manualChunksOriginal.call(this, id, ...args);
+                                        if (result !== undefined)
+                                            return result;
+                                    }
+                                    else {
+                                        assertUsage(false, "The Vite's configuration build.rollupOptions.output.manualChunks must be a function. Reach out if you need to set it to another value.");
+                                    }
+                                }
+                                // Disable CSS bundling to workaround https://github.com/vikejs/vike/issues/1815
+                                // TO-DO/eventually: let's bundle CSS again once Rolldown replaces Rollup
+                                if (id.endsWith('.css')) {
+                                    const userRootDir = config.root;
+                                    if (id.startsWith(userRootDir)) {
+                                        assertPosixPath(id);
+                                        assertModuleId(id);
+                                        let name;
+                                        const isNodeModules = id.match(/node_modules\/([^\/]+)\/(?!.*node_modules)/);
+                                        if (isNodeModules) {
+                                            name = isNodeModules[1];
+                                        }
+                                        else {
+                                            const filePath = getModuleFilePathAbsolute(id, config);
+                                            name = filePath;
+                                            name = name.split('.').slice(0, -1).join('.'); // remove file extension
+                                            name = name.split('/').filter(Boolean).join('_');
+                                        }
+                                        // Make fileHash the same between local development and CI
+                                        const idStable = path.posix.relative(userRootDir, id);
+                                        // Don't remove `?` queries because each `id` should belong to a unique bundle.
+                                        const hash = getIdHash(idStable);
+                                        return `${name}-${hash}`;
+                                    }
+                                    else {
+                                        let name;
+                                        const isVirtualModule = id.match(/virtual:([^:]+):/);
+                                        if (isVirtualModule) {
+                                            name = isVirtualModule[1];
+                                            assert(name);
+                                        }
+                                        else if (
+                                        // https://github.com/vikejs/vike/issues/1818#issuecomment-2298478321
+                                        id.startsWith('/__uno')) {
+                                            name = 'uno';
+                                        }
+                                        else {
+                                            name = 'style';
+                                        }
+                                        const hash = getIdHash(id);
+                                        return `${name}-${hash}`;
+                                    }
+                                }
+                            };
+                        }
+                    });
+                },
+            },
+        },
+    ];
+}
+function getIdHash(id) {
+    return crypto.createHash('md5').update(id).digest('hex').slice(0, 8);
+}
+function getAssetFileName(assetInfo, config) {
+    const userRootDir = config.root;
+    const assetsDir = getAssetsDir(config);
+    const dir = assetsDir + '/static';
+    let { name } = assetInfo;
+    if (!name) {
+        return `${dir}/[name].[hash][extname]`;
+    }
+    // https://github.com/vikejs/vike/issues/794
+    assertPosixPath(name);
+    name = path.posix.basename(name);
+    // dist/client/assets/index.page.server.jsx_extractAssets_lang.e4e33422.css
+    // => dist/client/assets/index.page.server.e4e33422.css
+    if (
+    // Vite 2
+    name?.endsWith('_extractAssets_lang.css') ||
+        // Vite 3
+        name?.endsWith('?extractAssets&lang.css')) {
+        name = name.split('.').slice(0, -2).join('.');
+        name = clean(name, userRootDir);
+        return `${dir}/${name}.[hash][extname]`;
+    }
+    name = name.split('.').slice(0, -1).join('.');
+    name = clean(name, userRootDir);
+    return `${dir}/${name}.[hash][extname]`;
+}
+function getChunkFileName(_chunkInfo, config) {
+    const isForClientSide = !config.build.ssr;
+    let name = 'chunks/chunk-[hash].js';
+    if (isForClientSide) {
+        const assetsDir = getAssetsDir(config);
+        name = `${assetsDir}/${name}`;
+    }
+    return name;
+}
+function getEntryFileName(chunkInfo, config, isEntry) {
+    const userRootDir = config.root;
+    const assetsDir = getAssetsDir(config);
+    const isForClientSide = !config.build.ssr;
+    let { name } = chunkInfo;
+    assertPosixPath(name);
+    name = clean(name, userRootDir, true, 
+    // Not needed for client-side because dist/ filenames contain `.[hash].js`
+    !isForClientSide);
+    if (isForClientSide) {
+        return `${assetsDir}/${name}.[hash].js`;
+    }
+    else {
+        return `${name}.${isEntry ? 'mjs' : 'js'}`;
+    }
+}
+function removePathSeparators(name) {
+    assertPosixPath(name);
+    assert(!name.startsWith('/'), { name });
+    const entryDir = 'entries/';
+    const hasEntryDir = name.startsWith(entryDir);
+    if (hasEntryDir) {
+        name = name.slice(entryDir.length);
+        assert(!name.startsWith('/'));
+    }
+    name = name.split('/').join('_');
+    if (hasEntryDir) {
+        name = `${entryDir}${name}`;
+    }
+    return name;
+}
+function removeUserRootDir(name, userRootDir) {
+    if (name.startsWith(userRootDir)) {
+        name = name.slice(userRootDir.length);
+        if (name.startsWith('/'))
+            name = name.slice(1);
+    }
+    assert(!name.startsWith('/'), { name });
+    return name;
+}
+function clean(name, userRootDir, removePathSep, fixGlob) {
+    name = removeUserRootDir(name, userRootDir);
+    name = fixExtractAssetsQuery(name);
+    if (fixGlob) {
+        name = workaroundGlob(name);
+    }
+    name = replaceNonLatinCharacters(name);
+    if (removePathSep) {
+        name = removePathSeparators(name);
+    }
+    name = removeLeadingUnderscoreInFilename(name);
+    name = removeUnderscoreDoublets(name);
+    // Avoid:
+    // ```
+    // dist/client/assets/entries/.Dp9wM6PK.js
+    // dist/server/entries/.mjs
+    // ```
+    assert(!name.endsWith('/'));
+    return name;
+}
+function fixExtractAssetsQuery(name) {
+    name = name.replace(/\.[^\.]*_extractAssets_lang$/, '.extractAssets');
+    return name;
+}
+function removeUnderscoreDoublets(name) {
+    name = name.split(/__+/).join('_');
+    return name;
+}
+function replaceNonLatinCharacters(name) {
+    name = name.split('+').join('');
+    name = name.replace(/[^a-zA-Z0-9\/\._]/g, '-');
+    return name;
+}
+// Remove leading `_` from filename
+//  - GitHub Pages treat URLs with filename starting with `_` differently (removing the need for workaround of creating a .jekyll file)
+function removeLeadingUnderscoreInFilename(name) {
+    assertPosixPath(name);
+    const paths = name.split('/');
+    {
+        const last = paths.length - 1;
+        let filename = paths[last];
+        if (filename.startsWith('_')) {
+            filename = filename.slice(1);
+            paths[last] = filename;
+            name = paths.join('/');
+        }
+    }
+    return name;
+}
+// Ensure import.meta.glob() doesn't match dist/ files
+function workaroundGlob(name) {
+    // V1 design
+    name = name.split('+').join('');
+    ['client', 'server', 'route'].forEach((env) => {
+        name = name.split(`.page.${env}`).join(`-page-${env}`);
+    });
+    name = name.split('.page.').join('-page.');
+    name = name.replace(/\.page$/, '-page');
+    return name;
+}
+function getRollupOutputs(config) {
+    var _a, _b;
+    // @ts-expect-error is read-only
+    config.build ?? (config.build = {});
+    (_a = config.build).rollupOptions ?? (_a.rollupOptions = {});
+    (_b = config.build.rollupOptions).output ?? (_b.output = {});
+    const { output } = config.build.rollupOptions;
+    if (!isArray(output)) {
+        return [output];
+    }
+    return output;
+}

package/dist/esm/node/vite/plugins/{pluginBuild → build}/pluginDistPackageJsonFile.d.ts

@@ -1,3 +1,3 @@
 export { pluginDistPackageJsonFile };
 import type { Plugin } from 'vite';
-declare function pluginDistPackageJsonFile(): Plugin;
+declare function pluginDistPackageJsonFile(): Plugin[];

package/dist/esm/node/vite/plugins/build/pluginDistPackageJsonFile.js

@@ -0,0 +1,40 @@
+export { pluginDistPackageJsonFile };
+import { rollupIsEsm } from '../../shared/rollupIsEsm.js';
+import { isViteServerSide } from '../../shared/isViteServerSide.js';
+function pluginDistPackageJsonFile() {
+    let config;
+    return [
+        {
+            name: 'vike:build:pluginDistPackageJsonFile',
+            apply: 'build',
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+            generateBundle: {
+                handler(options, bundle) {
+                    if (!isViteServerSide(config, this.environment))
+                        return;
+                    const isEsm = rollupIsEsm(options);
+                    const fileName = 'package.json';
+                    if (bundle[fileName])
+                        return; // E.g. already generated by Telefunc / vike
+                    this.emitFile({
+                        fileName,
+                        type: 'asset',
+                        source: getPackageJsonContent(isEsm),
+                    });
+                },
+            },
+        },
+    ];
+}
+function getPackageJsonContent(isEsm) {
+    if (isEsm) {
+        return `{ "type": "module" }`;
+    }
+    else {
+        return `{ "type": "commonjs" }`;
+    }
+}

package/dist/esm/node/vite/plugins/{pluginBuild → build}/pluginModuleBanner.d.ts

@@ -1,3 +1,3 @@
 export { pluginModuleBanner };
 import type { Plugin } from 'vite';
-declare function pluginModuleBanner(): Plugin;
+declare function pluginModuleBanner(): Plugin[];

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

@@ -0,0 +1,49 @@
+export { pluginModuleBanner };
+import { assert, removeVirtualFileIdPrefix } from '../../utils.js';
+import { getMagicString } from '../../shared/getMagicString.js';
+// Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
+// But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
+function pluginModuleBanner() {
+    let config;
+    return [
+        {
+            name: 'vike:build:pluginModuleBanner',
+            enforce: 'post',
+            apply: 'build',
+            applyToEnvironment(environment) {
+                const { config } = environment;
+                const { consumer } = config;
+                const { minify } = config.build;
+                assert(minify === false || minify, { minify, consumer });
+                return !minify;
+            },
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+            transform: {
+                order: 'post',
+                /* Using a Rolldown hook filter doesn't make sense here — we use applyToEnvironment() to conditionally apply this plugin.
+              filter: {},
+              */
+                handler(code, id) {
+                    const { minify } = this.environment.config.build;
+                    assert(minify === false, { minify });
+                    if (id.startsWith('\0'))
+                        id = id;
+                    id = removeVirtualFileIdPrefix(id);
+                    if (id.startsWith(config.root))
+                        id = id.slice(config.root.length + 1);
+                    id = id.replaceAll('*/', '*\\/'); // https://github.com/vikejs/vike/issues/2377
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    // Use legal comment so that esbuild doesn't remove it.
+                    // - Terser still removes the comment, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
+                    // - https://esbuild.github.io/api/#legal-comments
+                    magicString.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}

package/dist/esm/node/vite/plugins/{pluginBuild → build}/pluginProdBuildEntry.js

@@ -17,8 +17,10 @@ function pluginProdBuildEntry() {
             name: 'vike:build:pluginProdBuildEntry',
             apply: 'build',
             enforce: 'post',
-            async configResolved(config_) {
-                config = config_;
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                },
             },
         },
         ...serverProductionEntryPlugin({

package/dist/esm/node/vite/plugins/{pluginBuild → build}/pluginSuppressRollupWarning.d.ts

@@ -1,3 +1,3 @@
 export { pluginSuppressRollupWarning };
 import type { Plugin } from 'vite';
-declare function pluginSuppressRollupWarning(): Plugin;
+declare function pluginSuppressRollupWarning(): Plugin[];

package/dist/esm/node/vite/plugins/{pluginBuild → build}/pluginSuppressRollupWarning.js

@@ -1,30 +1,34 @@
 // Suppress Rollup warnings `Generated an empty chunk: "index.page.server"`
 export { pluginSuppressRollupWarning };
 function pluginSuppressRollupWarning() {
-    return {
-        name: 'vike:build:pluginSuppressRollupWarning',
-        apply: 'build',
-        enforce: 'post',
-        async configResolved(config) {
-            const onWarnOriginal = config.build.rollupOptions.onwarn;
-            config.build.rollupOptions.onwarn = function (warning, warn) {
-                // Suppress
-                if (suppressUnusedImport(warning))
-                    return;
-                if (suppressEmptyBundle(warning))
-                    return;
-                if (suppressUseClientDirective(warning))
-                    return;
-                // Pass through
-                if (onWarnOriginal) {
-                    onWarnOriginal.apply(this, arguments);
-                }
-                else {
-                    warn(warning);
-                }
-            };
+    return [
+        {
+            name: 'vike:build:pluginSuppressRollupWarning',
+            apply: 'build',
+            enforce: 'post',
+            configResolved: {
+                async handler(config) {
+                    const onWarnOriginal = config.build.rollupOptions.onwarn;
+                    config.build.rollupOptions.onwarn = function (warning, warn) {
+                        // Suppress
+                        if (suppressUnusedImport(warning))
+                            return;
+                        if (suppressEmptyBundle(warning))
+                            return;
+                        if (suppressUseClientDirective(warning))
+                            return;
+                        // Pass through
+                        if (onWarnOriginal) {
+                            onWarnOriginal.apply(this, arguments);
+                        }
+                        else {
+                            warn(warning);
+                        }
+                    };
+                },
+            },
         },
-    };
+    ];
 }
 /** Suppress warning about Rollup removing the React Server Components `"use client";` directives */
 function suppressUseClientDirective(warning) {

package/dist/esm/node/vite/plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.d.ts

@@ -0,0 +1,7 @@
+export { pluginReplaceConstantsNonRunnableDev };
+import type { Plugin } from 'vite';
+declare global {
+    var __VIKE__IS_NON_RUNNABLE_DEV: undefined | true;
+    var __VIKE__DYNAMIC_IMPORT: (module: `virtual:${string}`) => Promise<Record<string, unknown>>;
+}
+declare function pluginReplaceConstantsNonRunnableDev(): Plugin[];

package/dist/esm/node/vite/plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js

@@ -0,0 +1,47 @@
+export { pluginReplaceConstantsNonRunnableDev };
+import { isRunnableDevEnvironment, isDevCheck } from '../../utils.js';
+import { getMagicString } from '../../shared/getMagicString.js';
+// - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because we don't have access to `this.environment` and therefore we cannot call `isRunnableDevEnvironment(this.environment)` inside a configEnvironment() hook.
+// - We cannot use [`filter.id`](https://rolldown.rs/plugins/hook-filters) because Vite's optimizeDeps bundles packages (e.g. `vike` or `telefunc`) into node_modules/.vite/deps_ssr/chunk-WBC5FHD7.js
+const IS_NON_RUNNABLE_DEV = 'globalThis.__VIKE__IS_NON_RUNNABLE_DEV';
+const DYNAMIC_IMPORT = '__VIKE__DYNAMIC_IMPORT';
+function pluginReplaceConstantsNonRunnableDev() {
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsNonRunnableDev:IS_NON_RUNNABLE_DEV',
+            apply: (_, configEnv) => isDevCheck(configEnv),
+            transform: {
+                filter: {
+                    code: {
+                        include: IS_NON_RUNNABLE_DEV,
+                    },
+                },
+                handler(code, id) {
+                    if (isRunnableDevEnvironment(this.environment))
+                        return;
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    magicString.replaceAll(IS_NON_RUNNABLE_DEV, JSON.stringify(true));
+                    return getMagicStringResult();
+                },
+            },
+        },
+        {
+            name: 'vike:pluginReplaceConstantsNonRunnableDev:DYNAMIC_IMPORT',
+            apply: (_, configEnv) => isDevCheck(configEnv),
+            transform: {
+                filter: {
+                    code: {
+                        include: DYNAMIC_IMPORT,
+                    },
+                },
+                handler(code, id) {
+                    if (isRunnableDevEnvironment(this.environment))
+                        return;
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    magicString.replaceAll(DYNAMIC_IMPORT, 'import');
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}

package/dist/esm/node/vite/plugins/{pluginNonRunnableDev.d.ts → non-runnable-dev/pluginViteRPC.d.ts}

@@ -1,6 +1,6 @@
-export { pluginNonRunnableDev };
+export { pluginViteRPC };
 import type { Plugin, ViteDevServer } from 'vite';
-import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
 export type ViteRPC = ReturnType<typeof getViteRpcFunctions>;
 declare function getViteRpcFunctions(viteDevServer: ViteDevServer): {
     transformIndexHtmlRPC(html: string): Promise<string>;
@@ -19,8 +19,4 @@ declare function getViteRpcFunctions(viteDevServer: ViteDevServer): {
         };
     }>;
 };
-declare global {
-    var __VIKE__DYNAMIC_IMPORT: (module: string) => Promise<Record<string, unknown>>;
-    var __VIKE__IS_NON_RUNNABLE_DEV: undefined | boolean;
-}
-declare function pluginNonRunnableDev(): Plugin;
+declare function pluginViteRPC(): Plugin[];

package/dist/esm/node/vite/plugins/non-runnable-dev/pluginViteRPC.js

@@ -0,0 +1,30 @@
+export { pluginViteRPC };
+import { createViteRPC, isDevCheck } from '../../utils.js';
+import { retrievePageAssetsDev } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
+import { getViteConfigRuntime } from '../../shared/getViteConfigRuntime.js';
+function getViteRpcFunctions(viteDevServer) {
+    return {
+        async transformIndexHtmlRPC(html) {
+            return await viteDevServer.transformIndexHtml('/', html);
+        },
+        async retrievePageAssetsDevRPC(clientDependencies, clientEntries) {
+            return await retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries);
+        },
+        async getViteConfigRuntimeRPC() {
+            return getViteConfigRuntime(viteDevServer.config);
+        },
+    };
+}
+function pluginViteRPC() {
+    return [
+        {
+            name: 'vike:pluginViteRPC:1',
+            apply: (_, configEnv) => isDevCheck(configEnv),
+            configureServer: {
+                handler(viteDevServer) {
+                    createViteRPC(viteDevServer, getViteRpcFunctions);
+                },
+            },
+        },
+    ];
+}

package/dist/esm/node/vite/plugins/pluginBaseUrls.d.ts

@@ -1,3 +1,3 @@
 export { pluginBaseUrls };
 import type { Plugin } from 'vite';
-declare function pluginBaseUrls(): Plugin;
+declare function pluginBaseUrls(): Plugin[];

package/dist/esm/node/vite/plugins/pluginBaseUrls.js

@@ -4,40 +4,46 @@ import { assert } from '../utils.js';
 import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 function pluginBaseUrls() {
     let basesResolved;
-    return {
-        name: 'vike:pluginBaseUrls',
-        enforce: 'post',
-        async config(config) {
-            const isDev = config._isDev;
-            assert(typeof isDev === 'boolean');
-            const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            const vikeConfig = await getVikeConfigInternal();
-            basesResolved = resolveBase(baseViteOriginal, vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null);
-            // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
-            process.env.BASE_SERVER = basesResolved.baseServer;
-            process.env.BASE_ASSETS = basesResolved.baseAssets;
-            return {
-                envPrefix: [
-                    'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
-                    'BASE_SERVER',
-                    'BASE_ASSETS',
-                ],
-                base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
-                _baseViteOriginal: baseViteOriginal,
-            };
+    return [
+        {
+            name: 'vike:pluginBaseUrls',
+            enforce: 'post',
+            config: {
+                async handler(config) {
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
+                    const vikeConfig = await getVikeConfigInternal();
+                    basesResolved = resolveBase(baseViteOriginal, vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null);
+                    // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
+                    process.env.BASE_SERVER = basesResolved.baseServer;
+                    process.env.BASE_ASSETS = basesResolved.baseAssets;
+                    return {
+                        envPrefix: [
+                            'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
+                            'BASE_SERVER',
+                            'BASE_ASSETS',
+                        ],
+                        base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
+                        _baseViteOriginal: baseViteOriginal,
+                    };
+                },
+            },
+            configResolved: {
+                async handler(config) {
+                    const vikeConfig = await getVikeConfigInternal();
+                    const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null, config);
+                    assert(basesResolved2.baseServer === basesResolved.baseServer);
+                    assert(basesResolved2.baseAssets === basesResolved.baseAssets);
+                    /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
+                 *  - In dev, Vite removes the URL origin. (I.e. it resolves the user config `vite.config.js#base: 'http://localhost:8080/cdn/'` to resolved config `config.base === '/cdn/'`.)
+                 *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
+                assert(config.base === baseAssets)
+                */
+                },
+            },
         },
-        async configResolved(config) {
-            const vikeConfig = await getVikeConfigInternal();
-            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null, config);
-            assert(basesResolved2.baseServer === basesResolved.baseServer);
-            assert(basesResolved2.baseAssets === basesResolved.baseAssets);
-            /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
-             *  - In dev, Vite removes the URL origin. (I.e. it resolves the user config `vite.config.js#base: 'http://localhost:8080/cdn/'` to resolved config `config.base === '/cdn/'`.)
-             *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
-            assert(config.base === baseAssets)
-            */
-        },
-    };
+    ];
 }
 function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
     let baseViteOriginal = config._baseViteOriginal;