diff --git a/packages/vite/src/node/build.ts b/packages/vite/src/node/build.ts
index cfb1c843127924..9a2c3ae2b5d554 100644
--- a/packages/vite/src/node/build.ts
+++ b/packages/vite/src/node/build.ts
@@ -448,7 +448,7 @@ export function resolveBuildEnvironmentOptions(
     } satisfies BuildEnvironmentOptions,
     raw,
   )
-  setupRollupOptionCompat(merged)
+  setupRollupOptionCompat(merged, 'build')
   merged.rolldownOptions = {
     platform: consumer === 'server' ? 'node' : 'browser',
     ...merged.rolldownOptions,
diff --git a/packages/vite/src/node/config.ts b/packages/vite/src/node/config.ts
index 3e3ef91ec2b618..4110e04ae0b1d2 100644
--- a/packages/vite/src/node/config.ts
+++ b/packages/vite/src/node/config.ts
@@ -798,7 +798,7 @@ const configDefaults = Object.freeze({
     exclude: [],
     needsInterop: [],
     // esbuildOptions
-    rollupOptions: {},
+    rolldownOptions: {},
     /** @experimental */
     extensions: [],
     /** @deprecated @experimental */
@@ -1094,6 +1094,12 @@ function resolveDepOptimizationOptions(
   consumer: 'client' | 'server' | undefined,
   logger: Logger,
 ): DepOptimizationOptions {
+  if (
+    optimizeDeps?.rolldownOptions &&
+    optimizeDeps?.rolldownOptions === optimizeDeps?.rollupOptions
+  ) {
+    delete optimizeDeps?.rollupOptions
+  }
   const merged = mergeWithDefaults(
     {
       ...configDefaults.optimizeDeps,
@@ -1103,10 +1109,10 @@ function resolveDepOptimizationOptions(
     },
     optimizeDeps ?? {},
   )
-  setupRollupOptionCompat(merged)
+  setupRollupOptionCompat(merged, 'optimizeDeps')
 
-  const rollupOptions = merged.rollupOptions as Exclude<
-    DepOptimizationOptions['rollupOptions'],
+  const rolldownOptions = merged.rolldownOptions as Exclude<
+    DepOptimizationOptions['rolldownOptions'],
     undefined
   >
 
@@ -1116,13 +1122,13 @@ function resolveDepOptimizationOptions(
         `You or a plugin you are using have set \`optimizeDeps.esbuildOptions\` ` +
           `but this option is now deprecated. ` +
           `Vite now uses Rolldown to optimize the dependencies. ` +
-          `Please use \`optimizeDeps.rollupOptions\` instead.`,
+          `Please use \`optimizeDeps.rolldownOptions\` instead.`,
       ),
     )
 
-    rollupOptions.resolve ??= {}
-    rollupOptions.output ??= {}
-    rollupOptions.transform ??= {}
+    rolldownOptions.resolve ??= {}
+    rolldownOptions.output ??= {}
+    rolldownOptions.transform ??= {}
 
     const setResolveOptions = <
       T extends keyof Exclude<RolldownOptions['resolve'], undefined>,
@@ -1130,66 +1136,66 @@ function resolveDepOptimizationOptions(
       key: T,
       value: Exclude<RolldownOptions['resolve'], undefined>[T],
     ) => {
-      if (value !== undefined && rollupOptions.resolve![key] === undefined) {
-        rollupOptions.resolve![key] = value
+      if (value !== undefined && rolldownOptions.resolve![key] === undefined) {
+        rolldownOptions.resolve![key] = value
       }
     }
 
     if (
       merged.esbuildOptions.minify !== undefined &&
-      rollupOptions.output.minify === undefined
+      rolldownOptions.output.minify === undefined
     ) {
-      rollupOptions.output.minify = merged.esbuildOptions.minify
+      rolldownOptions.output.minify = merged.esbuildOptions.minify
     }
     if (
       merged.esbuildOptions.treeShaking !== undefined &&
-      rollupOptions.treeshake === undefined
+      rolldownOptions.treeshake === undefined
     ) {
-      rollupOptions.treeshake = merged.esbuildOptions.treeShaking
+      rolldownOptions.treeshake = merged.esbuildOptions.treeShaking
     }
     if (
       merged.esbuildOptions.define !== undefined &&
-      rollupOptions.transform.define === undefined
+      rolldownOptions.transform.define === undefined
     ) {
-      rollupOptions.transform.define = merged.esbuildOptions.define
+      rolldownOptions.transform.define = merged.esbuildOptions.define
     }
     if (merged.esbuildOptions.loader !== undefined) {
       const loader = merged.esbuildOptions.loader
-      rollupOptions.moduleTypes ??= {}
+      rolldownOptions.moduleTypes ??= {}
       for (const [key, value] of Object.entries(loader)) {
         if (
-          rollupOptions.moduleTypes[key] === undefined &&
+          rolldownOptions.moduleTypes[key] === undefined &&
           value !== 'copy' &&
           value !== 'css' &&
           value !== 'default' &&
           value !== 'file' &&
           value !== 'local-css'
         ) {
-          rollupOptions.moduleTypes[key] = value
+          rolldownOptions.moduleTypes[key] = value
         }
       }
     }
     if (
       merged.esbuildOptions.preserveSymlinks !== undefined &&
-      rollupOptions.resolve.symlinks === undefined
+      rolldownOptions.resolve.symlinks === undefined
     ) {
-      rollupOptions.resolve.symlinks = !merged.esbuildOptions.preserveSymlinks
+      rolldownOptions.resolve.symlinks = !merged.esbuildOptions.preserveSymlinks
     }
     setResolveOptions('extensions', merged.esbuildOptions.resolveExtensions)
     setResolveOptions('mainFields', merged.esbuildOptions.mainFields)
     setResolveOptions('conditionNames', merged.esbuildOptions.conditions)
     if (
       merged.esbuildOptions.keepNames !== undefined &&
-      rollupOptions.output.keepNames === undefined
+      rolldownOptions.output.keepNames === undefined
     ) {
-      rollupOptions.output.keepNames = merged.esbuildOptions.keepNames
+      rolldownOptions.output.keepNames = merged.esbuildOptions.keepNames
     }
 
     if (
       merged.esbuildOptions.platform !== undefined &&
-      rollupOptions.platform === undefined
+      rolldownOptions.platform === undefined
     ) {
-      rollupOptions.platform = merged.esbuildOptions.platform
+      rolldownOptions.platform = merged.esbuildOptions.platform
     }
 
     // NOTE: the following options cannot be converted
@@ -1232,10 +1238,10 @@ function resolveDepOptimizationOptions(
   merged.esbuildOptions ??= {}
   merged.esbuildOptions.preserveSymlinks ??= preserveSymlinks
 
-  rollupOptions.resolve ??= {}
-  rollupOptions.resolve.symlinks ??= !preserveSymlinks
-  rollupOptions.output ??= {}
-  rollupOptions.output.topLevelVar ??= true
+  rolldownOptions.resolve ??= {}
+  rolldownOptions.resolve.symlinks ??= !preserveSymlinks
+  rolldownOptions.output ??= {}
+  rolldownOptions.output.topLevelVar ??= true
 
   return merged
 }
@@ -1243,9 +1249,9 @@ function resolveDepOptimizationOptions(
 async function setOptimizeDepsPluginNames(resolvedConfig: ResolvedConfig) {
   await Promise.all(
     Object.values(resolvedConfig.environments).map(async (environment) => {
-      const plugins = environment.optimizeDeps.rollupOptions?.plugins ?? []
+      const plugins = environment.optimizeDeps.rolldownOptions?.plugins ?? []
       const outputPlugins =
-        environment.optimizeDeps.rollupOptions?.output?.plugins ?? []
+        environment.optimizeDeps.rolldownOptions?.output?.plugins ?? []
       const flattenedPlugins = await asyncFlatten([plugins, outputPlugins])
 
       const pluginNames = []
@@ -1264,9 +1270,9 @@ function applyDepOptimizationOptionCompat(resolvedConfig: ResolvedConfig) {
     resolvedConfig.optimizeDeps.esbuildOptions?.plugins &&
     resolvedConfig.optimizeDeps.esbuildOptions.plugins.length > 0
   ) {
-    resolvedConfig.optimizeDeps.rollupOptions ??= {}
-    resolvedConfig.optimizeDeps.rollupOptions.plugins ||= []
-    ;(resolvedConfig.optimizeDeps.rollupOptions.plugins as any[]).push(
+    resolvedConfig.optimizeDeps.rolldownOptions ??= {}
+    resolvedConfig.optimizeDeps.rolldownOptions.plugins ||= []
+    ;(resolvedConfig.optimizeDeps.rolldownOptions.plugins as any[]).push(
       ...resolvedConfig.optimizeDeps.esbuildOptions.plugins.map((plugin) =>
         convertEsbuildPluginToRolldownPlugin(plugin),
       ),
@@ -1296,14 +1302,14 @@ export async function resolveConfig(
 ): Promise<ResolvedConfig> {
   let config = inlineConfig
   config.build ??= {}
-  setupRollupOptionCompat(config.build)
+  setupRollupOptionCompat(config.build, 'build')
   config.worker ??= {}
-  setupRollupOptionCompat(config.worker)
+  setupRollupOptionCompat(config.worker, 'worker')
   config.optimizeDeps ??= {}
-  setupRollupOptionCompat(config.optimizeDeps)
+  setupRollupOptionCompat(config.optimizeDeps, 'optimizeDeps')
   if (config.ssr) {
     config.ssr.optimizeDeps ??= {}
-    setupRollupOptionCompat(config.ssr.optimizeDeps)
+    setupRollupOptionCompat(config.ssr.optimizeDeps, 'ssr.optimizeDeps')
   }
 
   let configFileDependencies: string[] = []
@@ -1735,7 +1741,7 @@ export async function resolveConfig(
     rollupOptions: config.worker?.rollupOptions || {},
     rolldownOptions: config.worker?.rolldownOptions, // will be set by setupRollupOptionCompat if undefined
   }
-  setupRollupOptionCompat(resolvedWorkerOptions)
+  setupRollupOptionCompat(resolvedWorkerOptions, 'worker')
 
   const base = withTrailingSlash(resolvedBase)
 
diff --git a/packages/vite/src/node/optimizer/index.ts b/packages/vite/src/node/optimizer/index.ts
index 60c1c6b4819c30..9dbb835c069f5f 100644
--- a/packages/vite/src/node/optimizer/index.ts
+++ b/packages/vite/src/node/optimizer/index.ts
@@ -760,8 +760,8 @@ async function prepareRolldownOptimizerRun(
 
   const { optimizeDeps } = environment.config
 
-  const { plugins: pluginsFromConfig = [], ...rollupOptions } =
-    optimizeDeps.rollupOptions ?? {}
+  const { plugins: pluginsFromConfig = [], ...rolldownOptions } =
+    optimizeDeps.rolldownOptions ?? {}
 
   let jsxLoader = false
   await Promise.all(
@@ -788,11 +788,11 @@ async function prepareRolldownOptimizerRun(
         // as esbuild will replace it automatically when `platform` is `'browser'`
         'process.env.NODE_ENV'
       : JSON.stringify(process.env.NODE_ENV || environment.config.mode),
-    ...rollupOptions.transform?.define,
+    ...rolldownOptions.transform?.define,
   }
 
   const platform =
-    optimizeDeps.rollupOptions?.platform ??
+    optimizeDeps.rolldownOptions?.platform ??
     // We generally don't want to use platform 'neutral', as esbuild has custom handling
     // when the platform is 'node' or 'browser' that can't be emulated by using mainFields
     // and conditions
@@ -812,24 +812,24 @@ async function prepareRolldownOptimizerRun(
   let canceled = false
   async function build() {
     const bundle = await rolldown({
-      ...rollupOptions,
+      ...rolldownOptions,
       input: flatIdDeps,
       logLevel: 'silent',
       plugins,
       platform,
       transform: {
-        ...rollupOptions.transform,
+        ...rolldownOptions.transform,
         target: ESBUILD_BASELINE_WIDELY_AVAILABLE_TARGET,
         define,
       },
       resolve: {
         extensions: ['.tsx', '.ts', '.jsx', '.js', '.css', '.json'],
-        ...rollupOptions.resolve,
+        ...rolldownOptions.resolve,
       },
       // TODO: remove this and enable rolldown's CSS support later
       moduleTypes: {
         '.css': 'js',
-        ...rollupOptions.moduleTypes,
+        ...rolldownOptions.moduleTypes,
         ...(jsxLoader ? { '.js': 'jsx' } : {}),
       },
     })
@@ -839,7 +839,7 @@ async function prepareRolldownOptimizerRun(
     }
     const result = await bundle.write({
       legalComments: 'none',
-      ...rollupOptions.output,
+      ...rolldownOptions.output,
       format: 'esm',
       sourcemap: true,
       dir: processingCacheDir,
@@ -1089,13 +1089,13 @@ export async function extractExportsData(
 
   const { optimizeDeps } = environment.config
 
-  const rollupOptions = optimizeDeps.rollupOptions ?? {}
+  const rolldownOptions = optimizeDeps.rolldownOptions ?? {}
   if (optimizeDeps.extensions?.some((ext) => filePath.endsWith(ext))) {
     // For custom supported extensions, build the entry file to transform it into JS,
     // and then parse with es-module-lexer. Note that the `bundle` option is not `true`,
     // so only the entry file is being transformed.
-    const { plugins: pluginsFromConfig = [], ...remainingRollupOptions } =
-      rollupOptions
+    const { plugins: pluginsFromConfig = [], ...remainingRolldownOptions } =
+      rolldownOptions
     const plugins = await asyncFlatten(arraify(pluginsFromConfig))
     plugins.unshift({
       name: 'externalize',
@@ -1106,17 +1106,17 @@ export async function extractExportsData(
       },
     })
     const build = await rolldown({
-      ...remainingRollupOptions,
+      ...remainingRolldownOptions,
       plugins,
       input: [filePath],
       // TODO: remove this and enable rolldown's CSS support later
       moduleTypes: {
         '.css': 'js',
-        ...remainingRollupOptions.moduleTypes,
+        ...remainingRolldownOptions.moduleTypes,
       },
     })
     const result = await build.generate({
-      ...rollupOptions.output,
+      ...rolldownOptions.output,
       format: 'esm',
       sourcemap: false,
     })
@@ -1134,7 +1134,7 @@ export async function extractExportsData(
   try {
     parseResult = parse(entryContent)
   } catch {
-    const lang = rollupOptions.moduleTypes?.[path.extname(filePath)] || 'jsx'
+    const lang = rolldownOptions.moduleTypes?.[path.extname(filePath)] || 'jsx'
     debug?.(
       `Unable to parse: ${filePath}.\n Trying again with a ${lang} transform.`,
     )
@@ -1274,14 +1274,14 @@ function getConfigHash(environment: Environment): string {
         exclude: optimizeDeps.exclude
           ? unique(optimizeDeps.exclude).sort()
           : undefined,
-        rollupOptions: {
-          ...optimizeDeps.rollupOptions,
+        rolldownOptions: {
+          ...optimizeDeps.rolldownOptions,
           plugins: undefined, // included in optimizeDepsPluginNames
           onLog: undefined,
           onwarn: undefined,
           checks: undefined,
           output: {
-            ...optimizeDeps.rollupOptions?.output,
+            ...optimizeDeps.rolldownOptions?.output,
             plugins: undefined, // included in optimizeDepsPluginNames
           },
         },
diff --git a/packages/vite/src/node/optimizer/scan.ts b/packages/vite/src/node/optimizer/scan.ts
index feba5acd76fc48..dd242545303f32 100644
--- a/packages/vite/src/node/optimizer/scan.ts
+++ b/packages/vite/src/node/optimizer/scan.ts
@@ -249,8 +249,8 @@ async function prepareRolldownScanner(
   deps: Record<string, string>,
   missing: Record<string, string>,
 ): Promise<{ build: () => Promise<void> }> {
-  const { plugins: pluginsFromConfig = [], ...rollupOptions } =
-    environment.config.optimizeDeps.rollupOptions ?? {}
+  const { plugins: pluginsFromConfig = [], ...rolldownOptions } =
+    environment.config.optimizeDeps.rolldownOptions ?? {}
 
   const plugins = await asyncFlatten(arraify(pluginsFromConfig))
 
@@ -264,7 +264,7 @@ async function prepareRolldownScanner(
   const { tsconfig } = await loadTsconfigJsonForFile(
     path.join(environment.config.root, '_dummy.js'),
   )
-  const transformOptions = deepClone(rollupOptions.transform) ?? {}
+  const transformOptions = deepClone(rolldownOptions.transform) ?? {}
   setOxcTransformOptionsFromTsconfigOptions(
     transformOptions,
     tsconfig.compilerOptions,
@@ -276,7 +276,7 @@ async function prepareRolldownScanner(
 
   async function build() {
     await scan({
-      ...rollupOptions,
+      ...rolldownOptions,
       transform: transformOptions,
       input: entries,
       logLevel: 'silent',
diff --git a/packages/vite/src/node/utils.ts b/packages/vite/src/node/utils.ts
index eb470f6170dc86..498cfd1e6f0818 100644
--- a/packages/vite/src/node/utils.ts
+++ b/packages/vite/src/node/utils.ts
@@ -1233,16 +1233,39 @@ export function mergeWithDefaults<
   return mergeWithDefaultsRecursively(clonedDefaults, values)
 }
 
+const runtimeDeprecatedPath = new Set(['optimizeDeps', 'ssr.optimizeDeps'])
+const rollupOptionsDeprecationCall = (() => {
+  return () => {
+    const method = process.env.VITE_DEPRECATION_TRACE ? 'trace' : 'warn'
+    // eslint-disable-next-line no-console
+    console[method](
+      '`optimizeDeps.rollupOptions` / `ssr.optimizeDeps.rollupOptions` is deprecated. ' +
+        'Use `optimizeDeps.rolldownOptions` instead. Note that this option may be set by a plugin. ' +
+        (method === 'trace'
+          ? 'Showing trace because VITE_DEPRECATION_TRACE is set.'
+          : 'Set VITE_DEPRECATION_TRACE=1 to see where it is called.'),
+    )
+  }
+})()
+
 export function setupRollupOptionCompat<
   T extends Pick<BuildEnvironmentOptions, 'rollupOptions' | 'rolldownOptions'>,
 >(
   buildConfig: T,
+  path: string,
 ): asserts buildConfig is T & {
   rolldownOptions: Exclude<T['rolldownOptions'], undefined>
 } {
   // if both rollupOptions and rolldownOptions are present,
   // ignore rollupOptions and use rolldownOptions
   buildConfig.rolldownOptions ??= buildConfig.rollupOptions
+  if (
+    runtimeDeprecatedPath.has(path) &&
+    buildConfig.rollupOptions &&
+    buildConfig.rolldownOptions !== buildConfig.rollupOptions
+  ) {
+    rollupOptionsDeprecationCall()
+  }
 
   // proxy rolldownOptions to rollupOptions
   Object.defineProperty(buildConfig, 'rollupOptions', {
@@ -1250,6 +1273,9 @@ export function setupRollupOptionCompat<
       return buildConfig.rolldownOptions
     },
     set(newValue) {
+      if (runtimeDeprecatedPath.has(path)) {
+        rollupOptionsDeprecationCall()
+      }
       buildConfig.rolldownOptions = newValue
     },
     configurable: true,
@@ -1291,7 +1317,7 @@ function mergeConfigRecursively(
 ) {
   const merged: Record<string, any> = { ...defaults }
   if (rollupOptionsRootPaths.has(rootPath)) {
-    setupRollupOptionCompat(merged)
+    setupRollupOptionCompat(merged, rootPath)
   }
 
   for (const key in overrides) {
diff --git a/playground/optimize-deps/vite.config.js b/playground/optimize-deps/vite.config.js
index 3bc0c05858ea83..7cc1fefc32af7d 100644
--- a/playground/optimize-deps/vite.config.js
+++ b/playground/optimize-deps/vite.config.js
@@ -34,7 +34,7 @@ export default defineConfig({
       '@vitejs/test-dep-esm-external',
       'stream',
     ],
-    rollupOptions: {
+    rolldownOptions: {
       plugins: [
         {
           name: 'replace-a-file',
@@ -122,7 +122,7 @@ function notjs() {
       return {
         optimizeDeps: {
           extensions: ['.notjs'],
-          rollupOptions: {
+          rolldownOptions: {
             plugins: [
               {
                 name: 'esbuild-notjs',