fix: make isBundled per environment

packages/vite/src/node/__tests__/plugins/define.spec.ts

@@ -27,6 +27,9 @@ async function createDefinePluginTransform(
       )
       return result?.code || result
     } else {
+      const nativeDefinePlugin = await (
+        definePlugin(config) as any
+      ).applyToEnvironment(environment)
       const bundler = await rolldown({
         input: 'entry.js',
         plugins: [
@@ -45,9 +48,7 @@ async function createDefinePluginTransform(
           },
           {
             name: 'native:define',
-            options: (definePlugin(config).options! as any).bind({
-              environment,
-            }),
+            options: nativeDefinePlugin.options.bind({ environment }),
           },
         ],
         experimental: {

packages/vite/src/node/build.ts

@@ -512,18 +512,24 @@ export function resolveBuildPlugins(config: ResolvedConfig): {
       ...(isBuild && !config.isWorker ? [prepareOutDirPlugin()] : []),
       perEnvironmentPlugin(
         'vite:rollup-options-plugins',
-        async (environment) =>
-          (
+        async (environment) => {
+          if (!isBuild && !environment.config.isBundled) {
+            return false
+          }
+          return (
             await asyncFlatten(
               arraify(environment.config.build.rollupOptions.plugins),
             )
-          ).filter(Boolean) as Plugin[],
+          ).filter(Boolean) as Plugin[]
+        },
       ),
       ...(config.isWorker ? [webWorkerPostPlugin(config)] : []),
     ],
     post: [
       ...(isBuild ? buildImportAnalysisPlugin(config) : []),
-      ...(config.build.minify === 'esbuild' ? [buildEsbuildPlugin()] : []),
+      ...(isBuild && config.build.minify === 'esbuild'
+        ? [buildEsbuildPlugin()]
+        : []),
       ...(isBuild ? [terserPlugin(config)] : []),
       ...(isBuild && !config.isWorker
         ? [

packages/vite/src/node/config.ts

@@ -303,6 +303,17 @@ export interface SharedEnvironmentOptions {
    * Optimize deps config
    */
   optimizeDeps?: DepOptimizationOptions
+  /**
+   * Whether this environment produces a bundled output.
+   *
+   * During `build`, this defaults to `true` for every environment.
+   * During `serve`, this defaults to `true` only for the client environment
+   * when `experimental.bundledDev` is enabled, and `false` otherwise.
+   * Setting this explicitly on an environment always overrides the default.
+   *
+   * @experimental
+   */
+  isBundled?: boolean
 }
 
 export interface EnvironmentOptions extends SharedEnvironmentOptions {
@@ -326,6 +337,7 @@ export type ResolvedEnvironmentOptions = {
   optimizeDeps: DepOptimizationOptions
   dev: ResolvedDevEnvironmentOptions
   build: ResolvedBuildEnvironmentOptions
+  isBundled: boolean
   plugins: readonly Plugin[]
   /** @internal */
   optimizeDepsPluginNames: string[]
@@ -568,7 +580,11 @@ export interface ExperimentalOptions {
    */
   hmrPartialAccept?: boolean
   /**
-   * Enable full bundle mode.
+   * Enable full bundle mode during `serve`.
+   *
+   * This seeds the default for the client environment's `isBundled` option.
+   * Other environments default to `false` during `serve`. Any environment
+   * can override its `isBundled` value via `environments[name].isBundled`.
    *
    * This is highly experimental.
    *
@@ -654,8 +670,6 @@ export interface ResolvedConfig extends Readonly<
     cacheDir: string
     command: 'build' | 'serve'
     mode: string
-    /** `true` when build or full-bundle mode dev */
-    isBundled: boolean
     isWorker: boolean
     // in nested worker bundle to find the main config
     /** @internal */
@@ -907,6 +921,7 @@ function resolveEnvironmentOptions(
   forceOptimizeDeps: boolean | undefined,
   logger: Logger,
   environmentName: string,
+  isBuild: boolean,
   isBundledDev: boolean,
   // Backward compatibility
   isSsrTargetWebworkerSet?: boolean,
@@ -918,6 +933,9 @@ function resolveEnvironmentOptions(
   const isSsrTargetWebworkerEnvironment =
     isSsrTargetWebworkerSet && environmentName === 'ssr'
 
+  const isBundled =
+    options.isBundled ?? (isBuild || (isClientEnvironment && isBundledDev))
+
   if (options.define?.['process.env']) {
     const processEnvDefine = options.define['process.env']
     if (typeof processEnvDefine === 'object') {
@@ -970,9 +988,10 @@ function resolveEnvironmentOptions(
       options.build ?? {},
       logger,
       consumer,
-      isBundledDev,
+      isBundled && !isBuild,
       isSsrTargetWebworkerEnvironment,
     ),
+    isBundled,
     plugins: undefined!, // to be resolved later
     // will be set by `setOptimizeDepsPluginNames` later
     optimizeDepsPluginNames: undefined!,
@@ -1608,6 +1627,7 @@ export async function resolveConfig(
       inlineConfig.forceOptimizeDeps,
       logger,
       environmentName,
+      isBuild,
       isBundledDev,
       config.ssr?.target === 'webworker',
       config.server?.preTransformRequests,
@@ -1900,7 +1920,6 @@ export async function resolveConfig(
     cacheDir,
     command,
     mode,
-    isBundled: config.experimental?.bundledDev || isBuild,
     isWorker: false,
     mainConfig: null,
     bundleChain: [],

packages/vite/src/node/plugins/asset.ts

@@ -475,7 +475,7 @@ async function fileToBuiltUrl(
 
     if (
       environment.config.command === 'serve' &&
-      environment.config.experimental.bundledDev
+      environment.config.isBundled
     ) {
       const outputFilename = pluginContext.getFileName(referenceId)
       url = toOutputFilePathInJSForBundledDev(environment, outputFilename)

packages/vite/src/node/plugins/clientInjections.ts

@@ -34,6 +34,9 @@ export function clientInjectionsPlugin(config: ResolvedConfig): Plugin {
 
   return {
     name: 'vite:client-inject',
+    applyToEnvironment(environment) {
+      return !environment.config.isBundled
+    },
     async buildStart() {
       injectConfigValues = await createClientConfigValueReplacer(config)
     },

packages/vite/src/node/plugins/css.ts

@@ -594,7 +594,7 @@ export function cssPostPlugin(config: ResolvedConfig): Plugin {
 
           const cssContent = await getContentWithSourcemap(css)
           const code = [
-            config.isBundled
+            this.environment.config.isBundled
               ? `const { updateStyle: __vite__updateStyle, removeStyle: __vite__removeStyle } = import.meta.hot._internal`
               : `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(
                   path.posix.join(config.base, CLIENT_PUBLIC_PATH),
@@ -1175,6 +1175,10 @@ export function cssAnalysisPlugin(config: ResolvedConfig): Plugin {
   return {
     name: 'vite:css-analysis',
 
+    applyToEnvironment(environment) {
+      return !environment.config.isBundled
+    },
+
     transform: {
       filter: {
         id: {

packages/vite/src/node/plugins/define.ts

@@ -10,7 +10,6 @@ const isNonJsRequest = (request: string): boolean => nonJsRe.test(request)
 const escapedDotRE = /(?<!\\)\\./g
 
 export function definePlugin(config: ResolvedConfig): Plugin {
-  const isBundled = config.isBundled
   const isBuild = config.command === 'build'
   const isBuildLib = isBuild && config.build.lib
 
@@ -28,27 +27,28 @@ export function definePlugin(config: ResolvedConfig): Plugin {
     })
   }
 
-  // during dev, import.meta properties are handled by importAnalysis plugin.
-  const importMetaKeys: Record<string, string> = {}
-  const importMetaEnvKeys: Record<string, string> = {}
-  const importMetaFallbackKeys: Record<string, string> = {}
-  if (isBuild) {
-    importMetaKeys['import.meta.hot'] = `undefined`
-  }
-  if (isBundled) {
-    for (const key in config.env) {
-      const val = JSON.stringify(config.env[key])
-      importMetaKeys[`import.meta.env.${key}`] = val
-      importMetaEnvKeys[key] = val
-    }
-    // these will be set to a proper value in `generatePattern`
-    importMetaKeys['import.meta.env.SSR'] = `undefined`
-    importMetaFallbackKeys['import.meta.env'] = `undefined`
-  }
-
   function generatePattern(environment: Environment) {
+    const isBundled = environment.config.isBundled
     const keepProcessEnv = environment.config.keepProcessEnv
 
+    // during dev, import.meta properties are handled by importAnalysis plugin.
+    const importMetaKeys: Record<string, string> = {}
+    const importMetaEnvKeys: Record<string, string> = {}
+    const importMetaFallbackKeys: Record<string, string> = {}
+    if (isBuild) {
+      importMetaKeys['import.meta.hot'] = `undefined`
+    }
+    if (isBundled) {
+      for (const key in config.env) {
+        const val = JSON.stringify(config.env[key])
+        importMetaKeys[`import.meta.env.${key}`] = val
+        importMetaEnvKeys[key] = val
+      }
+      // these will be set to a proper value below
+      importMetaKeys['import.meta.env.SSR'] = `undefined`
+      importMetaFallbackKeys['import.meta.env'] = `undefined`
+    }
+
     const userDefine: Record<string, string> = {}
     const userDefineEnv: Record<string, any> = {}
     for (const key in environment.config.define) {
@@ -113,24 +113,27 @@ export function definePlugin(config: ResolvedConfig): Plugin {
     return pattern
   }
 
-  if (isBundled) {
-    return {
-      name: 'vite:define',
-      options(option) {
-        const [define, _pattern, importMetaEnvVal] = getPattern(
-          this.environment,
-        )
-        define['import.meta.env'] = importMetaEnvVal
-        define['import.meta.env.*'] = 'undefined'
-        option.transform ??= {}
-        option.transform.define = { ...option.transform.define, ...define }
-      },
-    }
-  }
-
   return {
     name: 'vite:define',
 
+    applyToEnvironment(environment) {
+      if (environment.config.isBundled) {
+        return {
+          name: 'vite:define',
+          options(option) {
+            const [define, _pattern, importMetaEnvVal] = getPattern(
+              this.environment,
+            )
+            define['import.meta.env'] = importMetaEnvVal
+            define['import.meta.env.*'] = 'undefined'
+            option.transform ??= {}
+            option.transform.define = { ...option.transform.define, ...define }
+          },
+        }
+      }
+      return true
+    },
+
     transform: {
       handler(code, id) {
         if (this.environment.config.consumer === 'client') {

packages/vite/src/node/plugins/dynamicImportVars.ts

@@ -6,7 +6,7 @@ import { parseAst } from 'rolldown/parseAst'
 import { dynamicImportToGlob } from '@rollup/plugin-dynamic-import-vars'
 import { viteDynamicImportVarsPlugin as nativeDynamicImportVarsPlugin } from 'rolldown/experimental'
 import { exactRegex } from 'rolldown/filter'
-import { type Plugin, perEnvironmentPlugin } from '../plugin'
+import type { Plugin } from '../plugin'
 import type { ResolvedConfig } from '../config'
 import { CLIENT_ENTRY } from '../constants'
 import { createBackCompatIdResolver } from '../idResolver'
@@ -173,22 +173,6 @@ export function dynamicImportVarsPlugin(config: ResolvedConfig): Plugin {
     extensions: [],
   })
 
-  if (config.isBundled) {
-    return perEnvironmentPlugin('native:dynamic-import-vars', (environment) => {
-      const { include, exclude } =
-        environment.config.build.dynamicImportVarsOptions
-
-      return nativeDynamicImportVarsPlugin({
-        include,
-        exclude,
-        resolver(id, importer) {
-          return resolve(environment, id, importer)
-        },
-        sourcemap: !!environment.config.build.sourcemap,
-      })
-    })
-  }
-
   const getFilter = perEnvironmentState((environment: Environment) => {
     const { include, exclude } =
       environment.config.build.dynamicImportVarsOptions
@@ -198,6 +182,23 @@ export function dynamicImportVarsPlugin(config: ResolvedConfig): Plugin {
   return {
     name: 'vite:dynamic-import-vars',
 
+    applyToEnvironment(environment) {
+      if (environment.config.isBundled) {
+        const { include, exclude } =
+          environment.config.build.dynamicImportVarsOptions
+
+        return nativeDynamicImportVarsPlugin({
+          include,
+          exclude,
+          resolver(id, importer) {
+            return resolve(environment, id, importer)
+          },
+          sourcemap: !!environment.config.build.sourcemap,
+        })
+      }
+      return true
+    },
+
     resolveId: {
       filter: { id: exactRegex(dynamicImportHelperId) },
       handler(id) {

packages/vite/src/node/plugins/html.ts

@@ -430,6 +430,10 @@ export function buildHtmlPlugin(config: ResolvedConfig): Plugin {
   return {
     name: 'vite:build-html',
 
+    applyToEnvironment(environment) {
+      return environment.config.isBundled
+    },
+
     transform: {
       filter: { id: /\.html$/ },
       async handler(html, id) {

packages/vite/src/node/plugins/importAnalysis.ts

@@ -257,6 +257,10 @@ export function importAnalysisPlugin(config: ResolvedConfig): Plugin {
   return {
     name: 'vite:import-analysis',
 
+    applyToEnvironment(environment) {
+      return !environment.config.isBundled
+    },
+
     async transform(source, importer) {
       const environment = this.environment as DevEnvironment
       const ssr = environment.config.consumer === 'server'

packages/vite/src/node/plugins/importMetaGlob.ts

@@ -35,21 +35,24 @@ interface ParsedGeneralImportGlobOptions extends GeneralImportGlobOptions {
 }
 
 export function importGlobPlugin(config: ResolvedConfig): Plugin {
-  if (config.isBundled) {
-    return nativeImportGlobPlugin({
-      root: config.root,
-      sourcemap: !!config.build.sourcemap,
-      restoreQueryExtension: config.experimental.importGlobRestoreExtension,
-    })
-  }
-
   const importGlobMaps = new Map<
     Environment,
     Map<string, Array<(file: string) => boolean>>
   >()
 
   return {
     name: 'vite:import-glob',
+    applyToEnvironment(environment) {
+      if (environment.config.isBundled) {
+        return nativeImportGlobPlugin({
+          root: environment.config.root,
+          sourcemap: !!environment.config.build.sourcemap,
+          restoreQueryExtension:
+            environment.config.experimental.importGlobRestoreExtension,
+        })
+      }
+      return true
+    },
     buildStart() {
       importGlobMaps.clear()
     },