vite 6.0.0-alpha.3 → 6.0.0-alpha.5

package/dist/node/chunks/{dep-DitPlFWl.js → dep-yyboeDiN.js}

@@ -1,6 +1,6 @@
 import fs$l, { promises as promises$1, existsSync as existsSync$1, readFileSync as readFileSync$1 } from 'node:fs';
 import fsp from 'node:fs/promises';
-import path$o, { dirname as dirname$2, join as join$2, posix as posix$1, isAbsolute as isAbsolute$2, extname as extname$1, relative as relative$2, basename as basename$2 } from 'node:path';
+import path$o, { posix as posix$1, isAbsolute as isAbsolute$2, join as join$2, dirname as dirname$2, extname as extname$1, relative as relative$2, basename as basename$2 } from 'node:path';
 import { fileURLToPath, URL as URL$3, parse as parse$i, pathToFileURL } from 'node:url';
 import { promisify as promisify$4, format as format$2, inspect } from 'node:util';
 import { performance } from 'node:perf_hooks';
@@ -15158,6 +15158,34 @@ function terserPlugin(config) {
     };
 }
 
+async function resolveBoundedPlugins(environment) {
+    const resolvedPlugins = [];
+    for (const plugin of environment.config.plugins) {
+        if (plugin.create) {
+            const boundedPlugin = await plugin.create(environment);
+            if (boundedPlugin) {
+                const flatPlugins = await asyncFlattenBoundedPlugin(environment, boundedPlugin);
+                resolvedPlugins.push(...flatPlugins);
+            }
+        }
+        else {
+            resolvedPlugins.push(plugin);
+        }
+    }
+    return resolvedPlugins;
+}
+async function asyncFlattenBoundedPlugin(environment, plugins) {
+    if (!Array.isArray(plugins)) {
+        plugins = [plugins];
+    }
+    do {
+        plugins = (await Promise.all(plugins.map((p) => (p && p.split ? p.split(environment) : p))))
+            .flat(Infinity)
+            .filter(Boolean);
+    } while (plugins.some((v) => v?.then || v?.split));
+    return plugins;
+}
+
 const mimes = {
   "3g2": "video/3gpp2",
   "3gp": "video/3gpp",
@@ -29195,68 +29223,6 @@ const environmentColors = [
     colors$1.gray,
 ];
 
-// https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
-const ROOT_FILES = [
-    // '.git',
-    // https://pnpm.io/workspaces/
-    'pnpm-workspace.yaml',
-    // https://rushjs.io/pages/advanced/config_files/
-    // 'rush.json',
-    // https://nx.dev/latest/react/getting-started/nx-setup
-    // 'workspace.json',
-    // 'nx.json',
-    // https://github.com/lerna/lerna#lernajson
-    'lerna.json',
-];
-// npm: https://docs.npmjs.com/cli/v7/using-npm/workspaces#installing-workspaces
-// yarn: https://classic.yarnpkg.com/en/docs/workspaces/#toc-how-to-use-it
-function hasWorkspacePackageJSON(root) {
-    const path = join$2(root, 'package.json');
-    if (!isFileReadable(path)) {
-        return false;
-    }
-    try {
-        const content = JSON.parse(fs$l.readFileSync(path, 'utf-8')) || {};
-        return !!content.workspaces;
-    }
-    catch {
-        return false;
-    }
-}
-function hasRootFile(root) {
-    return ROOT_FILES.some((file) => fs$l.existsSync(join$2(root, file)));
-}
-function hasPackageJSON(root) {
-    const path = join$2(root, 'package.json');
-    return fs$l.existsSync(path);
-}
-/**
- * Search up for the nearest `package.json`
- */
-function searchForPackageRoot(current, root = current) {
-    if (hasPackageJSON(current))
-        return current;
-    const dir = dirname$2(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForPackageRoot(dir, root);
-}
-/**
- * Search up for the nearest workspace root
- */
-function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
-    if (hasRootFile(current))
-        return current;
-    if (hasWorkspacePackageJSON(current))
-        return current;
-    const dir = dirname$2(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForWorkspaceRoot(dir, root);
-}
-
 // An implementation of fsUtils without caching
 const commonFsUtils = {
     existsSync: fs$l.existsSync,
@@ -29332,7 +29298,7 @@ function pathUntilPart(root, parts, i) {
     return p;
 }
 function createCachedFsUtils(config) {
-    const root = normalizePath$3(searchForWorkspaceRoot(config.root));
+    const root = config.root; // root is resolved and normalized, so it doesn't have a trailing slash
     const rootDirPath = `${root}/`;
     const rootCache = { type: 'directory' }; // dirents will be computed lazily
     const getDirentCacheSync = (parts) => {
@@ -36491,34 +36457,6 @@ function esbuildCjsExternalPlugin(externals, platform) {
     };
 }
 
-async function resolveBoundedPlugins(environment) {
-    const resolvedPlugins = [];
-    for (const plugin of environment.config.plugins) {
-        if (plugin.create) {
-            const boundedPlugin = await plugin.create(environment);
-            if (boundedPlugin) {
-                const flatPlugins = await asyncFlattenBoundedPlugin(environment, boundedPlugin);
-                resolvedPlugins.push(...flatPlugins);
-            }
-        }
-        else {
-            resolvedPlugins.push(plugin);
-        }
-    }
-    return resolvedPlugins;
-}
-async function asyncFlattenBoundedPlugin(environment, plugins) {
-    if (!Array.isArray(plugins)) {
-        plugins = [plugins];
-    }
-    do {
-        plugins = (await Promise.all(plugins.map((p) => (p && p.split ? p.split(environment) : p))))
-            .flat(Infinity)
-            .filter(Boolean);
-    } while (plugins.some((v) => v?.then || v?.split));
-    return plugins;
-}
-
 // Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell
 // License: MIT.
 var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
@@ -47518,15 +47456,12 @@ class ServerHMRBroadcasterClient {
  * @experimental
  */
 class ServerHMRConnector {
-    handlers = [];
     hmrChannel;
+    handlers = [];
     hmrClient;
     connected = false;
-    constructor(server) {
-        const hmrChannel = server.hot?.channels.find((c) => c.name === 'ssr');
-        if (!hmrChannel) {
-            throw new Error("Your version of Vite doesn't support HMR during SSR. Please, use Vite 5.1 or higher.");
-        }
+    constructor(hmrChannel) {
+        this.hmrChannel = hmrChannel;
         this.hmrClient = new ServerHMRBroadcasterClient(hmrChannel);
         hmrChannel.api.outsideEmitter.on('send', (payload) => {
             this.handlers.forEach((listener) => listener(payload));
@@ -47547,8 +47482,8 @@ class ServerHMRConnector {
     }
 }
 
-function createHMROptions(server, options) {
-    if (server.config.server.hmr === false || options.hmr === false) {
+function createHMROptions(environment, options) {
+    if (environment.config.server.hmr === false || options.hmr === false) {
         return false;
     }
     if (options.hmr?.connection) {
@@ -47557,7 +47492,9 @@ function createHMROptions(server, options) {
             logger: options.hmr.logger,
         };
     }
-    const connection = new ServerHMRConnector(server);
+    if (!('api' in environment.hot))
+        return false;
+    const connection = new ServerHMRConnector(environment.hot);
     return {
         connection,
         logger: options.hmr?.logger,
@@ -47589,8 +47526,8 @@ function resolveSourceMapOptions(options) {
  * Create an instance of the Vite SSR runtime that support HMR.
  * @experimental
  */
-function createServerModuleRunner(server, environment, options = {}) {
-    const hmr = createHMROptions(server, options);
+function createServerModuleRunner(environment, options = {}) {
+    const hmr = createHMROptions(environment, options);
     return new ModuleRunner({
         ...options,
         root: environment.config.root,
@@ -47603,12 +47540,10 @@ function createServerModuleRunner(server, environment, options = {}) {
 }
 
 async function ssrLoadModule(url, server, _context = { global }, _urlStack = [], fixStacktrace) {
-    server.config.logger.warnOnce(colors$1.yellow('`ssrLoadModule` is deprecated and will be removed in the next major version. ' +
-        'Use `createServerModuleRunner(environment).import(url)` from "vite/module-runner" ' +
-        'to load modules instead.'));
     const runner = server._ssrCompatModuleRunner ||
-        (server._ssrCompatModuleRunner = createServerModuleRunner(server, server.environments.ssr, {
+        (server._ssrCompatModuleRunner = createServerModuleRunner(server.environments.ssr, {
             sourcemapInterceptor: false,
+            hmr: false,
         }));
     url = unwrapId$1(url);
     return instantiateModule(url, runner, server, fixStacktrace);
@@ -59910,6 +59845,68 @@ function notFoundMiddleware() {
     };
 }
 
+// https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
+const ROOT_FILES = [
+    // '.git',
+    // https://pnpm.io/workspaces/
+    'pnpm-workspace.yaml',
+    // https://rushjs.io/pages/advanced/config_files/
+    // 'rush.json',
+    // https://nx.dev/latest/react/getting-started/nx-setup
+    // 'workspace.json',
+    // 'nx.json',
+    // https://github.com/lerna/lerna#lernajson
+    'lerna.json',
+];
+// npm: https://docs.npmjs.com/cli/v7/using-npm/workspaces#installing-workspaces
+// yarn: https://classic.yarnpkg.com/en/docs/workspaces/#toc-how-to-use-it
+function hasWorkspacePackageJSON(root) {
+    const path = join$2(root, 'package.json');
+    if (!isFileReadable(path)) {
+        return false;
+    }
+    try {
+        const content = JSON.parse(fs$l.readFileSync(path, 'utf-8')) || {};
+        return !!content.workspaces;
+    }
+    catch {
+        return false;
+    }
+}
+function hasRootFile(root) {
+    return ROOT_FILES.some((file) => fs$l.existsSync(join$2(root, file)));
+}
+function hasPackageJSON(root) {
+    const path = join$2(root, 'package.json');
+    return fs$l.existsSync(path);
+}
+/**
+ * Search up for the nearest `package.json`
+ */
+function searchForPackageRoot(current, root = current) {
+    if (hasPackageJSON(current))
+        return current;
+    const dir = dirname$2(current);
+    // reach the fs root
+    if (!dir || dir === current)
+        return root;
+    return searchForPackageRoot(dir, root);
+}
+/**
+ * Search up for the nearest workspace root
+ */
+function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
+    if (hasRootFile(current))
+        return current;
+    if (hasWorkspacePackageJSON(current))
+        return current;
+    const dir = dirname$2(current);
+    // reach the fs root
+    if (!dir || dir === current)
+        return root;
+    return searchForWorkspaceRoot(dir, root);
+}
+
 function warmupFiles(server) {
     const { root } = server.config;
     for (const environment of Object.values(server.environments)) {
@@ -61245,6 +61242,8 @@ async function _createServer(inlineConfig = {}, options) {
     if (typeof config.server.hmr === 'object' && config.server.hmr.channels) {
         config.server.hmr.channels.forEach((channel) => hot.addChannel(channel));
     }
+    const publicFiles = await initPublicFilesPromise;
+    const { publicDir } = config;
     if (httpServer) {
         setClientErrorHandler(httpServer, config.logger);
     }
@@ -61257,6 +61256,9 @@ async function _createServer(inlineConfig = {}, options) {
             root,
             ...config.configFileDependencies,
             ...getEnvFilesForMode(config.mode, config.envDir),
+            // Watch the public directory explicitly because it might be outside
+            // of the root directory.
+            ...(publicDir && publicFiles ? [publicDir] : []),
         ], resolvedWatchOptions)
         : createNoopWatcher(resolvedWatchOptions);
     const environments = {};
@@ -61475,13 +61477,11 @@ async function _createServer(inlineConfig = {}, options) {
             process.stdin.on('end', exitProcess);
         }
     }
-    const publicFiles = await initPublicFilesPromise;
     const onHMRUpdate = async (type, file) => {
         if (serverConfig.hmr !== false) {
             await handleHMRUpdate(type, file, server);
         }
     };
-    const { publicDir } = config;
     const onFileAddUnlink = async (file, isUnlink) => {
         file = normalizePath$3(file);
         await pluginContainer.watchChange(file, {
@@ -64504,8 +64504,9 @@ async function transformDynamicImport(importSource, importer, resolve, root) {
         if (!resolvedFileName) {
             return null;
         }
-        const relativeFileName = posix$1.relative(posix$1.dirname(normalizePath$3(importer)), normalizePath$3(resolvedFileName));
-        importSource = normalizePath$3('`' + (relativeFileName[0] === '.' ? '' : './') + relativeFileName + '`');
+        const relativeFileName = normalizePath$3(posix$1.relative(posix$1.dirname(normalizePath$3(importer)), normalizePath$3(resolvedFileName)));
+        importSource =
+            '`' + (relativeFileName[0] === '.' ? '' : './') + relativeFileName + '`';
     }
     const dynamicImportPattern = parseDynamicImportPattern(importSource);
     if (!dynamicImportPattern) {
@@ -68001,7 +68002,7 @@ async function resolveBuildPlugins(config) {
  * Returns a Promise containing the build result.
  */
 async function build(inlineConfig = {}) {
-    const builder = await createViteBuilder({}, { ...inlineConfig, plugins: () => inlineConfig.plugins ?? [] });
+    const builder = await createBuilder(inlineConfig);
     if (builder.config.build.lib) {
         // TODO: temporal workaround. Should we support `libraries: Record<string, LibraryOptions & EnvironmentOptions>`
         // to build multiple libraries and be able to target different environments (for example for a Svelte components
@@ -68014,16 +68015,17 @@ async function build(inlineConfig = {}) {
         return builder.build(environment);
     }
 }
-function resolveConfigToBuild(inlineConfig = {}) {
-    return resolveConfig(inlineConfig, 'build', 'production', 'production');
+function resolveConfigToBuild(inlineConfig = {}, patchConfig) {
+    return resolveConfig(inlineConfig, 'build', 'production', 'production', false, patchConfig);
 }
 /**
  * Build an App environment, or a App library (if librayOptions is provided)
  **/
 async function buildEnvironment(config, environment, libOptions = false) {
     const options = config.build;
+    const { logger } = environment;
     const ssr = environment.name !== 'client';
-    config.logger.info(colors$1.cyan(`vite v${VERSION} ${colors$1.green(`building ${ssr ? `SSR bundle ` : ``}for ${config.mode}...`)}`));
+    logger.info(colors$1.cyan(`vite v${VERSION} ${colors$1.green(`building ${ssr ? `SSR bundle ` : ``}for ${config.mode}...`)}`));
     const resolve = (p) => path$o.resolve(config.root, p);
     const input = libOptions
         ? options.rollupOptions?.input ||
@@ -68054,9 +68056,8 @@ async function buildEnvironment(config, environment, libOptions = false) {
     }
     const outDir = resolve(options.outDir);
     // inject environment and ssr arg to plugin load/transform hooks
-    const plugins = (environment || ssr
-        ? config.plugins.map((p) => injectEnvironmentToHooks(p, environment))
-        : config.plugins);
+    // TODO: rework lib mode
+    const plugins = (libOptions ? config : environment).plugins.map((p) => injectEnvironmentToHooks(p, environment));
     const rollupOptions = {
         preserveEntrySignatures: ssr
             ? 'allow-extension'
@@ -68085,7 +68086,7 @@ async function buildEnvironment(config, environment, libOptions = false) {
     const outputBuildError = (e) => {
         const msg = mergeRollupError(e);
         clearLine();
-        config.logger.error(msg, { error: e });
+        logger.error(msg, { error: e });
     };
     let bundle;
     let startTime;
@@ -68093,7 +68094,7 @@ async function buildEnvironment(config, environment, libOptions = false) {
         const buildOutputOptions = (output = {}) => {
             // @ts-expect-error See https://github.com/vitejs/vite/issues/5812#issuecomment-984345618
             if (output.output) {
-                config.logger.warn(`You've set "rollupOptions.output.output" in your config. ` +
+                logger.warn(`You've set "rollupOptions.output.output" in your config. ` +
                     `This is deprecated and will override all Vite.js default output options. ` +
                     `Please use "rollupOptions.output" instead.`);
             }
@@ -68102,7 +68103,7 @@ async function buildEnvironment(config, environment, libOptions = false) {
                     `Please use "rollupOptions.output.dir" and "rollupOptions.output.entryFileNames" instead.`);
             }
             if (output.sourcemap) {
-                config.logger.warnOnce(colors$1.yellow(`Vite does not support "rollupOptions.output.sourcemap". ` +
+                logger.warnOnce(colors$1.yellow(`Vite does not support "rollupOptions.output.sourcemap". ` +
                     `Please use "build.sourcemap" instead.`));
             }
             const format = output.format || 'es';
@@ -68145,7 +68146,7 @@ async function buildEnvironment(config, environment, libOptions = false) {
             };
         };
         // resolve lib mode outputs
-        const outputs = resolveBuildOutputs(options.rollupOptions?.output, libOptions, config.logger);
+        const outputs = resolveBuildOutputs(options.rollupOptions?.output, libOptions, logger);
         const normalizedOutputs = [];
         if (Array.isArray(outputs)) {
             for (const resolvedOutput of outputs) {
@@ -68156,10 +68157,10 @@ async function buildEnvironment(config, environment, libOptions = false) {
             normalizedOutputs.push(buildOutputOptions(outputs));
         }
         const resolvedOutDirs = getResolvedOutDirs(config.root, options.outDir, options.rollupOptions?.output);
-        const emptyOutDir = resolveEmptyOutDir(options.emptyOutDir, config.root, resolvedOutDirs, config.logger);
+        const emptyOutDir = resolveEmptyOutDir(options.emptyOutDir, config.root, resolvedOutDirs, logger);
         // watch file changes with rollup
         if (config.build.watch) {
-            config.logger.info(colors$1.cyan(`\nwatching for file changes...`));
+            logger.info(colors$1.cyan(`\nwatching for file changes...`));
             const resolvedChokidarOptions = resolveChokidarOptions(config, config.build.watch.chokidar, resolvedOutDirs, emptyOutDir);
             const { watch } = await import('rollup');
             const watcher = watch({
@@ -68172,14 +68173,14 @@ async function buildEnvironment(config, environment, libOptions = false) {
             });
             watcher.on('event', (event) => {
                 if (event.code === 'BUNDLE_START') {
-                    config.logger.info(colors$1.cyan(`\nbuild started...`));
+                    logger.info(colors$1.cyan(`\nbuild started...`));
                     if (options.write) {
                         prepareOutDir(resolvedOutDirs, emptyOutDir, config);
                     }
                 }
                 else if (event.code === 'BUNDLE_END') {
                     event.result.close();
-                    config.logger.info(colors$1.cyan(`built in ${event.duration}ms.`));
+                    logger.info(colors$1.cyan(`built in ${event.duration}ms.`));
                 }
                 else if (event.code === 'ERROR') {
                     outputBuildError(event.error);
@@ -68198,14 +68199,14 @@ async function buildEnvironment(config, environment, libOptions = false) {
         for (const output of normalizedOutputs) {
             res.push(await bundle[options.write ? 'write' : 'generate'](output));
         }
-        config.logger.info(`${colors$1.green(`✓ built in ${displayTime(Date.now() - startTime)}`)}`);
+        logger.info(`${colors$1.green(`✓ built in ${displayTime(Date.now() - startTime)}`)}`);
         return Array.isArray(outputs) ? res : res[0];
     }
     catch (e) {
         e.message = mergeRollupError(e);
         clearLine();
         if (startTime) {
-            config.logger.error(`${colors$1.red('x')} Build failed in ${displayTime(Date.now() - startTime)}`);
+            logger.error(`${colors$1.red('x')} Build failed in ${displayTime(Date.now() - startTime)}`);
             startTime = undefined;
         }
         throw e;
@@ -68578,54 +68579,45 @@ class BuildEnvironment extends Environment {
         }
         super(name, config, options);
     }
+    async init() {
+        if (this._inited) {
+            return;
+        }
+        this._inited = true;
+        this._plugins = await resolveBoundedPlugins(this);
+    }
 }
-async function defaultBuildEnvironments(builder, build) {
+async function defaultBuildApp(builder) {
     for (const environment of Object.values(builder.environments)) {
-        await build(environment);
+        await builder.build(environment);
     }
 }
 function resolveBuilderOptions(options = {}) {
     return {
-        buildEnvironments: options.buildEnvironments ?? defaultBuildEnvironments,
+        sharedConfigBuild: options.sharedConfigBuild ?? false,
+        sharedPlugins: options.sharedPlugins ?? false,
+        entireApp: options.entireApp ?? false,
+        buildApp: options.buildApp ?? defaultBuildApp,
     };
 }
-async function createViteBuilder(builderOptions = {}, defaultBuilderInlineConfig = {}) {
-    // Plugins passed to the Builder inline config needs to be created
-    // from a factory to ensure each build has their own instances
-    const resolveConfig = (environmentOptions) => {
-        const { plugins } = defaultBuilderInlineConfig;
-        let defaultInlineConfig = plugins
-            ? {
-                ...defaultBuilderInlineConfig,
-                plugins: plugins(),
-            }
-            : defaultBuilderInlineConfig;
-        if (environmentOptions) {
-            defaultInlineConfig = mergeConfig(defaultInlineConfig, environmentOptions);
-        }
-        // We resolve the whole config including plugins here but later on we
-        // need to refactor resolveConfig to only resolve the environments config
-        return resolveConfigToBuild(defaultInlineConfig);
-    };
-    const defaultConfig = await resolveConfig();
+async function createBuilder(inlineConfig = {}) {
+    const config = await resolveConfigToBuild(inlineConfig);
     const environments = {};
     const builder = {
         environments,
-        config: defaultConfig,
-        async buildEnvironments() {
-            if (defaultConfig.build.watch) {
-                throw new Error('Watch mode is not yet supported in viteBuilder.buildEnvironments()');
+        config,
+        async buildApp() {
+            if (config.build.watch) {
+                throw new Error('Watch mode is not yet supported in viteBuilder.buildApp()');
             }
-            return defaultConfig.builder.buildEnvironments(builder, async (environment) => {
-                await this.build(environment);
-            });
+            return config.builder.buildApp(builder);
         },
         async build(environment) {
             return buildEnvironment(environment.config, environment);
         },
     };
-    for (const name of Object.keys(defaultConfig.environments)) {
-        const environmentOptions = defaultConfig.environments[name];
+    for (const name of Object.keys(config.environments)) {
+        const environmentOptions = config.environments[name];
         const createEnvironment = environmentOptions.build?.createEnvironment ??
             ((name, config) => new BuildEnvironment(name, config));
         // We need to resolve the config again so we can properly merge options
@@ -68633,8 +68625,36 @@ async function createViteBuilder(builderOptions = {}, defaultBuilderInlineConfig
         // expects plugins to be run for the same environment once they are created
         // and to process a single bundle at a time (contrary to dev mode where
         // plugins are built to handle multiple environments concurrently).
-        const environmentConfig = await resolveConfig(environmentOptions);
+        let environmentConfig = config;
+        if (!config.builder.sharedConfigBuild) {
+            const patchConfig = (resolved) => {
+                // Force opt-in shared plugins
+                const environmentPlugins = [...resolved.plugins];
+                let validMixedPlugins = true;
+                for (let i = 0; i < environmentPlugins.length; i++) {
+                    const environmentPlugin = environmentPlugins[i];
+                    const sharedPlugin = config.plugins[i];
+                    if (config.builder.sharedPlugins ||
+                        environmentPlugin.sharedDuringBuild) {
+                        if (environmentPlugin.name !== sharedPlugin.name) {
+                            validMixedPlugins = false;
+                            break;
+                        }
+                        environmentPlugins[i] = sharedPlugin;
+                    }
+                }
+                if (validMixedPlugins) {
+                    resolved.plugins = environmentPlugins;
+                }
+                resolved.build = {
+                    ...resolved.environments[name].build,
+                    lib: false,
+                };
+            };
+            environmentConfig = await resolveConfigToBuild(inlineConfig, patchConfig);
+        }
         const environment = await createEnvironment(name, environmentConfig);
+        await environment.init();
         environments[name] = environment;
     }
     return builder;
@@ -68645,8 +68665,8 @@ var build$1 = {
     BuildEnvironment: BuildEnvironment,
     build: build,
     buildEnvironment: buildEnvironment,
+    createBuilder: createBuilder,
     createToImportMetaURLBasedRelativeRuntime: createToImportMetaURLBasedRelativeRuntime,
-    createViteBuilder: createViteBuilder,
     injectEnvironmentToHooks: injectEnvironmentToHooks,
     onRollupWarning: onRollupWarning,
     resolveBuildEnvironmentOptions: resolveBuildEnvironmentOptions,
@@ -69048,7 +69068,7 @@ function resolveOptimizeDepsConfig(optimizeDeps, preserveSymlinks) {
         disabled: optimizeDeps.disabled,
     };
 }
-async function resolveConfig(inlineConfig, command, defaultMode = 'development', defaultNodeEnv = 'development', isPreview = false) {
+async function resolveConfig(inlineConfig, command, defaultMode = 'development', defaultNodeEnv = 'development', isPreview = false, patchConfig = undefined) {
     let config = inlineConfig;
     let configFileDependencies = [];
     let mode = inlineConfig.mode || defaultMode;
@@ -69125,9 +69145,9 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
     // Backward compatibility: merge optimizeDeps into environments.client.dev.optimizeDeps as defaults
     // TODO: should entries and force be in EnvironmentOptions?
     const { entries, force, ...deprecatedClientOptimizeDepsConfig } = config.optimizeDeps ?? {};
-    let configEnvironmentsClient = config.environments.client;
+    const configEnvironmentsClient = config.environments.client;
     configEnvironmentsClient.dev ??= {};
-    configEnvironmentsClient.dev.optimizeDeps = mergeConfig(configEnvironmentsClient.dev.optimizeDeps ?? {}, deprecatedClientOptimizeDepsConfig);
+    configEnvironmentsClient.dev.optimizeDeps = mergeConfig(deprecatedClientOptimizeDepsConfig, configEnvironmentsClient.dev.optimizeDeps ?? {});
     const deprecatedSsrOptimizeDepsConfig = config.ssr?.optimizeDeps ?? {};
     let configEnvironmentsSsr = config.environments.ssr;
     // Backward compatibility: server.warmup.clientFiles/ssrFiles -> environment.dev.warmup
@@ -69143,7 +69163,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
     // Backward compatibility: merge ssr into environments.ssr.config as defaults
     if (configEnvironmentsSsr) {
         configEnvironmentsSsr.dev ??= {};
-        configEnvironmentsSsr.dev.optimizeDeps = mergeConfig(configEnvironmentsSsr.dev.optimizeDeps ?? {}, deprecatedSsrOptimizeDepsConfig);
+        configEnvironmentsSsr.dev.optimizeDeps = mergeConfig(deprecatedSsrOptimizeDepsConfig, configEnvironmentsSsr.dev.optimizeDeps ?? {});
         // TODO: should we merge here?
         configEnvironmentsSsr.resolve ??= {};
         configEnvironmentsSsr.resolve.conditions ??= config.ssr?.resolve?.conditions;
@@ -69155,6 +69175,11 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
             configEnvironmentsSsr.webCompatible = true;
         }
     }
+    if (config.build?.ssrEmitAssets !== undefined) {
+        configEnvironmentsSsr ??= {};
+        configEnvironmentsSsr.build ??= {};
+        configEnvironmentsSsr.build.emitAssets = config.build.ssrEmitAssets;
+    }
     // The client and ssr environment configs can't be removed by the user in the config hook
     if (!config.environments ||
         !config.environments.client ||
@@ -69173,8 +69198,8 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
     }
     const resolvedDefaultEnvironmentResolve = resolveEnvironmentResolveOptions(config.resolve, logger);
     // Backward compatibility: merge environments.client.dev.optimizeDeps back into optimizeDeps
-    configEnvironmentsClient = resolvedEnvironments.client;
-    const patchedOptimizeDeps = mergeConfig(configEnvironmentsClient.dev?.optimizeDeps ?? {}, config.optimizeDeps ?? {});
+    const resolvedConfigEnvironmentsClient = resolvedEnvironments.client;
+    const patchedOptimizeDeps = mergeConfig(config.optimizeDeps ?? {}, resolvedConfigEnvironmentsClient.dev?.optimizeDeps ?? {});
     const backwardCompatibleOptimizeDeps = {
         holdUntilCrawlEnd: true,
         ...patchedOptimizeDeps,
@@ -69411,6 +69436,8 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         ...resolved,
     };
     resolved.plugins = await resolvePlugins(resolved, prePlugins, normalPlugins, postPlugins);
+    // Backward compatibility hook used in builder
+    patchConfig?.(resolved);
     Object.assign(resolved, createPluginHookUtils(resolved.plugins));
     // call configResolved hooks
     await Promise.all(resolved
@@ -69780,4 +69807,4 @@ function optimizeDepsDisabledBackwardCompatibility(resolved, optimizeDeps, optim
     }
 }
 
-export { resolveEnvPrefix as A, BuildEnvironment as B, index as C, DevEnvironment as D, build$1 as E, preview$1 as F, ServerHMRConnector as S, arraify as a, build as b, createServer as c, defineConfig as d, createViteBuilder as e, formatPostcssSourceMap as f, preprocessCSS as g, buildErrorMessage as h, isInNodeModules$1 as i, createNodeDevEnvironment as j, fetchModule as k, loadConfigFromFile as l, createServerModuleRunner as m, normalizePath$3 as n, mergeConfig as o, preview as p, mergeAlias as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, createFilter as u, rollupVersion as v, send$1 as w, searchForWorkspaceRoot as x, isFileServingAllowed as y, loadEnv as z };
+export { resolveEnvPrefix as A, BuildEnvironment as B, index as C, DevEnvironment as D, build$1 as E, preview$1 as F, ServerHMRConnector as S, arraify as a, build as b, createServer as c, defineConfig as d, createBuilder as e, formatPostcssSourceMap as f, preprocessCSS as g, buildErrorMessage as h, isInNodeModules$1 as i, createNodeDevEnvironment as j, fetchModule as k, loadConfigFromFile as l, createServerModuleRunner as m, normalizePath$3 as n, mergeConfig as o, preview as p, mergeAlias as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, createFilter as u, rollupVersion as v, send$1 as w, searchForWorkspaceRoot as x, isFileServingAllowed as y, loadEnv as z };

package/dist/node/cli.js

@@ -685,8 +685,7 @@ function cleanGlobalCLIOptions(options) {
  */
 function cleanBuilderCLIOptions(options) {
     const ret = { ...options };
-    delete ret.environment;
-    delete ret.all;
+    delete ret.app;
     return ret;
 }
 /**
@@ -732,7 +731,7 @@ cli
     filterDuplicateOptions(options);
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-DitPlFWl.js').then(function (n) { return n.C; });
+    const { createServer } = await import('./chunks/dep-yyboeDiN.js').then(function (n) { return n.C; });
     try {
         const server = await createServer({
             root,
@@ -810,10 +809,10 @@ cli
     .option('--emptyOutDir', `[boolean] force empty outDir when it's outside of root`)
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .option('--environment [name]', `[string] build a single environment`)
-    .option('--all', `[boolean] build all environments`)
+    .option('--app', `[boolean] same as builder.entireApp`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { build, createViteBuilder } = await import('./chunks/dep-DitPlFWl.js').then(function (n) { return n.E; });
+    const { createBuilder, buildEnvironment } = await import('./chunks/dep-yyboeDiN.js').then(function (n) { return n.E; });
     const buildOptions = cleanGlobalCLIOptions(cleanBuilderCLIOptions(options));
     const config = {
         root,
@@ -825,22 +824,19 @@ cli
         build: buildOptions,
     };
     try {
-        if (options.all || options.environment) {
-            const builder = await createViteBuilder({}, config);
-            if (options.environment) {
-                const environment = builder.environments[options.environment];
-                if (!environment) {
-                    throw new Error(`The environment ${options.environment} isn't configured.`);
-                }
-                await builder.build(environment);
-            }
-            else {
-                // --all: build all environments
-                await builder.buildEnvironments();
-            }
+        const builder = await createBuilder(config);
+        // TODO: Backward compatibility with lib and single environment build
+        // Ideally we would move to only building the entire app with this command
+        if (builder.config.build.lib) {
+            await buildEnvironment(builder.config, builder.environments.client, builder.config.build.lib);
+        }
+        else if (builder.config.builder.entireApp || options.app) {
+            await builder.buildApp();
         }
         else {
-            await build(config);
+            const ssr = !!builder.config.build.ssr;
+            const environment = builder.environments[ssr ? 'ssr' : 'client'];
+            await builder.build(environment);
         }
     }
     catch (e) {
@@ -892,7 +888,7 @@ cli
     .option('--outDir <dir>', `[string] output directory (default: dist)`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-DitPlFWl.js').then(function (n) { return n.F; });
+    const { preview } = await import('./chunks/dep-yyboeDiN.js').then(function (n) { return n.F; });
     try {
         const server = await preview({
             root,

package/dist/node/index.d.ts

@@ -2932,21 +2932,22 @@ declare class BuildEnvironment extends Environment {
     constructor(name: string, config: ResolvedConfig, setup?: {
         options?: EnvironmentOptions;
     });
+    init(): Promise<void>;
 }
 interface ViteBuilder {
     environments: Record<string, BuildEnvironment>;
     config: ResolvedConfig;
-    buildEnvironments(): Promise<void>;
+    buildApp(): Promise<void>;
     build(environment: BuildEnvironment): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
 }
 interface BuilderOptions {
-    buildEnvironments?: (builder: ViteBuilder, build: (environment: BuildEnvironment) => Promise<void>) => Promise<void>;
+    sharedConfigBuild?: boolean;
+    sharedPlugins?: boolean;
+    entireApp?: boolean;
+    buildApp?: (builder: ViteBuilder) => Promise<void>;
 }
 type ResolvedBuilderOptions = Required<BuilderOptions>;
-interface BuilderInlineConfig extends Omit<InlineConfig, 'plugins'> {
-    plugins?: () => PluginOption[];
-}
-declare function createViteBuilder(builderOptions?: BuilderOptions, defaultBuilderInlineConfig?: BuilderInlineConfig): Promise<ViteBuilder>;
+declare function createBuilder(inlineConfig?: InlineConfig): Promise<ViteBuilder>;
 
 interface ESBuildOptions extends esbuild_TransformOptions {
     include?: string | RegExp | string[] | RegExp[];
@@ -3295,6 +3296,15 @@ interface BasePlugin<A = any> extends rollup.Plugin<A> {
 }
 type BoundedPlugin<A = any> = BasePlugin<A>;
 interface Plugin<A = any> extends BasePlugin<A> {
+    /**
+     * Opt-in this plugin into the shared plugins pipeline.
+     * For backward-compatibility, plugins are re-recreated for each environment
+     * during `vite build --app`
+     * We have an opt-in per plugin, and a general `builder.sharedPlugins`
+     * In a future major, we'll flip the default to be shared by default
+     * @experimental
+     */
+    sharedDuringBuild?: boolean;
     /**
      * Spawn the plugin into multiple plugins based on the environment.
      * This hook is called when the config has already been resolved, allowing to
@@ -3862,7 +3872,7 @@ interface PluginHookUtils {
     getSortedPluginHooks: <K extends keyof Plugin>(hookName: K) => NonNullable<HookHandler<Plugin[K]>>[];
 }
 type ResolveFn = (id: string, importer?: string, aliasOnly?: boolean, ssr?: boolean) => Promise<string | undefined>;
-declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean): Promise<ResolvedConfig>;
+declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean, patchConfig?: ((config: ResolvedConfig) => void) | undefined): Promise<ResolvedConfig>;
 declare function sortUserPlugins(plugins: (Plugin | Plugin[])[] | undefined): [Plugin[], Plugin[], Plugin[]];
 declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel, customLogger?: Logger): Promise<{
     path: string;
@@ -3894,18 +3904,18 @@ interface ServerModuleRunnerOptions extends Omit<ModuleRunnerOptions, 'root' | '
  * Create an instance of the Vite SSR runtime that support HMR.
  * @experimental
  */
-declare function createServerModuleRunner(server: ViteDevServer, environment: DevEnvironment, options?: ServerModuleRunnerOptions): ModuleRunner;
+declare function createServerModuleRunner(environment: DevEnvironment, options?: ServerModuleRunnerOptions): ModuleRunner;
 
 /**
  * The connector class to establish HMR communication between the server and the Vite runtime.
  * @experimental
  */
 declare class ServerHMRConnector implements ModuleRunnerHMRConnection {
-    private handlers;
     private hmrChannel;
+    private handlers;
     private hmrClient;
     private connected;
-    constructor(server: ViteDevServer);
+    constructor(hmrChannel: ServerHMRChannel);
     isReady(): boolean;
     send(message: string): void;
     onUpdate(handler: (payload: HMRPayload) => void): void;
@@ -3982,4 +3992,4 @@ interface ManifestChunk {
     dynamicImports?: string[];
 }
 
-export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, BuildEnvironment, type BuildEnvironmentOptions, type BuildOptions, type BuilderOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type CommonServerOptions, type ConfigEnv, Connect, type CorsOptions, type CorsOrigin, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, DevEnvironment, type DevEnvironmentOptions, type DevEnvironmentSetup, type ESBuildOptions, type ESBuildTransformResult, EnvironmentModuleGraph, EnvironmentModuleNode, type ExperimentalOptions, type ExportsData, FSWatcher, type FetchModuleOptions, type FileSystemServeOptions, type FilterPattern, type HMRBroadcaster, type HMRBroadcasterClient, type HMRChannel, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HotUpdateContext, type HtmlTagDescriptor, HttpProxy, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InlineConfig, type InternalResolveOptions, type JsonOptions, type LegacyOptions, type LibraryFormats, type LibraryOptions, type LightningCSSOptions, type LogErrorOptions, type LogLevel, type LogOptions, type LogType, type Logger, type LoggerOptions, type Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, ModuleGraph, ModuleNode, type ModulePreloadOptions, type OptimizedDepInfo, type Plugin, type PluginContainer, type PluginHookUtils, type PluginOption, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, RemoteEnvironmentTransport, type RenderBuiltAssetUrl, type ResolveFn, type ResolveModulePreloadDependenciesFn, type ResolveOptions, type ResolvedBuildEnvironmentOptions, type ResolvedBuildOptions, type ResolvedCSSOptions, type ResolvedConfig, type ResolvedDevEnvironmentOptions, type ResolvedModulePreloadOptions, type ResolvedPreviewOptions, type ResolvedSSROptions, type ResolvedServerOptions, type ResolvedServerUrls, type ResolvedUrl, type ResolvedWorkerOptions, type ResolverFunction, type ResolverObject, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type SSROptions, type SSRTarget, type SendOptions, type ServerHMRChannel, ServerHMRConnector, type ServerHook, type ServerModuleRunnerOptions, type ServerOptions, SplitVendorChunkCache, type SsrDepOptimizationOptions, Terser, type TerserOptions, type TransformOptions, type TransformResult, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type ViteBuilder, type ViteDevServer, type WatchOptions, WebSocket, WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, WebSocketServer, build, buildErrorMessage, createFilter, createLogger, createNodeDevEnvironment, createServer, createServerModuleRunner, createViteBuilder, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };
+export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, BuildEnvironment, type BuildEnvironmentOptions, type BuildOptions, type BuilderOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type CommonServerOptions, type ConfigEnv, Connect, type CorsOptions, type CorsOrigin, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, DevEnvironment, type DevEnvironmentOptions, type DevEnvironmentSetup, type ESBuildOptions, type ESBuildTransformResult, EnvironmentModuleGraph, EnvironmentModuleNode, type ExperimentalOptions, type ExportsData, FSWatcher, type FetchModuleOptions, type FileSystemServeOptions, type FilterPattern, type HMRBroadcaster, type HMRBroadcasterClient, type HMRChannel, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HotUpdateContext, type HtmlTagDescriptor, HttpProxy, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InlineConfig, type InternalResolveOptions, type JsonOptions, type LegacyOptions, type LibraryFormats, type LibraryOptions, type LightningCSSOptions, type LogErrorOptions, type LogLevel, type LogOptions, type LogType, type Logger, type LoggerOptions, type Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, ModuleGraph, ModuleNode, type ModulePreloadOptions, type OptimizedDepInfo, type Plugin, type PluginContainer, type PluginHookUtils, type PluginOption, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, RemoteEnvironmentTransport, type RenderBuiltAssetUrl, type ResolveFn, type ResolveModulePreloadDependenciesFn, type ResolveOptions, type ResolvedBuildEnvironmentOptions, type ResolvedBuildOptions, type ResolvedCSSOptions, type ResolvedConfig, type ResolvedDevEnvironmentOptions, type ResolvedModulePreloadOptions, type ResolvedPreviewOptions, type ResolvedSSROptions, type ResolvedServerOptions, type ResolvedServerUrls, type ResolvedUrl, type ResolvedWorkerOptions, type ResolverFunction, type ResolverObject, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type SSROptions, type SSRTarget, type SendOptions, type ServerHMRChannel, ServerHMRConnector, type ServerHook, type ServerModuleRunnerOptions, type ServerOptions, SplitVendorChunkCache, type SsrDepOptimizationOptions, Terser, type TerserOptions, type TransformOptions, type TransformResult, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type ViteBuilder, type ViteDevServer, type WatchOptions, WebSocket, WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, WebSocketServer, build, buildErrorMessage, createBuilder, createFilter, createLogger, createNodeDevEnvironment, createServer, createServerModuleRunner, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };

package/dist/node/index.js

@@ -1,6 +1,6 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-DitPlFWl.js';
-export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, b as build, h as buildErrorMessage, u as createFilter, j as createNodeDevEnvironment, c as createServer, m as createServerModuleRunner, e as createViteBuilder, d as defineConfig, k as fetchModule, f as formatPostcssSourceMap, y as isFileServingAllowed, l as loadConfigFromFile, z as loadEnv, q as mergeAlias, o as mergeConfig, n as normalizePath, g as preprocessCSS, p as preview, r as resolveConfig, A as resolveEnvPrefix, v as rollupVersion, x as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-DitPlFWl.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-yyboeDiN.js';
+export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, b as build, h as buildErrorMessage, e as createBuilder, u as createFilter, j as createNodeDevEnvironment, c as createServer, m as createServerModuleRunner, d as defineConfig, k as fetchModule, f as formatPostcssSourceMap, y as isFileServingAllowed, l as loadConfigFromFile, z as loadEnv, q as mergeAlias, o as mergeConfig, n as normalizePath, g as preprocessCSS, p as preview, r as resolveConfig, A as resolveEnvPrefix, v as rollupVersion, x as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-yyboeDiN.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
 export { c as createLogger } from './chunks/dep-C7zR1Rh8.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "6.0.0-alpha.3",
+  "version": "6.0.0-alpha.5",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",
@@ -114,7 +114,7 @@
     "http-proxy": "^1.18.1",
     "launch-editor-middleware": "^2.6.1",
     "lightningcss": "^1.24.1",
-    "magic-string": "^0.30.9",
+    "magic-string": "^0.30.10",
     "micromatch": "^4.0.5",
     "mlly": "^1.6.1",
     "mrmime": "^2.0.0",
@@ -131,7 +131,7 @@
     "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-esbuild": "^6.1.1",
     "rollup-plugin-license": "^3.3.1",
-    "sass": "^1.74.1",
+    "sass": "^1.75.0",
     "sirv": "^2.0.4",
     "source-map-support": "^0.5.21",
     "strip-ansi": "^7.1.0",