Set plugin version to chylex-49

Fixes multiple cursors with vim-surround commands `cs, ds, S` (but not `ys`).

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

.github/workflows/runUiRdTests.yml

@@ -28,10 +28,12 @@ jobs:
         uses: jtalk/url-health-check-action@v3
         with:
           url: http://127.0.0.1:8082
-          max-attempts: 20
+          max-attempts: 100
           retry-delay: 10s
       - name: Tests
         run: gradle :tests:ui-rd-tests:testUi
+        env:
+          RIDER_LICENSE: ${{ secrets.RIDER_LICENSE }}
       - name: Move video
         if: always()
         run: mv tests/ui-rd-tests/video build/reports

.gitignore

@@ -32,4 +32,6 @@ vim-engine/src/main/java/com/maddyhome/idea/vim/regexp/parser/generated
 # Created by github automation
 settings.xml
 
-.kotlin
+.kotlin
+
+.claude/settings.local.json

.teamcity/_Self/Constants.kt

@@ -5,11 +5,11 @@ object Constants {
   const val EAP_CHANNEL = "eap"
   const val DEV_CHANNEL = "Dev"
 
-  const val NVIM_TESTS = "2024.3.3"
+  const val NVIM_TESTS = "2025.1"
-  const val PROPERTY_TESTS = "2024.3.3"
+  const val PROPERTY_TESTS = "2025.1"
-  const val LONG_RUNNING_TESTS = "2024.3.3"
+  const val LONG_RUNNING_TESTS = "2025.1"
-  const val RELEASE = "2024.3.3"
+  const val RELEASE = "2025.1"
 
-  const val RELEASE_DEV = "2024.3.3"
+  const val RELEASE_DEV = "2025.1"
-  const val RELEASE_EAP = "2024.3.3"
+  const val RELEASE_EAP = "2025.1"
 }

.teamcity/_Self/Project.kt

@@ -23,8 +23,8 @@ object Project : Project({
   vcsRoot(ReleasesVcsRoot)
 
   // Active tests
-  buildType(TestingBuildType("Latest EAP", "<default>", version = "LATEST-EAP-SNAPSHOT"))
+  buildType(TestingBuildType("Latest EAP", version = "LATEST-EAP-SNAPSHOT"))
-  buildType(TestingBuildType("2024.3.3", "<default>"))
+  buildType(TestingBuildType("2025.1"))
   buildType(TestingBuildType("Latest EAP With Xorg", "<default>", version = "LATEST-EAP-SNAPSHOT"))
 
   buildType(PropertyBased)

.teamcity/_Self/buildTypes/Compatibility.kt

@@ -43,6 +43,8 @@ object Compatibility : IdeaVimBuildType({
               java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.julienphalip.ideavim.peekaboo' [latest-IU] -team-city
               java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.julienphalip.ideavim.switch' [latest-IU] -team-city
               java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.julienphalip.ideavim.functiontextobj' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.miksuki.HighlightCursor' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.ugarosa.idea.edgemotion' [latest-IU] -team-city
             """.trimIndent()
     }
   }

.teamcity/_Self/buildTypes/PropertyBased.kt

@@ -24,6 +24,7 @@ object PropertyBased : IdeaVimBuildType({
 
   steps {
     gradle {
+      clearConditions()
       tasks = "clean :tests:property-tests:testPropertyBased"
       buildFile = ""
       enableStacktrace = true

.teamcity/_Self/buildTypes/TestingBuildType.kt

@@ -12,7 +12,7 @@ import jetbrains.buildServer.configs.kotlin.v2019_2.triggers.vcs
 
 open class TestingBuildType(
   private val testName: String,
-  private val branch: String,
+  private val branch: String = "<default>",
   private val version: String = testName,
   private val javaVersion: String? = null,
   private val javaPlugin: Boolean = true,

AUTHORS.md

@@ -26,6 +26,13 @@ Previous maintainers:
    
   Andrey Vlasovskikh
 
+Previous support members:
+
+* [![icon][mail]](mailto:lejia.chen@jetbrains.com)
+  [![icon][github-off]](#)
+   
+  Lejia Chen
+
 Contributors:
 
 * [![icon][mail]](mailto:yole@jetbrains.com)
@@ -587,6 +594,26 @@ Contributors:
   [![icon][github]](https://github.com/Iliya-usov)
    
   Ilya Usov
+* [![icon][mail]](mailto:peterHoburg@users.noreply.github.com)
+  [![icon][github]](https://github.com/peterHoburg)
+   
+  Peter Hoburg
+* [![icon][mail]](mailto:erotourtes@gmail.com)
+  [![icon][github]](https://github.com/erotourtes)
+   
+  Max Siryk
+* [![icon][mail]](mailto:ivan.yarkov@jetbrains.com)
+  [![icon][github]](https://github.com/MToolMakerJB)
+   
+  Ivan Yarkov
+* [![icon][mail]](mailto:mia.vucinic@jetbrains.com)
+  [![icon][github]](https://github.com/vumi19)
+   
+  Mia Vucinic
+* [![icon][mail]](mailto:canava.thomas@gmail.com)
+  [![icon][github]](https://github.com/Malandril)
+   
+  Thomas Canava
 
 Previous contributors:
 

README.md

@@ -29,8 +29,8 @@ IdeaVim is a Vim engine for JetBrains IDEs.
 
 #### Compatibility
 
-IntelliJ IDEA, PyCharm, CLion, PhpStorm, WebStorm, RubyMine, DataGrip, GoLand, Rider, Cursive,
+IntelliJ IDEA, PyCharm, GoLand, CLion, PhpStorm, WebStorm, RubyMine, DataGrip, DataSpell, Rider, Cursive,
-Android Studio and other IntelliJ platform based IDEs.
+Android Studio, and other [JetBrains IDEs](https://www.jetbrains.com/ides/).
 
 Setup
 ------------
@@ -89,29 +89,12 @@ Here are some examples of supported vim features and commands:
 * Full Vim regexps for search and search/replace
 * Vim web help
 * `~/.ideavimrc` configuration file
-
+* Vim script
-[IdeaVim plugins](https://github.com/JetBrains/ideavim/wiki/IdeaVim-Plugins):
+* IdeaVim plugins
-
-* vim-easymotion
-* NERDTree
-* vim-surround
-* vim-multiple-cursors
-* vim-commentary
-* argtextobj.vim
-* vim-textobj-entire
-* ReplaceWithRegister
-* vim-exchange
-* vim-highlightedyank
-* vim-paragraph-motion
-* vim-indent-object
-* match.it  
-etc
 
 See also:
 
 * [Top feature requests and bugs](https://youtrack.jetbrains.com/issues/VIM?q=%23Unresolved+sort+by%3A+votes)
-* [Vimscript support roadmap](vimscript-info/VIMSCRIPT_ROADMAP.md)
-* [List of supported in-build functions](vimscript-info/FUNCTIONS_INFO.MD)
 
 Files
 -----
@@ -265,8 +248,7 @@ IdeaVim can execute custom scripts that are written with Vim Script.
 At the moment we support all language features, but not all of the built-in functions and options are supported.
 
 Additionally, you may be interested in the
-[Vim Script Discussion](https://github.com/JetBrains/ideavim/discussions/357) or
+[Vim Script Discussion](https://github.com/JetBrains/ideavim/discussions/357).
-[Vim Script Roadmap](https://github.com/JetBrains/ideavim/blob/master/vimscript-info/VIMSCRIPT_ROADMAP.md).
 
 
 ### IDE specific options

annotation-processors/build.gradle.kts

@@ -21,7 +21,7 @@ repositories {
 }
 
 dependencies {
-  compileOnly("com.google.devtools.ksp:symbol-processing-api:2.1.10-1.0.29")
+  compileOnly("com.google.devtools.ksp:symbol-processing-api:2.1.21-2.0.1")
   implementation("org.jetbrains.kotlinx:kotlinx-serialization-json-jvm:$kotlinxSerializationVersion") {
     // kotlin stdlib is provided by IJ, so there is no need to include it into the distribution
     exclude("org.jetbrains.kotlin", "kotlin-stdlib")

build.gradle.kts

@@ -31,6 +31,7 @@ import kotlinx.serialization.json.putJsonObject
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.RepositoryBuilder
 import org.intellij.markdown.ast.getTextInNode
+import org.intellij.markdown.ast.impl.ListCompositeNode
 import org.jetbrains.changelog.Changelog
 import org.jetbrains.intellij.platform.gradle.TestFrameworkType
 import org.jetbrains.intellij.platform.gradle.tasks.aware.SplitModeAware
@@ -50,14 +51,14 @@ buildscript {
     classpath("org.eclipse.jgit:org.eclipse.jgit:6.6.0.202305301015-r")
 
     // This is needed for jgit to connect to ssh
-    classpath("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:7.1.0.202411261347-r")
+    classpath("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:7.2.1.202505142326-r")
     classpath("org.kohsuke:github-api:1.305")
 
-    classpath("io.ktor:ktor-client-core:3.1.1")
+    classpath("io.ktor:ktor-client-core:3.1.3")
-    classpath("io.ktor:ktor-client-cio:3.1.1")
+    classpath("io.ktor:ktor-client-cio:3.1.3")
-    classpath("io.ktor:ktor-client-auth:3.1.1")
+    classpath("io.ktor:ktor-client-auth:3.1.3")
-    classpath("io.ktor:ktor-client-content-negotiation:3.1.1")
+    classpath("io.ktor:ktor-client-content-negotiation:3.1.3")
-    classpath("io.ktor:ktor-serialization-kotlinx-json:3.1.1")
+    classpath("io.ktor:ktor-serialization-kotlinx-json:3.1.3")
 
     // This comes from the changelog plugin
 //        classpath("org.jetbrains:markdown:0.3.1")
@@ -69,7 +70,12 @@ plugins {
   kotlin("jvm") version "2.0.21"
   application
   id("java-test-fixtures")
-  id("org.jetbrains.intellij.platform") version "2.3.0"
+
+  // NOTE: Unignore "test block comment falls back to line comment when not available" test
+  //   After changing this version. It supposed to work on the next version of the gradle plugin
+  //   Or go report to the devs that this test still fails.
+  id("org.jetbrains.intellij.platform") version "2.6.0"
+
   id("org.jetbrains.changelog") version "2.2.1"
   id("org.jetbrains.kotlinx.kover") version "0.6.1"
   id("com.dorongold.task-tree") version "4.0.1"
@@ -112,7 +118,11 @@ dependencies {
   intellijPlatform {
     // Snapshots don't use installers
     // https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-dependencies-extension.html#target-versions-installers
-    val useInstaller = "EAP-SNAPSHOT" !in ideaVersion
+    var useInstaller = "EAP-SNAPSHOT" !in ideaVersion
+    if (ideaType == "RD") {
+      // Using Rider as a target IntelliJ Platform with `useInstaller = true` is currently not supported, please set `useInstaller = false` instead. See: https://github.com/JetBrains/intellij-platform-gradle-plugin/issues/1852
+      useInstaller = false
+    }
 
     // Note that it is also possible to use local("...") to compile against a locally installed IDE
     // E.g. local("/Users/{user}/Applications/IntelliJ IDEA Ultimate.app")
@@ -127,8 +137,9 @@ dependencies {
 
     // AceJump is an optional dependency. We use their SessionManager class to check if it's active
     plugin("AceJump", "3.8.19")
+    plugin("com.intellij.classic.ui", "251.23774.318")
 
-    bundledPlugins("org.jetbrains.plugins.terminal", "com.intellij.modules.json")
+    bundledPlugins("org.jetbrains.plugins.terminal")
   }
 
   moduleSources(project(":vim-engine", "sourcesJarArtifacts"))
@@ -150,17 +161,17 @@ dependencies {
   // https://mvnrepository.com/artifact/org.mockito.kotlin/mockito-kotlin
   testImplementation("org.mockito.kotlin:mockito-kotlin:5.4.0")
 
-  testImplementation("org.junit.jupiter:junit-jupiter-api:5.12.0")
+  testImplementation("org.junit.jupiter:junit-jupiter-api:5.13.0")
-  testImplementation("org.junit.jupiter:junit-jupiter-engine:5.12.0")
+  testImplementation("org.junit.jupiter:junit-jupiter-engine:5.13.0")
-  testImplementation("org.junit.jupiter:junit-jupiter-params:5.12.0")
+  testImplementation("org.junit.jupiter:junit-jupiter-params:5.13.0")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-api:5.12.0")
+  testFixturesImplementation("org.junit.jupiter:junit-jupiter-api:5.13.0")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-engine:5.12.0")
+  testFixturesImplementation("org.junit.jupiter:junit-jupiter-engine:5.13.0")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-params:5.12.0")
+  testFixturesImplementation("org.junit.jupiter:junit-jupiter-params:5.13.0")
 
   // Temp workaround suggested in https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-faq.html#junit5-test-framework-refers-to-junit4
   // Can be removed when IJPL-159134 is fixed
 //  testRuntimeOnly("junit:junit:4.13.2")
-  testImplementation("org.junit.vintage:junit-vintage-engine:5.12.0")
+  testImplementation("org.junit.vintage:junit-vintage-engine:5.13.0")
 //  testFixturesImplementation("org.junit.vintage:junit-vintage-engine:5.10.3")
 }
 
@@ -188,12 +199,9 @@ tasks {
     useJUnitPlatform()
 
     // Set teamcity env variable locally to run additional tests for leaks.
-    // By default, this test runs on TC only, but this test doesn't take a lot of time,
+    println("Project leak checks: If you experience project leaks on TeamCity that doesn't reproduce locally")
-    //   so we can turn it on for local development
+    println("Uncomment the following line in build.gradle to enable leak checks (see build.gradle config)")
-    if (environment["TEAMCITY_VERSION"] == null) {
+//      environment("TEAMCITY_VERSION" to "X")
-      println("Set env TEAMCITY_VERSION to X to enable project leak checks from the platform")
-      environment("TEAMCITY_VERSION" to "X")
-    }
 
     systemProperty("ideavim.nvim.test", System.getProperty("nvim") ?: false)
 
@@ -232,6 +240,8 @@ tasks {
   }
 
   compileTestKotlin {
+    enabled = false
+    
     kotlinOptions {
       jvmTarget = javaVersion
       apiVersion = "2.0"
@@ -247,6 +257,7 @@ tasks {
   // a custom task (see below)
   runIde {
     systemProperty("octopus.handler", System.getProperty("octopus.handler") ?: true)
+    systemProperty("idea.trust.all.projects", "true")
   }
 
   // Uncomment to run the plugin in a custom IDE, rather than the IDE specified as a compile target in dependencies
@@ -819,7 +830,9 @@ fun updateAuthors(uncheckedEmails: Set<String>) {
     org.intellij.markdown.parser.MarkdownParser(org.intellij.markdown.flavours.gfm.GFMFlavourDescriptor())
   val tree = parser.buildMarkdownTreeFromString(authors)
 
-  val contributorsSection = tree.children[24]
+  val contributorsSection = tree.children
+    .filter { it is ListCompositeNode }
+    .single { it.getTextInNode(authors).contains("yole") }
   val existingEmails = mutableSetOf<String>()
   for (child in contributorsSection.children) {
     if (child.children.size > 1) {

doc/IdeaVim Plugins.md

@@ -16,10 +16,95 @@ in `~/.ideavimrc`. E.g. `set nosurround`.
 Available plugins:
 
 <details>
-<summary><h2>easymotion</h2></summary>
+<summary><h2>argtextobj: Provides a text-object 'a' argument</h2></summary>
+
+Original plugin: [argtextobj.vim](https://www.vim.org/scripts/script.php?script_id=2699).
+
+### Summary:
+This plugin provides a text-object 'a' (argument). 
+You can d(elete), c(hange), v(select)... an argument or inner argument in familiar ways.
+
+That is, such as 'daa'(delete-an-argument) 'cia'(change-inner-argument) 'via'(select-inner-argument).
+What this script does is more than just typing
+
+F,dt,
+
+because it recognizes inclusion relationship of parentheses.
+
+### Setup:
+- Add the following command to `~/.ideavimrc`: `Plug 'vim-scripts/argtextobj.vim'`
+    <details>
+      <summary>Alternative syntax</summary>
+      <code>Plugin 'vim-scripts/argtextobj.vim'</code>
+      <br/>
+      <code>Plug 'https://github.com/vim-scripts/argtextobj.vim'</code>
+      <br/>
+      <code>Plug 'argtextobj.vim'</code>
+      <br/>
+      <code>Plug 'https://www.vim.org/scripts/script.php?script_id=2699'</code>
+      <br/>
+      <code>set argtextobj</code>
+      </details>
+
+### Instructions
+
+By default, only the arguments inside parenthesis are considered. To extend the functionality
+to other types of brackets, set `g:argtextobj_pairs` variable to a comma-separated
+list of colon-separated pairs (same as VIM's `matchpairs` option), like
+`let g:argtextobj_pairs="(:),{:},<:>"`. The order of pairs matters when
+handling symbols that can also be operators: `func(x << 5, 20) >> 17`. To handle
+this syntax parenthesis, must come before angle brackets in the list.
+
+https://www.vim.org/scripts/script.php?script_id=2699
+
+</details>
+
+<details>
+<summary><h2>commentary: Adds mapping for quickly commenting stuff out</h2></summary>
+
+By [Daniel Leong](https://github.com/dhleong)  
+Original plugin: [commentary.vim](https://github.com/tpope/vim-commentary).
+
+### Summary:
+Comment stuff out. 
+Use gcc to comment out a line (takes a count), gc to comment out the target of a motion 
+(for example, gcap to comment out a paragraph), gc in visual mode to comment out the selection, 
+and gc in operator pending mode to target a comment. 
+You can also use it as a command, either with a range like :7,17Commentary, 
+or as part of a :global invocation like with :g/TODO/Commentary. 
+That's it.
+
+### Setup:
+- Add the following command to `~/.ideavimrc`: `Plug 'tpope/vim-commentary'`
+    <details>
+      <summary>Alternative syntax</summary>
+      <code>Plugin 'tpope/vim-commentary'</code>
+      <br/>
+      <code>Plug 'https://github.com/tpope/vim-commentary'</code>
+      <br/>
+      <code>Plug 'vim-commentary'</code>
+      <br/>
+      <code>Plug 'tcomment_vim'</code>
+      <br/>
+      <code>set commentary</code>
+      </details>
+
+### Instructions
+
+https://github.com/tpope/vim-commentary/blob/master/doc/commentary.txt
+
+</details>
+
+<details>
+<summary><h2>easymotion: Simplifies some motions</h2></summary>
    
 Original plugin: [vim-easymotion](https://github.com/easymotion/vim-easymotion).
-   
+
+### Summary:
+EasyMotion provides a much simpler way to use some motions in vim. 
+It takes the \<number> out of \<number>w or \<number>f{char} by highlighting all possible choices 
+and allowing you to press one key to jump directly to the target.
+
 ### Setup:
 - Install [IdeaVim-EasyMotion](https://plugins.jetbrains.com/plugin/13360-ideavim-easymotion/)
       and [AceJump](https://plugins.jetbrains.com/plugin/7086-acejump/) plugins.
@@ -41,80 +126,176 @@ All commands with the mappings are supported. See the [full list of supported co
 
 </details>
 
-
 <details>
-<summary><h2>sneak</h2></summary>
+<summary><h2>exchange: Easy text exchange operator</h2></summary>
 
-<img src="images/sneakIcon.svg" width="80" height="80" alt="icon"/>  
+By [fan-tom](https://github.com/fan-tom)  
+Original plugin: [vim-exchange](https://github.com/tommcdo/vim-exchange).
+
+### Summary:
+Easy text exchange operator for Vim.
 
-By [Mikhail Levchenko](https://github.com/Mishkun)  
-Original repository with the plugin: https://github.com/Mishkun/ideavim-sneak  
-Original plugin: [vim-sneak](https://github.com/justinmk/vim-sneak).
-   
 ### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'justinmk/vim-sneak'`
+- Add the following command to `~/.ideavimrc`: `Plug 'tommcdo/vim-exchange'`
-   
-### Instructions
-
-* Type `s` and two chars to start sneaking in forward direction
-* Type `S` and two chars to start sneaking in backward direction
-* Type `;` or `,` to proceed with sneaking just as if you were using `f` or `t` commands
-
-</details>
-
-<details>
-<summary><h2>NERDTree</h2></summary>
-   
-Original plugin: [NERDTree](https://github.com/preservim/nerdtree).
-   
-### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'preservim/nerdtree'`
     <details>
       <summary>Alternative syntax</summary>
-      <code>Plugin 'preservim/nerdtree'</code>
+      <code>Plugin 'tommcdo/vim-exchange'</code>
       <br/>
-      <code>Plug 'https://github.com/preservim/nerdtree'</code>
+      <code>Plug 'https://github.com/tommcdo/vim-exchange'</code>
       <br/>
-      <code>Plug 'nerdtree'</code>
+      <code>Plug 'vim-exchange'</code>
       <br/>
-      <code>set NERDTree</code>
+      <code>set exchange</code>
       </details>
-   
+
 ### Instructions
-   
+
-[See here](NERDTree-support.md).
+https://github.com/tommcdo/vim-exchange/blob/master/doc/exchange.txt
 
 </details>
 
 <details>
-<summary><h2>surround</h2></summary>
+<summary><h2>FunctionTextObj: Adds text objects for manipulating functions/methods</h2></summary>
-   
+
-Original plugin: [vim-surround](https://github.com/tpope/vim-surround).
+By Julien Phalip
-   
+
+### Summary:
+An extension for IdeaVim that adds text objects for manipulating functions/methods in your code. 
+Similar to how iw operates on words or i" operates on quoted strings, 
+this plugin provides if and af to operate on functions
+
+### Setup
+
+Add `set functiontextobj` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
+or restart the IDE.
+
+### Instructions
+
+https://plugins.jetbrains.com/plugin/25897-vim-functiontextobj
+</details>
+
+<details>
+<summary><h2>highlightedyank: Highlights the yanked region</h2></summary>
+
+By [KostkaBrukowa](https://github.com/KostkaBrukowa)  
+Original plugin: [vim-highlightedyank](https://github.com/machakann/vim-highlightedyank).
+
+### Summary:
+Make the yanked region apparent!
+
 ### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'tpope/vim-surround'`
+- Add the following command to `~/.ideavimrc`: `Plug 'machakann/vim-highlightedyank'`
     <details>
       <summary>Alternative syntax</summary>
-      <code>Plugin 'tpope/vim-surround'</code>
+      <code>Plugin 'machakann/vim-highlightedyank'</code>
       <br/>
-      <code>Plug 'https://www.vim.org/scripts/script.php?script_id=1697'</code>
+      <code>Plug 'https://github.com/machakann/vim-highlightedyank'</code>
       <br/>
-      <code>Plug 'vim-surround'</code>
+      <code>Plug 'vim-highlightedyank'</code>
       <br/>
-      <code>set surround</code>
+      <code>set highlightedyank</code>
       </details>
-   
+
 ### Instructions
-   
+
-https://github.com/tpope/vim-surround/blob/master/doc/surround.txt
+If you want to optimize highlight duration, assign a time in milliseconds:  
+`let g:highlightedyank_highlight_duration = "1000"`  
+A negative number makes the highlight persistent.
+
+If you want to change background color of highlight you can provide the rgba of the color you want e.g.  
+`let g:highlightedyank_highlight_color = "rgba(160, 160, 160, 155)"`
+
+If you want to change text color of highlight you can provide the rgba of the color you want e.g.  
+`let g:highlightedyank_highlight_foreground_color = "rgba(0, 0, 0, 255)"`
+
+https://github.com/machakann/vim-highlightedyank/blob/master/doc/highlightedyank.txt
 
 </details>
 
 <details>
-<summary><h2>multiple-cursors</h2></summary>
+<summary><h2>indent-object: Adds text objects for manipulating sentences/paragraphs/etc...</h2></summary>
-   
+
+By [Shrikant Sharat Kandula](https://github.com/sharat87)  
+Original plugin: [vim-indent-object](https://github.com/michaeljsmith/vim-indent-object).
+
+### Summary:
+Vim text objects provide a convenient way to select and operate on various types of objects. 
+These objects include regions surrounded by various types of brackets and various parts of language 
+(ie sentences, paragraphs, etc).
+
+### Setup:
+- Add the following command to `~/.ideavimrc`: `Plug 'michaeljsmith/vim-indent-object'`
+    <details>
+      <summary>Alternative syntax</summary>
+      <code>Plugin 'michaeljsmith/vim-indent-object'</code>
+      <br/>
+      <code>Plug 'https://github.com/michaeljsmith/vim-indent-object'</code>
+      <br/>
+      <code>Plug 'vim-indent-object'</code>
+      <br/>
+      <code>set textobj-indent</code>
+      </details>
+
+### Instructions
+
+https://github.com/michaeljsmith/vim-indent-object/blob/master/doc/indent-object.txt
+
+</details>
+
+<details>
+<summary><h2>matchit.vim: Extends the % key functionality</h2></summary>
+
+By [Martin Yzeiri](https://github.com/myzeiri)
+Original plugin: [matchit.vim](https://github.com/chrisbra/matchit).
+
+### Summary:
+In Vim, as in plain vi, the percent key, |%|, jumps the cursor from a brace, bracket, or paren to its match. 
+This can be configured with the 'matchpairs' option. 
+The matchit plugin extends this in several ways...
+
+### Setup:
+- Add the following command to `~/.ideavimrc`: `packadd matchit`
+    <details>
+      <summary>Alternative syntax</summary>
+      <code>Plug 'vim-matchit'</code>
+      <br/>
+      <code>Plug 'chrisbra/matchit'</code>
+      <br/>
+      <code>set matchit</code>
+      </details>
+
+### Instructions
+
+https://github.com/adelarsq/vim-matchit/blob/master/doc/matchit.txt
+
+</details>
+
+<details>
+<summary><h2>Mini.ai: Extend and create a/i textobjects (IMPORTANT: The plugin is not related with artificial intelligence)</h2></summary>
+
+### Summary:
+Extend and create a/i textobjects
+
+### Features:
+Provides additional text object motions for handling quotes and brackets. The following motions are included:
+
+- aq: Around any quotes.
+- iq: Inside any quotes.
+- ab: Around any parentheses, curly braces, and square brackets.
+- ib: Inside any parentheses, curly braces, and square brackets.
+
+Original plugin: [mini.ai](https://github.com/echasnovski/mini.ai).
+
+### Setup:
+- Add the following command to `~/.ideavimrc`: `set mini-ai`
+
+</details>
+
+<details>
+<summary><h2>multiple-cursors: Extends multicursor support</h2></summary>
+
 Original plugin: [vim-multiple-cursors](https://github.com/terryma/vim-multiple-cursors).
-   
+
 ### Setup:
 - Add the following command to `~/.ideavimrc`: `Plug 'terryma/vim-multiple-cursors'`
     <details>
@@ -127,7 +308,7 @@ Original plugin: [vim-multiple-cursors](https://github.com/terryma/vim-multiple-
       <br/>
       <code>set multiple-cursors</code>
       </details>
-   
+
 ### Instructions
 
 At the moment, the default key binds for this plugin do not get mapped correctly in IdeaVim (see [VIM-2178](https://youtrack.jetbrains.com/issue/VIM-2178)). To enable the default key binds, add the following to your `.ideavimrc` file...
@@ -153,38 +334,118 @@ xmap <leader>g<C-n> <Plug>AllOccurrences
 </details>
 
 <details>
-<summary><h2>commentary</h2></summary>
+<summary><h2>NERDTree: Adds NERDTree navigation to the project panel</h2></summary>
+   
+Original plugin: [NERDTree](https://github.com/preservim/nerdtree).
 
-By [Daniel Leong](https://github.com/dhleong)  
+### Summary:
-Original plugin: [commentary.vim](https://github.com/tpope/vim-commentary).
+Adds NERDTree navigation to the project panel. 
    
 ### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'tpope/vim-commentary'`
+- Add the following command to `~/.ideavimrc`: `Plug 'preservim/nerdtree'`
     <details>
       <summary>Alternative syntax</summary>
-      <code>Plugin 'tpope/vim-commentary'</code>
+      <code>Plugin 'preservim/nerdtree'</code>
       <br/>
-      <code>Plug 'https://github.com/tpope/vim-commentary'</code>
+      <code>Plug 'https://github.com/preservim/nerdtree'</code>
       <br/>
-      <code>Plug 'vim-commentary'</code>
+      <code>Plug 'nerdtree'</code>
       <br/>
-      <code>Plug 'tcomment_vim'</code>
+      <code>set NERDTree</code>
-      <br/>
-      <code>set commentary</code>
       </details>
    
 ### Instructions
    
-https://github.com/tpope/vim-commentary/blob/master/doc/commentary.txt
+[See here](NERDTree-support.md).
 
 </details>
 
 <details>
-<summary><h2>ReplaceWithRegister</h2></summary>
+<summary><h2>paragraph-motion: Extends the { and } motions to ignore whitespace on otherwise empty lines</h2></summary>
-   
+
+Original plugin: [vim-paragraph-motion](https://github.com/dbakker/vim-paragraph-motion).
+
+### Summary:
+Normally the { and } motions only match completely empty lines. 
+With this plugin lines that only contain whitespace are also matched.
+
+### Setup:
+- Add the following command to `~/.ideavimrc`: `Plug 'dbakker/vim-paragraph-motion'`
+    <details>
+      <summary>Alternative syntax</summary>
+      <code>Plugin 'dbakker/vim-paragraph-motion'</code>
+      <br/>
+      <code>Plug 'https://github.com/dbakker/vim-paragraph-motion'</code>
+      <br/>
+      <code>Plug 'vim-paragraph-motion'</code>
+      <br/>
+      <code>Plug 'https://github.com/vim-scripts/Improved-paragraph-motion'</code>
+      <br/>
+      <code>Plug 'vim-scripts/Improved-paragraph-motion'</code>
+      <br/>
+      <code>Plug 'Improved-paragraph-motion'</code>
+      <br/>
+      <code>set vim-paragraph-motion</code>
+      </details>
+
+### Instructions
+
+https://github.com/dbakker/vim-paragraph-motion#vim-paragraph-motion
+
+</details>
+
+<details>
+<summary><h2>Peekaboo: Extends " @ CTRL-r to show a popup of the register contents</h2></summary>
+
+By Julien Phalip  
+Original plugin: [vim-peekaboo](https://github.com/junegunn/vim-peekaboo).
+
+### Summary:
+Peekaboo extends " and @ in normal mode and <CTRL-R> in insert mode so you can see the contents of the registers.
+
+### Setup
+
+Add `set peekaboo` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
+or restart the IDE.
+
+### Instructions
+
+https://plugins.jetbrains.com/plugin/25776-vim-peekaboo
+</details>
+
+<details>
+<summary><h2>quick-scope: Always-on highlight for a unique character in every word on a line to help use f, F, etc.</h2></summary>
+
+Original plugin: [quick-scope](https://github.com/unblevable/quick-scope).
+
+### Summary:
+An always-on highlight for a unique character in every word on a line to help you use f, F and family.
+
+This plugin should help you get to any word on a line in two or three keystrokes with Vim's built-in f<char> 
+(which moves your cursor to <char>).
+
+### Setup:
+- Install [IdeaVim-Quickscope](https://plugins.jetbrains.com/plugin/19417-ideavim-quickscope) plugin.
+- Add the following command to `~/.ideavimrc`: `set quickscope`
+
+### Instructions
+
+https://plugins.jetbrains.com/plugin/19417-ideavim-quickscope
+
+</details>
+
+<details>
+<summary><h2>ReplaceWithRegister: Adds two-in-one command that replaces text with the contents of a register.</h2></summary>
+
 By [igrekster](https://github.com/igrekster)  
 Original plugin: [ReplaceWithRegister](https://github.com/vim-scripts/ReplaceWithRegister).
-   
+
+### Summary:
+This plugin offers a two-in-one command that replaces text covered by a
+{motion}, entire line(s) or the current selection with the contents of a
+register; the old text is deleted into the black-hole register, i.e. it's
+gone. (But of course, the command can be easily undone.)
+
 ### Setup:
 - Add the following command to `~/.ideavimrc`: `Plug 'vim-scripts/ReplaceWithRegister'`
     <details>
@@ -203,78 +464,99 @@ Original plugin: [ReplaceWithRegister](https://github.com/vim-scripts/ReplaceWit
       <br/>
       <code>set ReplaceWithRegister</code>
       </details>
-   
+
 ### Instructions
-   
+
 https://github.com/vim-scripts/ReplaceWithRegister/blob/master/doc/ReplaceWithRegister.txt
 
 </details>
 
 <details>
-<summary><h2>argtextobj</h2></summary>
+<summary><h2>sneak: Jump to any location specified by two characters</h2></summary>
+
+<img src="images/sneakIcon.svg" width="80" height="80" alt="icon"/>  
+
+By [Mikhail Levchenko](https://github.com/Mishkun)  
+Original repository with the plugin: https://github.com/Mishkun/ideavim-sneak  
+Original plugin: [vim-sneak](https://github.com/justinmk/vim-sneak).
+
+### Summary:
+Jump to any location specified by two characters.
 
-Original plugin: [argtextobj.vim](https://www.vim.org/scripts/script.php?script_id=2699).
-   
 ### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'vim-scripts/argtextobj.vim'`
+- Add the following command to `~/.ideavimrc`: `Plug 'justinmk/vim-sneak'`
+
+### Instructions
+
+* Type `s` and two chars to start sneaking in forward direction
+* Type `S` and two chars to start sneaking in backward direction
+* Type `;` or `,` to proceed with sneaking just as if you were using `f` or `t` commands
+
+</details>
+
+<details>
+<summary><h2>surround: Adds provides mappings to easily delete, change, and add surroundings in pairs</h2></summary>
+   
+Original plugin: [vim-surround](https://github.com/tpope/vim-surround).
+   
+### Summary:
+Surround.vim is all about "surroundings": parentheses, brackets, quotes, XML tags, and more. 
+The plugin provides mappings to easily delete, change and add such surroundings in pairs.
+
+### Setup:
+- Add the following command to `~/.ideavimrc`: `Plug 'tpope/vim-surround'`
     <details>
       <summary>Alternative syntax</summary>
-      <code>Plugin 'vim-scripts/argtextobj.vim'</code>
+      <code>Plugin 'tpope/vim-surround'</code>
       <br/>
-      <code>Plug 'https://github.com/vim-scripts/argtextobj.vim'</code>
+      <code>Plug 'https://www.vim.org/scripts/script.php?script_id=1697'</code>
       <br/>
-      <code>Plug 'argtextobj.vim'</code>
+      <code>Plug 'vim-surround'</code>
       <br/>
-      <code>Plug 'https://www.vim.org/scripts/script.php?script_id=2699'</code>
+      <code>set surround</code>
-      <br/>
-      <code>set argtextobj</code>
       </details>
    
 ### Instructions
    
-By default, only the arguments inside parenthesis are considered. To extend the functionality
+https://github.com/tpope/vim-surround/blob/master/doc/surround.txt
-      to other types of brackets, set `g:argtextobj_pairs` variable to a comma-separated
-      list of colon-separated pairs (same as VIM's `matchpairs` option), like
-      `let g:argtextobj_pairs="(:),{:},<:>"`. The order of pairs matters when
-      handling symbols that can also be operators: `func(x << 5, 20) >> 17`. To handle
-      this syntax parenthesis, must come before angle brackets in the list.
-   
-https://www.vim.org/scripts/script.php?script_id=2699
 
 </details>
-   
 
 <details>
-<summary><h2>exchange</h2></summary>
+<summary><h2>Switch: Switch some text under the cursor based on regex patterns</h2></summary>
+
+By Julien Phalip  
+Original plugin: [switch.vim](https://github.com/AndrewRadev/switch.vim).
+
+### Summary:
+The purpose of the plugin is to switch some text under the cursor based on regex patterns. 
+The main entry point is a single command, :Switch. 
+When the command is executed, 
+the plugin looks for one of a few specific patterns under the cursor and performs a substitution depending on it. 
+
+### Setup
+
+Add `set switch` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
+or restart the IDE.
 
-By [fan-tom](https://github.com/fan-tom)  
-Original plugin: [vim-exchange](https://github.com/tommcdo/vim-exchange).
-   
-### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'tommcdo/vim-exchange'`
-    <details>
-      <summary>Alternative syntax</summary>
-      <code>Plugin 'tommcdo/vim-exchange'</code>
-      <br/>
-      <code>Plug 'https://github.com/tommcdo/vim-exchange'</code>
-      <br/>
-      <code>Plug 'vim-exchange'</code>
-      <br/>
-      <code>set exchange</code>
-      </details>
-   
 ### Instructions
-   
+
-https://github.com/tommcdo/vim-exchange/blob/master/doc/exchange.txt
+https://plugins.jetbrains.com/plugin/25899-vim-switch
 
 </details>
-   
+
 <details>
-<summary><h2>textobj-entire</h2></summary>
+<summary><h2>textobj-entire: Adds mapping for selecting entire contents of file regardless of cursor position</h2></summary>
 
 By [Alexandre Grison](https://github.com/agrison)  
 Original plugin: [vim-textobj-entire](https://github.com/kana/vim-textobj-entire).
    
+### Summary:
+vim-textobj-entire is a Vim plugin to provide text objects 
+(ae and ie by default) to select the entire content of a buffer. 
+Though these are trivial operations (e.g. ggVG), text object versions are more handy, 
+because you do not have to be conscious of the cursor position (e.g. vae).
+
 ### Setup:
 - Add the following command to `~/.ideavimrc`: `Plug 'kana/vim-textobj-entire'`
     <details>
@@ -295,158 +577,13 @@ https://github.com/kana/vim-textobj-entire/blob/master/doc/textobj-entire.txt
 </details>
    
 <details>
-<summary><h2>highlightedyank</h2></summary>
+<summary><h2>Which-Key: Displays available keybindings in popup</h2></summary>
-
-By [KostkaBrukowa](https://github.com/KostkaBrukowa)  
-Original plugin: [vim-highlightedyank](https://github.com/machakann/vim-highlightedyank).
-   
-### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'machakann/vim-highlightedyank'`
-    <details>
-      <summary>Alternative syntax</summary>
-      <code>Plugin 'machakann/vim-highlightedyank'</code>
-      <br/>
-      <code>Plug 'https://github.com/machakann/vim-highlightedyank'</code>
-      <br/>
-      <code>Plug 'vim-highlightedyank'</code>
-      <br/>
-      <code>set highlightedyank</code>
-      </details>
-   
-### Instructions
-   
-If you want to optimize highlight duration, assign a time in milliseconds:  
-      `let g:highlightedyank_highlight_duration = "1000"`  
-      A negative number makes the highlight persistent.  
-   
-If you want to change background color of highlight you can provide the rgba of the color you want e.g.  
-      `let g:highlightedyank_highlight_color = "rgba(160, 160, 160, 155)"`
-
-If you want to change text color of highlight you can provide the rgba of the color you want e.g.  
-`let g:highlightedyank_highlight_foreground_color = "rgba(0, 0, 0, 255)"`
-
-https://github.com/machakann/vim-highlightedyank/blob/master/doc/highlightedyank.txt
-
-</details>
-
-<details>
-<summary><h2>vim-paragraph-motion</h2></summary>
-
-Original plugin: [vim-paragraph-motion](https://github.com/dbakker/vim-paragraph-motion).
-   
-### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'dbakker/vim-paragraph-motion'`
-    <details>
-      <summary>Alternative syntax</summary>
-      <code>Plugin 'dbakker/vim-paragraph-motion'</code>
-      <br/>
-      <code>Plug 'https://github.com/dbakker/vim-paragraph-motion'</code>
-      <br/>
-      <code>Plug 'vim-paragraph-motion'</code>
-      <br/>
-      <code>Plug 'https://github.com/vim-scripts/Improved-paragraph-motion'</code>
-      <br/>
-      <code>Plug 'vim-scripts/Improved-paragraph-motion'</code>
-      <br/>
-      <code>Plug 'Improved-paragraph-motion'</code>
-      <br/>
-      <code>set vim-paragraph-motion</code>
-      </details>
-   
-### Instructions
-   
-https://github.com/dbakker/vim-paragraph-motion#vim-paragraph-motion
-
-</details>
-   
-<details>
-<summary><h2>vim-indent-object</h2></summary>
-
-By [Shrikant Sharat Kandula](https://github.com/sharat87)  
-Original plugin: [vim-indent-object](https://github.com/michaeljsmith/vim-indent-object).
-   
-### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'michaeljsmith/vim-indent-object'`
-    <details>
-      <summary>Alternative syntax</summary>
-      <code>Plugin 'michaeljsmith/vim-indent-object'</code>
-      <br/>
-      <code>Plug 'https://github.com/michaeljsmith/vim-indent-object'</code>
-      <br/>
-      <code>Plug 'vim-indent-object'</code>
-      <br/>
-      <code>set textobj-indent</code>
-      </details>
-   
-### Instructions
-   
-https://github.com/michaeljsmith/vim-indent-object/blob/master/doc/indent-object.txt
-
-</details>
-   
-   
-<details>
-<summary><h2>matchit.vim</h2></summary>
-
-By [Martin Yzeiri](https://github.com/myzeiri)
-Original plugin: [matchit.vim](https://github.com/chrisbra/matchit).
-   
-### Setup:
-- Add the following command to `~/.ideavimrc`: `packadd matchit`
-    <details>
-      <summary>Alternative syntax</summary>
-      <code>Plug 'vim-matchit'</code>
-      <br/>
-      <code>Plug 'chrisbra/matchit'</code>
-      <br/>
-      <code>set matchit</code>
-      </details>
-   
-### Instructions
-   
-https://github.com/adelarsq/vim-matchit/blob/master/doc/matchit.txt
-
-</details>
-
-<details>
-<summary><h2>IdeaVim-Quickscope</h2></summary>
-
-Original plugin: [quick-scope](https://github.com/unblevable/quick-scope).
-
-### Setup:
-- Install [IdeaVim-Quickscope](https://plugins.jetbrains.com/plugin/19417-ideavim-quickscope) plugin.
-- Add the following command to `~/.ideavimrc`: `set quickscope`
-
-### Instructions
-
-https://plugins.jetbrains.com/plugin/19417-ideavim-quickscope
-
-</details>
-
-<details>
-<summary><h2>Mini.ai: Extend and create a/i textobjects (IMPORTANT: The plugin is not related with artificial intelligence)</h2></summary>
-
-### Features: 
-Provides additional text object motions for handling quotes and brackets. The following motions are included:
-
-- aq: Around any quotes.
-- iq: Inside any quotes.
-- ab: Around any parentheses, curly braces, and square brackets.
-- ib: Inside any parentheses, curly braces, and square brackets.
-
-Original plugin: [mini.ai](https://github.com/echasnovski/mini.ai).
-
-### Setup:
-- Add the following command to `~/.ideavimrc`: `set mini-ai`
-
-</details>
-
-
-<details>
-<summary><h2>Which-Key</h2></summary>
 
 Original plugin: [vim-which-key](https://github.com/liuchengxu/vim-which-key).
 
+### Summary:
+vim-which-key is vim port of emacs-which-key that displays available keybindings in popup.
+
 ### Setup:
 - Install [Which-Key](https://plugins.jetbrains.com/plugin/15976-which-key) plugin.
 - Add the following command to `~/.ideavimrc`: `set which-key`
@@ -456,49 +593,3 @@ Original plugin: [vim-which-key](https://github.com/liuchengxu/vim-which-key).
 https://github.com/TheBlob42/idea-which-key?tab=readme-ov-file#installation
 
 </details>
-<details>
-<summary><h2>Vim Peekaboo</h2></summary>
-
-By Julien Phalip  
-Original plugin: [vim-peekaboo](https://github.com/junegunn/vim-peekaboo).
-
-### Setup
-
-Add `set peekaboo` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
-or restart the IDE.
-
-### Instructions
-
-https://plugins.jetbrains.com/plugin/25776-vim-peekaboo
-</details>
-
-<details>
-<summary><h2>FunctionTextObj</h2></summary>
-
-By Julien Phalip  
-
-### Setup
-
-Add `set functiontextobj` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
-or restart the IDE.
-
-### Instructions
-
-https://plugins.jetbrains.com/plugin/25897-vim-functiontextobj
-</details>
-
-<details>
-<summary><h2>Switch</h2></summary>
-
-By Julien Phalip  
-Original plugin: [switch.vim](https://github.com/AndrewRadev/switch.vim).
-
-### Setup
-
-Add `set switch` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
-or restart the IDE.
-
-### Instructions
-
-https://plugins.jetbrains.com/plugin/25899-vim-switch
-

gradle.properties

@@ -16,11 +16,11 @@
 # https://data.services.jetbrains.com/products?code=IC
 # Maven releases are here: https://www.jetbrains.com/intellij-repository/releases
 # And snapshots: https://www.jetbrains.com/intellij-repository/snapshots
-ideaVersion=2024.3.3
+ideaVersion=2025.1
 # Values for type: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#intellij-extension-type
 ideaType=IC
 instrumentPluginCode=true
-version=SNAPSHOT
+version=chylex-49
 javaVersion=21
 remoteRobotVersion=0.11.23
 antlrVersion=4.10.1
@@ -41,7 +41,6 @@ youtrackToken=
 
 # Gradle settings
 org.gradle.jvmargs='-Dfile.encoding=UTF-8'
-org.gradle.configuration-cache=true
 org.gradle.caching=true
 
 # Disable warning from gradle-intellij-plugin. Kotlin stdlib is included as compileOnly, so the warning is unnecessary

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -86,8 +86,7 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
-' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum

scripts/build.gradle.kts

@@ -20,17 +20,17 @@ repositories {
 }
 
 dependencies {
-  compileOnly("org.jetbrains.kotlin:kotlin-stdlib:2.1.10")
+  compileOnly("org.jetbrains.kotlin:kotlin-stdlib:2.1.21")
 
-  implementation("io.ktor:ktor-client-core:3.1.1")
+  implementation("io.ktor:ktor-client-core:3.1.3")
-  implementation("io.ktor:ktor-client-cio:3.1.1")
+  implementation("io.ktor:ktor-client-cio:3.1.3")
-  implementation("io.ktor:ktor-client-content-negotiation:3.1.1")
+  implementation("io.ktor:ktor-client-content-negotiation:3.1.3")
-  implementation("io.ktor:ktor-serialization-kotlinx-json:3.1.1")
+  implementation("io.ktor:ktor-serialization-kotlinx-json:3.1.3")
-  implementation("io.ktor:ktor-client-auth:3.1.1")
+  implementation("io.ktor:ktor-client-auth:3.1.3")
   implementation("org.eclipse.jgit:org.eclipse.jgit:6.6.0.202305301015-r")
 
   // This is needed for jgit to connect to ssh
-  implementation("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:7.1.0.202411261347-r")
+  implementation("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:7.2.1.202505142326-r")
   implementation("com.vdurmont:semver4j:3.1.0")
 }
 

scripts/src/main/kotlin/scripts/checkNewPluginDependencies.kt

@@ -43,6 +43,8 @@ val knownPlugins = setOf(
   "com.julienphalip.ideavim.peekaboo", // https://plugins.jetbrains.com/plugin/25776-vim-peekaboo
   "com.julienphalip.ideavim.switch", // https://plugins.jetbrains.com/plugin/25899-vim-switch
   "com.julienphalip.ideavim.functiontextobj", // https://plugins.jetbrains.com/plugin/25897-vim-functiontextobj
+  "com.miksuki.HighlightCursor", // https://plugins.jetbrains.com/plugin/26743-highlightcursor
+  "com.ugarosa.idea.edgemotion", // https://plugins.jetbrains.com/plugin/27211-edgemotion
 )
 
 suspend fun main() {

src/main/java/com/maddyhome/idea/vim/VimPlugin.java

@@ -355,7 +355,12 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
     if (unsubscribe) {
       VimListenerManager.INSTANCE.turnOff();
     }
-    injector.getCommandLine().fullReset();
+    // Use getServiceIfCreated to avoid creating the service during the dispose (this is prohibited by the platform)
+    @Nullable VimCommandLineService service =
+      ApplicationManager.getApplication().getServiceIfCreated(VimCommandLineService.class);
+    if (service != null) {
+      service.fullReset();
+    }
 
     // Unregister vim actions in command mode
     RegisterActions.unregisterActions();
@@ -371,8 +376,7 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
     if (isEnabled() && !ApplicationManager.getApplication().isUnitTestMode()) {
       stateUpdated = true;
       if (SystemInfo.isMac) {
-        final MacKeyRepeat keyRepeat = MacKeyRepeat.getInstance();
+        final Boolean enabled = MacKeyRepeat.INSTANCE.isEnabled();
-        final Boolean enabled = keyRepeat.isEnabled();
         final Boolean isKeyRepeat = getEditor().isKeyRepeat();
         if ((enabled == null || !enabled) && (isKeyRepeat == null || isKeyRepeat)) {
           // This system property is used in IJ ui robot to hide the startup tips
@@ -382,7 +386,7 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
           if (showNotification) {
             if (VimPlugin.getNotifications().enableRepeatingMode() == Messages.YES) {
               getEditor().setKeyRepeat(true);
-              keyRepeat.setEnabled(true);
+              MacKeyRepeat.INSTANCE.setEnabled(true);
             }
             else {
               getEditor().setKeyRepeat(false);

src/main/java/com/maddyhome/idea/vim/VimTypedActionHandler.kt

@@ -88,7 +88,7 @@ class VimTypedActionHandler(origHandler: TypedActionHandler) : TypedActionHandle
         LOG.info("VimTypedAction '$charTyped': $duration ms")
       }
     } catch (e: ProcessCanceledException) {
-      // Nothing
+      throw e
     } catch (e: Throwable) {
       LOG.error(e)
     }

src/main/java/com/maddyhome/idea/vim/action/VimRunLastMacroInOpenFiles.kt

@@ -0,0 +1,52 @@
+package com.maddyhome.idea.vim.action
+
+import com.intellij.openapi.actionSystem.ActionUpdateThread
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.command.UndoConfirmationPolicy
+import com.intellij.openapi.command.WriteCommandAction
+import com.intellij.openapi.fileEditor.TextEditor
+import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
+import com.intellij.openapi.project.DumbAwareAction
+import com.maddyhome.idea.vim.KeyHandler
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.newapi.IjEditorExecutionContext
+import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.mode.Mode
+
+class VimRunLastMacroInOpenFiles : DumbAwareAction() {
+  override fun update(e: AnActionEvent) {
+    val lastRegister = injector.macro.lastRegister
+    val isEnabled = lastRegister != 0.toChar()
+
+    e.presentation.isEnabled = isEnabled
+    e.presentation.text = if (isEnabled) "Run Macro '${lastRegister}' in Open Files" else "Run Last Macro in Open Files"
+  }
+
+  override fun getActionUpdateThread(): ActionUpdateThread {
+    return ActionUpdateThread.EDT
+  }
+
+  override fun actionPerformed(e: AnActionEvent) {
+    val project = e.project ?: return
+    val fileEditorManager = FileEditorManagerEx.getInstanceExIfCreated(project) ?: return
+    val editors = fileEditorManager.allEditors.filterIsInstance<TextEditor>()
+    
+    WriteCommandAction.writeCommandAction(project)
+      .withName(e.presentation.text)
+      .withGlobalUndo()
+      .withUndoConfirmationPolicy(UndoConfirmationPolicy.REQUEST_CONFIRMATION)
+      .run<RuntimeException> {
+        val reg = injector.macro.lastRegister
+        
+        for (editor in editors) {
+          fileEditorManager.openFile(editor.file, true)
+          
+          val vimEditor = editor.editor.vim
+          vimEditor.mode = Mode.NORMAL()
+          KeyHandler.getInstance().reset(vimEditor)
+          
+          injector.macro.playbackRegister(vimEditor, IjEditorExecutionContext(e.dataContext), reg, 1)
+        }
+      }
+  }
+}

src/main/java/com/maddyhome/idea/vim/action/VimShortcutKeyAction.kt

@@ -59,11 +59,8 @@ import javax.swing.KeyStroke
  *
  *
  * These keys are not passed to [com.maddyhome.idea.vim.VimTypedActionHandler] and should be handled by actions.
- *
- * This class is used in Which-Key plugin, so don't make it internal. Generally, we should provide a proper
- *   way to get ideavim keys for this plugin. See VIM-3085
  */
-class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
+internal class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
 
   init {
     initInjector()
@@ -92,9 +89,10 @@ class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
           val duration = System.currentTimeMillis() - start
           LOG.info("VimShortcut execution '$keyStroke': $duration ms")
         }
-      } catch (_: ProcessCanceledException) {
+      } catch (e: ProcessCanceledException) {
-        // Control-flow exceptions (like ProcessCanceledException) should never be logged
+        // Control-flow exceptions (like ProcessCanceledException) should never be logged and should be rethrown
         // See {@link com.intellij.openapi.diagnostic.Logger.checkException}
+        throw e
       } catch (throwable: Throwable) {
         LOG.error(throwable)
       }
@@ -198,10 +196,6 @@ class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
         VimPlugin.getChange().tabAction = true
         return ActionEnableStatus.no("Tab action in insert mode", LogLevel.INFO)
       }
-      // Debug watch, Python console, etc.
-      if (keyStroke in NON_FILE_EDITOR_KEYS && !EditorHelper.isFileEditor(editor)) {
-        return ActionEnableStatus.no("Non file editor keys", LogLevel.INFO)
-      }
     }
 
     if (keyStroke in VIM_ONLY_EDITOR_KEYS) {
@@ -349,14 +343,6 @@ class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
 
     private const val ACTION_ID = "VimShortcutKeyAction"
 
-    private val NON_FILE_EDITOR_KEYS: Set<KeyStroke> = ImmutableSet.builder<KeyStroke>()
-      .addAll(getKeyStrokes(KeyEvent.VK_ENTER, 0))
-      .addAll(getKeyStrokes(KeyEvent.VK_ESCAPE, 0))
-      .addAll(getKeyStrokes(KeyEvent.VK_TAB, 0))
-      .addAll(getKeyStrokes(KeyEvent.VK_UP, 0))
-      .addAll(getKeyStrokes(KeyEvent.VK_DOWN, 0))
-      .build()
-
     private val LOG = logger<VimShortcutKeyAction>()
 
     @JvmStatic

src/main/java/com/maddyhome/idea/vim/command/CommandState.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2023 The IdeaVim authors
+ * Copyright 2003-2025 The IdeaVim authors
  *
  * Use of this source code is governed by an MIT-style
  * license that can be found in the LICENSE.txt file or at
@@ -14,10 +14,6 @@ import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.state.VimStateMachine
 import org.jetbrains.annotations.ApiStatus
 
-/**
- * COMPATIBILITY-LAYER: Additional class
- * Please see: https://jb.gg/zo8n0r
- */
 @Deprecated("Use `injector.vimState`")
 @ApiStatus.ScheduledForRemoval
 class CommandState(private val machine: VimStateMachine) {

src/main/java/com/maddyhome/idea/vim/customization/feature/terminal/IdeaVimTerminalDisablerExtension.kt

@@ -11,16 +11,17 @@ package com.maddyhome.idea.vim.customization.feature.terminal
 import com.intellij.openapi.editor.Editor
 import com.maddyhome.idea.vim.key.IdeaVimDisablerExtensionPoint
 import org.jetbrains.plugins.terminal.block.util.TerminalDataContextUtils.isAlternateBufferEditor
+import org.jetbrains.plugins.terminal.block.util.TerminalDataContextUtils.isAlternateBufferModelEditor
 import org.jetbrains.plugins.terminal.block.util.TerminalDataContextUtils.isOutputEditor
+import org.jetbrains.plugins.terminal.block.util.TerminalDataContextUtils.isOutputModelEditor
 import org.jetbrains.plugins.terminal.block.util.TerminalDataContextUtils.isPromptEditor
 
 /**
  * The only implementation is defined right here.
  */
-// [VERSION UPDATE] 2025.1+ Add 2 new predicates
 internal class IdeaVimTerminalDisablerExtension : IdeaVimDisablerExtensionPoint {
   override fun isDisabledForEditor(editor: Editor): Boolean {
     return editor.isPromptEditor || editor.isOutputEditor || editor.isAlternateBufferEditor
-//      || editor.isOutputModelEditor || editor.isAlternateBufferModelEditor
+      || editor.isOutputModelEditor || editor.isAlternateBufferModelEditor
   }
 }

src/main/java/com/maddyhome/idea/vim/extension/VimExtensionFacade.kt

@@ -146,7 +146,7 @@ object VimExtensionFacade {
   fun executeNormalWithoutMapping(keys: List<KeyStroke>, editor: Editor) {
     val context = injector.executionContextManager.getEditorExecutionContext(editor.vim)
     val keyHandler = KeyHandler.getInstance()
-    keys.forEach { keyHandler.handleKey(editor.vim, it, context, false, false, keyHandler.keyHandlerState) }
+    keys.forEach { keyHandler.handleKey(editor.vim, it, context, false, keyHandler.keyHandlerState) }
   }
 
   /** Returns a single key stroke from the user input similar to 'getchar()'. */
@@ -214,7 +214,13 @@ object VimExtensionFacade {
 
   /** Set the current contents of the given register */
   @JvmStatic
-  fun setRegisterForCaret(register: Char, caret: ImmutableVimCaret, keys: List<KeyStroke?>?) {
+  fun setRegisterForCaret(
+    editor: VimEditor,
+    context: ExecutionContext,
+    register: Char,
+    caret: ImmutableVimCaret,
+    keys: List<KeyStroke?>?,
+  ) {
     caret.registerStorage.setKeys(register, keys?.filterNotNull() ?: emptyList())
   }
 
@@ -282,4 +288,4 @@ fun VimExtensionFacade.exportOperatorFunction(name: String, function: OperatorFu
 
 fun interface ScriptFunction {
   fun execute(editor: VimEditor, context: ExecutionContext, args: Map<String, VimDataType>): ExecutionResult
-}
+}

src/main/java/com/maddyhome/idea/vim/extension/commentary/CommentaryExtension.kt

@@ -221,14 +221,16 @@ internal class CommentaryExtension : VimExtension {
       val endOffset = editor.vim.getLineEndOffset(logicalLine, true)
       val startElement = file.findElementAt(startOffset) ?: return false
       var next: PsiElement? = startElement
+      var hasComment = false
       while (next != null && next.textRange.startOffset <= endOffset) {
-        if (next !is PsiWhiteSpace && !isComment(next)) {
+        when {
-          return false
+          next is PsiWhiteSpace -> {} // Skip whitespace elementl
+          isComment(next) -> hasComment = true // Mark when we find a comment
+          else -> return false // Non-comment content found, exit early
         }
         next = PsiTreeUtil.nextLeaf(next, true)
       }
-
+      return hasComment
-      return true
     }
 
     private fun isComment(element: PsiElement) =

src/main/java/com/maddyhome/idea/vim/extension/highlightedyank/VimHighlightedYank.kt

@@ -21,9 +21,7 @@ import com.intellij.openapi.editor.markup.TextAttributes
 import com.intellij.openapi.util.Disposer
 import com.intellij.util.Alarm
 import com.intellij.util.Alarm.ThreadToUse
-import com.jetbrains.rd.util.first
 import com.maddyhome.idea.vim.VimPlugin
-import com.maddyhome.idea.vim.api.ImmutableVimCaret
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.common.ModeChangeListener
@@ -123,9 +121,9 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, ModeChangeLis
     initialised = false
   }
 
-  override fun yankPerformed(caretToRange: Map<ImmutableVimCaret, TextRange>) {
+  override fun yankPerformed(editor: VimEditor, range: TextRange) {
     ensureInitialised()
-    highlightHandler.highlightYankRange(caretToRange)
+    highlightHandler.highlightYankRange(editor.ij, range)
   }
 
   override fun modeChanged(editor: VimEditor, oldMode: Mode) {
@@ -146,25 +144,22 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, ModeChangeLis
     private var lastEditor: Editor? = null
     private val highlighters = mutableSetOf<RangeHighlighter>()
 
-    fun highlightYankRange(caretToRange: Map<ImmutableVimCaret, TextRange>) {
+    fun highlightYankRange(editor: Editor, range: TextRange) {
       // from vim-highlightedyank docs: When a new text is yanked or user starts editing, the old highlighting would be deleted
       clearYankHighlighters()
 
-      val editor = caretToRange.first().key.editor.ij
       lastEditor = editor
 
       val attributes = getHighlightTextAttributes(editor)
-      for (range in caretToRange.values) {
+      for (i in 0 until range.size()) {
-        for (i in 0 until range.size()) {
+        val highlighter = editor.markupModel.addRangeHighlighter(
-          val highlighter = editor.markupModel.addRangeHighlighter(
+          range.startOffsets[i],
-            range.startOffsets[i],
+          range.endOffsets[i],
-            range.endOffsets[i],
+          HighlighterLayer.SELECTION,
-            HighlighterLayer.SELECTION,
+          attributes,
-            attributes,
+          HighlighterTargetArea.EXACT_RANGE,
-            HighlighterTargetArea.EXACT_RANGE,
+        )
-          )
+        highlighters.add(highlighter)
-          highlighters.add(highlighter)
-        }
       }
 
       // from vim-highlightedyank docs: A negative number makes the highlight persistent.
@@ -282,4 +277,4 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, ModeChangeLis
       return default
     }
   }
-}
+}

src/main/java/com/maddyhome/idea/vim/extension/matchit/Matchit.kt

@@ -230,7 +230,7 @@ private object FileTypePatterns {
     } else if (fileTypeName == "CMakeLists.txt" || fileName == "CMakeLists") {
       this.cMakePatterns
     } else {
-      return null
+      this.htmlPatterns
     }
   }
 

src/main/java/com/maddyhome/idea/vim/extension/replacewithregister/ReplaceWithRegister.kt

@@ -29,7 +29,6 @@ import com.maddyhome.idea.vim.extension.exportOperatorFunction
 import com.maddyhome.idea.vim.group.visual.VimSelection
 import com.maddyhome.idea.vim.helper.exitVisualMode
 import com.maddyhome.idea.vim.key.OperatorFunction
-import com.maddyhome.idea.vim.newapi.IjVimCopiedText
 import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
@@ -154,8 +153,7 @@ private fun doReplace(editor: Editor, context: DataContext, caret: ImmutableVimC
     usedType = SelectionType.CHARACTER_WISE
   }
 
-  val copiedText = IjVimCopiedText(usedText, (savedRegister.copiedText as IjVimCopiedText).transferableData)
+  val textData = PutData.TextData(usedText, usedType, savedRegister.transferableData, savedRegister.name)
-  val textData = PutData.TextData(savedRegister.name, copiedText, usedType)
 
   val putData = PutData(
     textData,

src/main/java/com/maddyhome/idea/vim/extension/surround/RepeatedCharSequence.kt

@@ -0,0 +1,30 @@
+package com.maddyhome.idea.vim.extension.surround
+
+import com.intellij.util.text.CharSequenceSubSequence
+
+internal data class RepeatedCharSequence(val text: CharSequence, val count: Int) : CharSequence {
+  override val length = text.length * count
+
+  override fun get(index: Int): Char {
+    if (index < 0 || index >= length) throw IndexOutOfBoundsException()
+    return text[index % text.length]
+  }
+
+  override fun subSequence(startIndex: Int, endIndex: Int): CharSequence {
+    return CharSequenceSubSequence(this, startIndex, endIndex)
+  }
+
+  override fun toString(): String {
+    return text.repeat(count)
+  }
+  
+  companion object {
+    fun of(text: CharSequence, count: Int): CharSequence {
+      return when (count) {
+        0 -> ""
+        1 -> text
+        else -> RepeatedCharSequence(text, count)
+      }
+    }
+  }
+}

src/main/java/com/maddyhome/idea/vim/extension/surround/VimSurroundExtension.kt

@@ -11,9 +11,11 @@ import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.openapi.application.runWriteAction
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.Editor
+import com.maddyhome.idea.vim.KeyHandler
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimCaret
+import com.maddyhome.idea.vim.api.VimChangeGroup
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.endsWithNewLine
 import com.maddyhome.idea.vim.api.getLeadingCharacterOffset
@@ -36,7 +38,10 @@ import com.maddyhome.idea.vim.extension.VimExtensionFacade.setRegisterForCaret
 import com.maddyhome.idea.vim.extension.exportOperatorFunction
 import com.maddyhome.idea.vim.group.findBlockRange
 import com.maddyhome.idea.vim.helper.exitVisualMode
+import com.maddyhome.idea.vim.helper.runWithEveryCaretAndRestore
 import com.maddyhome.idea.vim.key.OperatorFunction
+import com.maddyhome.idea.vim.newapi.IjVimCaret
+import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.options.helpers.ClipboardOptionHelper
@@ -79,7 +84,7 @@ internal class VimSurroundExtension : VimExtension {
       putKeyMappingIfMissing(MappingMode.XO, injector.parser.parseKeys("S"), owner, injector.parser.parseKeys("<Plug>VSurround"), true)
     }
 
-    VimExtensionFacade.exportOperatorFunction(OPERATOR_FUNC, Operator())
+    VimExtensionFacade.exportOperatorFunction(OPERATOR_FUNC, Operator(supportsMultipleCursors = false, count = 1)) // TODO
   }
 
   private class YSurroundHandler : ExtensionHandler {
@@ -107,7 +112,7 @@ internal class VimSurroundExtension : VimExtension {
         val lastNonWhiteSpaceOffset = getLastNonWhitespaceCharacterOffset(editor.text(), lineStartOffset, lineEndOffset)
         if (lastNonWhiteSpaceOffset != null) {
           val range = TextRange(lineStartOffset, lastNonWhiteSpaceOffset + 1)
-          performSurround(pair, range, it)
+          performSurround(pair, range, it, count = operatorArguments.count1)
         }
 //        it.moveToOffset(lineStartOffset)
       }
@@ -130,15 +135,17 @@ internal class VimSurroundExtension : VimExtension {
 
   private class VSurroundHandler : ExtensionHandler {
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      val selectionStart = editor.ij.caretModel.primaryCaret.selectionStart
       // NB: Operator ignores SelectionType anyway
-      if (!Operator().apply(editor, context, editor.mode.selectionType)) {
+      if (!Operator(supportsMultipleCursors = true, count = operatorArguments.count1).apply(editor, context, editor.mode.selectionType)) {
         return
       }
       runWriteAction {
         // Leave visual mode
         editor.exitVisualMode()
-        editor.ij.caretModel.moveToOffset(selectionStart)
+        
+        // Reset the key handler so that the command trie is updated for the new mode (Normal)
+        // TODO: This should probably be handled by ToHandlerMapping.execute
+        KeyHandler.getInstance().reset(editor)
       }
     }
   }
@@ -159,12 +166,16 @@ internal class VimSurroundExtension : VimExtension {
 
     companion object {
       fun change(editor: VimEditor, context: ExecutionContext, charFrom: Char, newSurround: SurroundPair?) {
+        editor.ij.runWithEveryCaretAndRestore { changeAtCaret(editor, context, charFrom, newSurround) }
+      }
+      
+      fun changeAtCaret(editor: VimEditor, context: ExecutionContext, charFrom: Char, newSurround: SurroundPair?) {
         // Save old register values for carets
         val surroundings = editor.sortedCarets()
           .map {
             val oldValue: List<KeyStroke>? = getRegisterForCaret(editor, context, REGISTER, it)
-            setRegisterForCaret(REGISTER, it, null)
+            setRegisterForCaret(editor, context, REGISTER, it, null)
-            SurroundingInfo(it, null, oldValue, false)
+            SurroundingInfo(editor, context, it, null, oldValue, false)
           }
 
         // Delete surrounding's content
@@ -201,7 +212,7 @@ internal class VimSurroundExtension : VimExtension {
               val trimmedValue = if (newSurround.shouldTrim) innerValue.trim() else innerValue
               it.first + trimmedValue + it.second
             } ?: innerValue
-            val textData = PutData.TextData(null, injector.clipboardManager.dumbCopiedText(text), SelectionType.CHARACTER_WISE)
+            val textData = PutData.TextData(text, SelectionType.CHARACTER_WISE, emptyList(), null)
             val putData = PutData(textData, null, 1, insertTextBeforeCaret = true, rawIndent = true, caretAfterInsertedText = false)
 
             surrounding.caret to putData
@@ -253,9 +264,16 @@ internal class VimSurroundExtension : VimExtension {
     }
   }
 
-  private data class SurroundingInfo(val caret: VimCaret, var innerText: List<KeyStroke>?, val oldRegisterContent: List<KeyStroke>?, var isValidSurrounding: Boolean) {
+  private data class SurroundingInfo(
+    val editor: VimEditor,
+    val context: ExecutionContext,
+    val caret: VimCaret,
+    var innerText: List<KeyStroke>?,
+    val oldRegisterContent: List<KeyStroke>?,
+    var isValidSurrounding: Boolean,
+  ) {
     fun restoreRegister() {
-      setRegisterForCaret(REGISTER, caret, oldRegisterContent)
+      setRegisterForCaret(editor, context, REGISTER, caret, oldRegisterContent)
     }
   }
 
@@ -272,20 +290,41 @@ internal class VimSurroundExtension : VimExtension {
     }
   }
 
-  private class Operator : OperatorFunction {
+  private class Operator(private val supportsMultipleCursors: Boolean, private val count: Int) : OperatorFunction {
-    override fun apply(editor: VimEditor, context: ExecutionContext, selectionType: SelectionType?): Boolean {
+    override fun apply(vimEditor: VimEditor, context: ExecutionContext, selectionType: SelectionType?): Boolean {
-      val ijEditor = editor.ij
+      val ijEditor = vimEditor.ij
       val c = getChar(ijEditor)
       if (c.code == 0) return true
 
       val pair = getOrInputPair(c, ijEditor, context.ij) ?: return false
-      // XXX: Will it work with line-wise or block-wise selections?
+
-      val range = getSurroundRange(editor.currentCaret()) ?: return false
+      runWriteAction {
-      performSurround(pair, range, editor.currentCaret(), selectionType == SelectionType.LINE_WISE)
+        val change = VimPlugin.getChange()
-      // Jump back to start
+        if (supportsMultipleCursors) {
-      executeNormalWithoutMapping(injector.parser.parseKeys("`["), ijEditor)
+          ijEditor.runWithEveryCaretAndRestore {
+            applyOnce(ijEditor, change, pair, count)
+          }
+        }
+        else {
+          applyOnce(ijEditor, change, pair, count)
+          // Jump back to start
+          executeNormalWithoutMapping(injector.parser.parseKeys("`["), ijEditor)
+        }
+      }
       return true
     }
+    
+    private fun applyOnce(editor: Editor, change: VimChangeGroup, pair: SurroundPair, count: Int) {
+      // XXX: Will it work with line-wise or block-wise selections?
+      val primaryCaret = editor.caretModel.primaryCaret
+      val range = getSurroundRange(primaryCaret.vim)
+      if (range != null) {
+        val start = RepeatedCharSequence.of(pair.first, count)
+        val end = RepeatedCharSequence.of(pair.second, count)
+        change.insertText(IjVimEditor(editor), IjVimCaret(primaryCaret), range.startOffset, start)
+        change.insertText(IjVimEditor(editor), IjVimCaret(primaryCaret), range.endOffset + start.length, end)
+      }
+    }
 
     private fun getSurroundRange(caret: VimCaret): TextRange? {
       val editor = caret.editor
@@ -386,15 +425,15 @@ private fun getChar(editor: Editor): Char {
   return res
 }
 
-private fun performSurround(pair: SurroundPair, range: TextRange, caret: VimCaret, tagsOnNewLines: Boolean = false) {
+private fun performSurround(pair: SurroundPair, range: TextRange, caret: VimCaret, count: Int, tagsOnNewLines: Boolean = false) {
   runWriteAction {
     val editor = caret.editor
     val change = VimPlugin.getChange()
-    val leftSurround = pair.first + if (tagsOnNewLines) "\n" else ""
+    val leftSurround = RepeatedCharSequence.of(pair.first + if (tagsOnNewLines) "\n" else "", count)
 
     val isEOF = range.endOffset == editor.text().length
     val hasNewLine = editor.endsWithNewLine()
-    val rightSurround = if (tagsOnNewLines) {
+    val rightSurround = (if (tagsOnNewLines) {
       if (isEOF && !hasNewLine) {
         "\n" + pair.second
       } else {
@@ -402,7 +441,7 @@ private fun performSurround(pair: SurroundPair, range: TextRange, caret: VimCare
       }
     } else {
       pair.second
-    }
+    }).let { RepeatedCharSequence.of(it, count) }
 
     change.insertText(editor, caret, range.startOffset, leftSurround)
     change.insertText(editor, caret, range.endOffset + leftSurround.length, rightSurround)

src/main/java/com/maddyhome/idea/vim/group/ChangeGroup.kt

@@ -7,7 +7,7 @@
  */
 package com.maddyhome.idea.vim.group
 
-import com.intellij.codeInsight.actions.AsyncActionExecutionService.Companion.getInstance
+import com.intellij.codeInsight.actions.AsyncActionExecutionService
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.actionSystem.IdeActions
 import com.intellij.openapi.application.ApplicationManager
@@ -15,6 +15,7 @@ import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.command.UndoConfirmationPolicy
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.actionSystem.TypedActionHandler
 import com.intellij.openapi.editor.actions.EnterAction
 import com.intellij.openapi.editor.event.EditorMouseEvent
 import com.intellij.openapi.editor.event.EditorMouseListener
@@ -33,7 +34,7 @@ import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.group.visual.vimSetSystemSelectionSilently
 import com.maddyhome.idea.vim.handler.commandContinuation
 import com.maddyhome.idea.vim.helper.inInsertMode
-import com.maddyhome.idea.vim.key.KeyHandlerKeeper.Companion.getInstance
+import com.maddyhome.idea.vim.key.KeyHandlerKeeper
 import com.maddyhome.idea.vim.listener.VimInsertListener
 import com.maddyhome.idea.vim.newapi.IjVimCaret
 import com.maddyhome.idea.vim.newapi.IjVimCopiedText
@@ -42,7 +43,6 @@ import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.undo.VimKeyBasedUndoService
 import com.maddyhome.idea.vim.undo.VimTimestampBasedUndoService
-import kotlin.math.min
 
 /**
  * Provides all the insert/replace related functionality
@@ -62,8 +62,21 @@ class ChangeGroup : VimChangeGroupBase() {
   }
 
   override fun type(vimEditor: VimEditor, context: ExecutionContext, key: Char) {
+    doType(vimEditor, context) {
+      it.execute(vimEditor.ij, key, context.ij)
+    }
+  }
+
+  override fun type(vimEditor: VimEditor, context: ExecutionContext, string: String) {
+    doType(vimEditor, context) { handler ->
+      string.forEach { char ->
+        handler.execute(vimEditor.ij, char, context.ij)
+      }
+    }
+  }
+
+  private fun doType(vimEditor: VimEditor, context: ExecutionContext, action: (TypedActionHandler) -> Unit) {
     val editor = (vimEditor as IjVimEditor).editor
-    val ijContext = context.ij
     val doc = vimEditor.editor.document
 
     val undo = injector.undo
@@ -76,8 +89,9 @@ class ChangeGroup : VimChangeGroupBase() {
     }
     CommandProcessor.getInstance().executeCommand(
       editor.project, {
-        ApplicationManager.getApplication()
+        ApplicationManager.getApplication().runWriteAction {
-          .runWriteAction { getInstance().originalHandler.execute(editor, key, ijContext) }
+          action(KeyHandlerKeeper.getInstance().originalHandler)
+        }
       }, "", doc,
       UndoConfirmationPolicy.DEFAULT, doc
     )
@@ -141,6 +155,7 @@ class ChangeGroup : VimChangeGroupBase() {
     context: ExecutionContext,
     range: TextRange,
   ) {
+    val startPos = editor.offsetToBufferPosition(caret.offset)
     val startOffset = editor.getLineStartForOffset(range.startOffset)
     val endOffset = editor.getLineEndForOffset(range.endOffset)
     val ijEditor = (editor as IjVimEditor).editor
@@ -150,7 +165,7 @@ class ChangeGroup : VimChangeGroupBase() {
     var copiedText: IjVimCopiedText? = null
     try {
       if (injector.registerGroup.isPrimaryRegisterSupported()) {
-        copiedText = injector.clipboardManager.getPrimaryContent(editor, context) as IjVimCopiedText
+        copiedText = injector.clipboardManager.getPrimaryContent() as IjVimCopiedText
       }
     } catch (e: Exception) {
       // FIXME: [isPrimaryRegisterSupported()] is not implemented perfectly, so there might be thrown an exception after trying to access the primary selection
@@ -165,15 +180,11 @@ class ChangeGroup : VimChangeGroupBase() {
       }
     }
     val afterAction = {
-      val firstLine = editor.offsetToBufferPosition(
+      caret.moveToOffset(injector.motion.moveCaretToLineStartSkipLeading(editor, startPos.line))
-        min(startOffset.toDouble(), endOffset.toDouble()).toInt()
-      ).line
-      val newOffset = injector.motion.moveCaretToLineStartSkipLeading(editor, firstLine)
-      caret.moveToOffset(newOffset)
       restoreCursor(editor, caret, (caret as IjVimCaret).caret.logicalPosition.line)
     }
     if (project != null) {
-      getInstance(project)
+      AsyncActionExecutionService.getInstance(project)
         .withExecutionAfterAction(IdeActions.ACTION_EDITOR_AUTO_INDENT_LINES, actionExecution, afterAction)
     } else {
       actionExecution.invoke()

src/main/java/com/maddyhome/idea/vim/group/IjOptionProperties.kt

@@ -31,10 +31,8 @@ open class GlobalIjOptions(scope: OptionAccessScope) : OptionsPropertiesBase(sco
 
   // Temporary options to control work-in-progress behaviour
   var closenotebooks: Boolean by optionProperty(IjOptions.closenotebooks)
-  var commandOrMotionAnnotation: Boolean by optionProperty(IjOptions.commandOrMotionAnnotation)
   var oldundo: Boolean by optionProperty(IjOptions.oldundo)
   var unifyjumps: Boolean by optionProperty(IjOptions.unifyjumps)
-  var vimscriptFunctionAnnotation: Boolean by optionProperty(IjOptions.vimscriptFunctionAnnotation)
 }
 
 /**

src/main/java/com/maddyhome/idea/vim/group/IjOptions.kt

@@ -141,12 +141,8 @@ object IjOptions {
   // Temporary feature flags during development, not really intended for external use
   val closenotebooks: ToggleOption =
     addOption(ToggleOption("closenotebooks", GLOBAL, "closenotebooks", true, isHidden = true))
-  val commandOrMotionAnnotation: ToggleOption =
+  val oldundo: ToggleOption = addOption(ToggleOption("oldundo", GLOBAL, "oldundo", true, isHidden = true))
-    addOption(ToggleOption("commandormotionannotation", GLOBAL, "commandormotionannotation", true, isHidden = true))
-  val oldundo: ToggleOption = addOption(ToggleOption("oldundo", GLOBAL, "oldundo", false, isHidden = true))
   val unifyjumps: ToggleOption = addOption(ToggleOption("unifyjumps", GLOBAL, "unifyjumps", true, isHidden = true))
-  val vimscriptFunctionAnnotation: ToggleOption =
-    addOption(ToggleOption("vimscriptfunctionannotation", GLOBAL, "vimscriptfunctionannotation", true, isHidden = true))
 
   // This needs to be Option<out VimDataType> so that it can work with derived option types, such as NumberOption, which
   // derives from Option<VimInt>

src/main/java/com/maddyhome/idea/vim/group/KeyGroup.java

@@ -58,7 +58,7 @@ public class KeyGroup extends VimKeyGroupBase implements PersistentStateComponen
   public void registerRequiredShortcutKeys(@NotNull VimEditor editor) {
     EventFacade.getInstance()
       .registerCustomShortcutSet(VimShortcutKeyAction.getInstance(), toShortcutSet(getRequiredShortcutKeys()),
-                                 ((IjVimEditor)editor).getEditor().getComponent());
+                                 ((IjVimEditor)editor).getEditor().getContentComponent());
   }
 
   public void registerShortcutsForLookup(@NotNull LookupImpl lookup) {
@@ -69,7 +69,7 @@ public class KeyGroup extends VimKeyGroupBase implements PersistentStateComponen
 
   void unregisterShortcutKeys(@NotNull VimEditor editor) {
     EventFacade.getInstance().unregisterCustomShortcutSet(VimShortcutKeyAction.getInstance(),
-                                                          ((IjVimEditor)editor).getEditor().getComponent());
+                                                          ((IjVimEditor)editor).getEditor().getContentComponent());
   }
 
   @Override

src/main/java/com/maddyhome/idea/vim/group/MacroAutoImport.kt

@@ -0,0 +1,68 @@
+package com.maddyhome.idea.vim.group
+
+import com.intellij.codeInsight.daemon.ReferenceImporter
+import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.actionSystem.DataContext
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.application.ReadAction
+import com.intellij.openapi.command.WriteCommandAction
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.fileEditor.FileDocumentManager
+import com.intellij.openapi.progress.ProgressIndicator
+import com.intellij.openapi.progress.ProgressManager
+import com.intellij.openapi.progress.Task
+import com.intellij.psi.PsiDocumentManager
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiRecursiveElementWalkingVisitor
+import java.util.function.BooleanSupplier
+
+internal object MacroAutoImport {
+  fun run(editor: Editor, dataContext: DataContext) {
+    val project = CommonDataKeys.PROJECT.getData(dataContext) ?: return
+    val file = PsiDocumentManager.getInstance(project).getPsiFile(editor.document) ?: return
+
+    if (!FileDocumentManager.getInstance().requestWriting(editor.document, project)) {
+      return
+    }
+
+    val importers = ReferenceImporter.EP_NAME.extensionList
+    if (importers.isEmpty()) {
+      return
+    }
+
+    ProgressManager.getInstance().run(object : Task.Backgroundable(project, "Auto import", true) {
+      override fun run(indicator: ProgressIndicator) {
+        val fixes = ReadAction.nonBlocking<List<BooleanSupplier>> {
+          val fixes = mutableListOf<BooleanSupplier>()
+
+          file.accept(object : PsiRecursiveElementWalkingVisitor() {
+            override fun visitElement(element: PsiElement) {
+              for (reference in element.references) {
+                if (reference.resolve() != null) {
+                  continue
+                }
+                for (importer in importers) {
+                  importer.computeAutoImportAtOffset(editor, file, element.textRange.startOffset, true)
+                    ?.let(fixes::add)
+                }
+              }
+              super.visitElement(element)
+            }
+          })
+
+          return@nonBlocking fixes
+        }.executeSynchronously()
+
+        ApplicationManager.getApplication().invokeAndWait {
+          WriteCommandAction.writeCommandAction(project)
+            .withName("Auto Import")
+            .withGroupId("IdeaVimAutoImportAfterMacro")
+            .shouldRecordActionForActiveDocument(true)
+            .run<RuntimeException> {
+              fixes.forEach { it.asBoolean }
+            }
+        }
+      }
+    })
+  }
+}

src/main/java/com/maddyhome/idea/vim/group/MacroGroup.kt

@@ -21,6 +21,7 @@ import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.helper.MessageHelper.message
 import com.maddyhome.idea.vim.macro.VimMacroBase
 import com.maddyhome.idea.vim.newapi.IjVimEditor
+import com.maddyhome.idea.vim.newapi.ij
 
 /**
  * Used to handle playback of macros
@@ -89,6 +90,9 @@ internal class MacroGroup : VimMacroBase() {
         } finally {
           keyStack.removeFirst()
         }
+        if (!isInternalMacro) {
+          MacroAutoImport.run(editor.ij, context.ij)
+        }
       }
 
       if (isInternalMacro) {

src/main/java/com/maddyhome/idea/vim/group/MotionGroup.kt

@@ -89,6 +89,9 @@ internal class MotionGroup : VimMotionGroupBase() {
   }
 
   override fun moveCaretToCurrentDisplayLineStart(editor: VimEditor, caret: ImmutableVimCaret): Motion {
+    if (editor.ij.softWrapModel.isSoftWrappingEnabled) {
+      return AbsoluteOffset(caret.ij.visualLineStart)
+    }
     val col = EditorHelper.getVisualColumnAtLeftOfDisplay(editor.ij, caret.getVisualPosition().line)
     return moveCaretToColumn(editor, caret, col, false)
   }
@@ -97,6 +100,15 @@ internal class MotionGroup : VimMotionGroupBase() {
     editor: VimEditor,
     caret: ImmutableVimCaret,
   ): @Range(from = 0, to = Int.MAX_VALUE.toLong()) Int {
+    if (editor.ij.softWrapModel.isSoftWrappingEnabled) {
+      val offset = caret.ij.visualLineStart
+      val line = editor.offsetToBufferPosition(offset).line
+      return if (offset == editor.getLineStartOffset(line)) {
+        editor.getLeadingCharacterOffset(line, 0)
+      } else {
+        offset
+      }
+    }
     val col = EditorHelper.getVisualColumnAtLeftOfDisplay(editor.ij, caret.getVisualPosition().line)
     val bufferLine = caret.getLine()
     return editor.getLeadingCharacterOffset(bufferLine, col)
@@ -107,6 +119,9 @@ internal class MotionGroup : VimMotionGroupBase() {
     caret: ImmutableVimCaret,
     allowEnd: Boolean,
   ): Motion {
+    if (editor.ij.softWrapModel.isSoftWrappingEnabled) {
+      return AbsoluteOffset(caret.ij.visualLineEnd - 1)
+    }
     val col = EditorHelper.getVisualColumnAtRightOfDisplay(editor.ij, caret.getVisualPosition().line)
     return moveCaretToColumn(editor, caret, col, allowEnd)
   }

src/main/java/com/maddyhome/idea/vim/group/NotificationService.kt

@@ -12,7 +12,6 @@ import com.intellij.icons.AllIcons
 import com.intellij.ide.BrowserUtil
 import com.intellij.ide.actions.OpenFileAction
 import com.intellij.ide.actions.RevealFileAction
-import com.intellij.notification.ActionCenter
 import com.intellij.notification.Notification
 import com.intellij.notification.NotificationGroup
 import com.intellij.notification.NotificationGroupManager
@@ -34,15 +33,13 @@ import com.intellij.openapi.ui.Messages
 import com.intellij.openapi.util.SystemInfo
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.VimEditor
-import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.handler.KeyMapIssue
 import com.maddyhome.idea.vim.helper.MessageHelper
+import com.maddyhome.idea.vim.icons.VimIcons
 import com.maddyhome.idea.vim.key.ShortcutOwner
 import com.maddyhome.idea.vim.key.ShortcutOwnerInfo
 import com.maddyhome.idea.vim.newapi.globalIjOptions
-import com.maddyhome.idea.vim.newapi.ijOptions
-import com.maddyhome.idea.vim.options.OptionConstants
 import com.maddyhome.idea.vim.statistic.ActionTracker
 import com.maddyhome.idea.vim.ui.VimEmulationConfigurable
 import com.maddyhome.idea.vim.vimscript.services.VimRcService
@@ -62,55 +59,11 @@ internal class NotificationService(private val project: Project?) {
   @Suppress("unused")
   constructor() : this(null)
 
-  fun notifyAboutIdeaPut() {
+  fun notifyAboutNewUndo() {}
-    val notification = Notification(
-      IDEAVIM_NOTIFICATION_ID,
-      IDEAVIM_NOTIFICATION_TITLE,
-      """Add <code>ideaput</code> to <code>clipboard</code> option to perform a put via the IDE<br/><b><code>set clipboard+=ideaput</code></b>""",
-      NotificationType.INFORMATION,
-    )
 
-    notification.addAction(OpenIdeaVimRcAction(notification))
+  fun notifyAboutIdeaPut() {}
 
-    notification.addAction(
+  fun notifyAboutIdeaJoin(editor: VimEditor) {}
-      AppendToIdeaVimRcAction(
-        notification,
-        "set clipboard^=ideaput",
-        "ideaput",
-      ) {
-        // Technically, we're supposed to prepend values to clipboard so that it's not added to the "exclude" item.
-        // Since we don't handle exclude, it's safe to append. But let's be clean.
-        injector.globalOptions().clipboard.prependValue(OptionConstants.clipboard_ideaput)
-      },
-    )
-
-    notification.notify(project)
-  }
-
-  fun notifyAboutIdeaJoin(editor: VimEditor) {
-    val notification = Notification(
-      IDEAVIM_NOTIFICATION_ID,
-      IDEAVIM_NOTIFICATION_TITLE,
-      """Put <b><code>set ideajoin</code></b> into your <code>~/.ideavimrc</code> to perform a join via the IDE""",
-      NotificationType.INFORMATION,
-    )
-
-    notification.addAction(OpenIdeaVimRcAction(notification))
-
-    notification.addAction(
-      AppendToIdeaVimRcAction(
-        notification,
-        "set ideajoin",
-        "ideajoin"
-      ) {
-        // This is a global-local option. Setting it will always set the global value
-        injector.ijOptions(editor).ideajoin = true
-      },
-    )
-
-    notification.addAction(HelpLink(ideajoinExamplesUrl))
-    notification.notify(project)
-  }
 
   fun enableRepeatingMode() = Messages.showYesNoDialog(
     "Do you want to enable repeating keys in macOS on press and hold?\n\n" +
@@ -182,8 +135,30 @@ internal class NotificationService(private val project: Project?) {
     ).notify(project)
   }
 
-  fun notifyActionId(id: String?, candidates: List<String>? = null) {
+  /**
-    ActionIdNotifier.notifyActionId(id, project, candidates)
+   * Shows a notification that the user can reenable IdeaVim by clicking on the IdeaVim icon in the status bar.
+   */
+  fun showReenableNotification(project: Project) {
+    val notification = Notification(
+      IDEAVIM_NOTIFICATION_ID,
+      IDEAVIM_NOTIFICATION_TITLE,
+      "IdeaVim has been disabled. You can reenable it by clicking on the gray IdeaVim icon in the status bar.",
+      NotificationType.INFORMATION,
+    )
+    notification.icon = VimIcons.IDEAVIM_DISABLED
+
+    notification.addAction(object : DumbAwareAction("Reenable IdeaVim") {
+      override fun actionPerformed(e: AnActionEvent) {
+        VimPlugin.setEnabled(true)
+        notification.expire()
+      }
+    })
+
+    notification.notify(project)
+  }
+
+  fun notifyActionId(id: String?, candidates: List<String>? = null, intentionName: String?) {
+    ActionIdNotifier.notifyActionId(id, project, candidates, intentionName)
   }
 
   fun notifyKeymapIssues(issues: ArrayList<KeyMapIssue>) {
@@ -196,7 +171,7 @@ internal class NotificationService(private val project: Project?) {
           is KeyMapIssue.AddShortcut -> {
             appendLine("- ${it.key} key is not assigned to the ${it.action} action.<br/>")
           }
-
+          
           is KeyMapIssue.RemoveShortcut -> {
             appendLine("- ${it.shortcut} key is incorrectly assigned to the ${it.action} action.<br/>")
           }
@@ -261,12 +236,15 @@ internal class NotificationService(private val project: Project?) {
   object ActionIdNotifier {
     private var notification: Notification? = null
 
-    fun notifyActionId(id: String?, project: Project?, candidates: List<String>? = null) {
+    fun notifyActionId(id: String?, project: Project?, candidates: List<String>? = null, intentionName: String? = null) {
       notification?.expire()
 
       val possibleIDs = candidates?.distinct()?.sorted()
       val content = when {
         id != null -> "Action ID: <code>$id</code><br><br>"
+        possibleIDs.isNullOrEmpty() && !intentionName.isNullOrEmpty() -> {
+          "Intention \"$intentionName\" does not have an action ID.<br><br>"
+        }
         possibleIDs.isNullOrEmpty() -> "<i>Cannot detect action ID</i><br><br>"
         possibleIDs.size == 1 -> "Possible action ID: <code>${possibleIDs[0]}</code><br><br>"
         else -> {
@@ -276,20 +254,20 @@ internal class NotificationService(private val project: Project?) {
             append("</ul></p>")
           }
         }
-      } + "<small>See the ${ActionCenter.getToolwindowName()} tool window for previous IDs</small>"
+      } + "<small>See the Notifications tool window for previous IDs</small>"
 
       notification =
         Notification(IDEAVIM_NOTIFICATION_ID, IDEAVIM_NOTIFICATION_TITLE, content, NotificationType.INFORMATION).also {
-          it.whenExpired { notification = null }
+        it.whenExpired { notification = null }
-          it.addAction(StopTracking())
+        it.addAction(StopTracking())
 
-          if (id != null || possibleIDs?.size == 1) {
+        if (id != null || possibleIDs?.size == 1) {
-            it.addAction(CopyActionId(id ?: possibleIDs?.get(0), project))
+          it.addAction(CopyActionId(id ?: possibleIDs?.get(0), project))
-          }
-
-          it.notify(project)
         }
 
+        it.notify(project)
+      }
+
       if (id != null) {
         ActionTracker.Util.logTrackedAction(id)
       }

src/main/java/com/maddyhome/idea/vim/group/RegisterGroup.java

@@ -25,10 +25,9 @@ import org.jetbrains.annotations.Nullable;
 import javax.swing.*;
 import java.awt.event.KeyEvent;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
-import static com.maddyhome.idea.vim.api.VimInjectorKt.injector;
-
 /**
  * This group works with command associated with copying and pasting text
  */
@@ -128,7 +127,7 @@ public class RegisterGroup extends VimRegisterGroupBase implements PersistentSta
           final String text = VimPlugin.getXML().getSafeXmlText(textElement);
           if (text != null) {
             logger.trace("Register data parsed");
-            register = new Register(key, injector.getClipboardManager().dumbCopiedText(text), type);
+            register = new Register(key, type, text, Collections.emptyList());
           }
           else {
             logger.trace("Cannot parse register data");

src/main/java/com/maddyhome/idea/vim/group/SystemMarks.kt

@@ -44,7 +44,7 @@ internal class SystemMarks {
 
 internal fun Project.createLineBookmark(editor: Editor, line: Int, mnemonic: Char): LineBookmark? {
   val bookmarksManager = BookmarksManager.getInstance(this) ?: return null
-  val lineBookmarkProvider = LineBookmarkProvider.find(this) ?: return null
+  val lineBookmarkProvider = LineBookmarkProvider.Util.find(this) ?: return null
   val bookmark = lineBookmarkProvider.createBookmark(editor, line) as LineBookmark? ?: return null
   val type = BookmarkType.get(mnemonic)
   if (type == BookmarkType.DEFAULT) return null

src/main/java/com/maddyhome/idea/vim/group/copy/PutGroup.kt

@@ -19,6 +19,7 @@ import com.intellij.openapi.editor.Caret
 import com.intellij.openapi.editor.RangeMarker
 import com.intellij.openapi.editor.ex.EditorEx
 import com.intellij.openapi.ide.CopyPasteManager
+import com.intellij.util.PlatformUtils
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimCaret
@@ -36,7 +37,6 @@ import com.maddyhome.idea.vim.ide.isClionNova
 import com.maddyhome.idea.vim.ide.isRider
 import com.maddyhome.idea.vim.mark.VimMarkConstants.MARK_CHANGE_POS
 import com.maddyhome.idea.vim.newapi.IjVimCaret
-import com.maddyhome.idea.vim.newapi.IjVimCopiedText
 import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
@@ -127,7 +127,7 @@ internal class PutGroup : VimPutBase() {
       point.dispose()
       if (!caret.isValid) return@forEach
 
-      val caretPossibleEndOffset = lastPastedRegion?.endOffset ?: (startOffset + text.copiedText.text.length)
+      val caretPossibleEndOffset = lastPastedRegion?.endOffset ?: (startOffset + text.text.length)
       val endOffset = if (data.indent) {
         doIndent(
           vimEditor,
@@ -179,10 +179,12 @@ internal class PutGroup : VimPutBase() {
     val allContentsBefore = CopyPasteManager.getInstance().allContents
     val sizeBeforeInsert = allContentsBefore.size
     val firstItemBefore = allContentsBefore.firstOrNull()
-    logger.debug { "Copied text: ${text.copiedText}" }
+    logger.debug { "Transferable classes: ${text.transferableData.joinToString { it.javaClass.name }}" }
-    val (textContent, transferableData) = text.copiedText as IjVimCopiedText
     val origContent: TextBlockTransferable =
-      injector.clipboardManager.setClipboardText(textContent, textContent, transferableData) as TextBlockTransferable
+      injector.clipboardManager.setClipboardText(
+      text.text,
+      transferableData = text.transferableData,
+    ) as TextBlockTransferable
     val allContentsAfter = CopyPasteManager.getInstance().allContents
     val sizeAfterInsert = allContentsAfter.size
     try {
@@ -190,7 +192,7 @@ internal class PutGroup : VimPutBase() {
     } finally {
       val textInClipboard = (firstItemBefore as? TextBlockTransferable)
         ?.getTransferData(DataFlavor.stringFlavor) as? String
-      val textOnTop = textInClipboard != null && textInClipboard != text.copiedText.text
+      val textOnTop = textInClipboard != null && textInClipboard != text.text
       if (sizeBeforeInsert != sizeAfterInsert || textOnTop) {
         // Sometimes an inserted text replaces an existing one. E.g. on insert with + or * register
         (CopyPasteManager.getInstance() as? CopyPasteManagerEx)?.run { removeContent(origContent) }
@@ -205,8 +207,9 @@ internal class PutGroup : VimPutBase() {
     startOffset: Int,
     endOffset: Int,
   ): Int {
-    // Temp fix for VIM-2808. Should be removed after rider will fix it's issues
+    // Temp fix for VIM-2808 for Rider and Clion. Should be removed after rider will fix it's issues
-    if (isRider() || isClionNova()) return endOffset
+    // Disable for client due to VIM-3857
+    if (isRider() || isClionNova() || PlatformUtils.isJetBrainsClient()) return endOffset
 
     val startLine = editor.offsetToBufferPosition(startOffset).line
     val endLine = editor.offsetToBufferPosition(endOffset - 1).line

src/main/java/com/maddyhome/idea/vim/group/visual/IdeaSelectionControl.kt

@@ -96,7 +96,7 @@ internal object IdeaSelectionControl {
       } else {
         logger.debug("None of carets have selection. State before adjustment: ${editor.vim.mode}")
         if (editor.vim.inVisualMode) editor.vim.exitVisualMode()
-        if (editor.vim.inSelectMode) editor.exitSelectMode(false)
+        if (editor.vim.inSelectMode) editor.vim.exitSelectMode(false)
 
         if (editor.vim.inNormalMode) {
           activateMode(editor, chooseNonSelectionMode(editor))

src/main/java/com/maddyhome/idea/vim/handler/CopilotKeymapCorrector.kt

@@ -17,7 +17,6 @@ import com.intellij.openapi.keymap.KeymapManagerListener
 import com.intellij.openapi.keymap.ex.KeymapManagerEx
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.startup.ProjectActivity
-import com.jetbrains.rd.util.ConcurrentHashMap
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.api.key
@@ -28,6 +27,8 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.launch
+import org.jetbrains.annotations.NonNls
+import java.util.concurrent.ConcurrentHashMap
 
 
 // We use alarm with delay to avoid many actions in case many events are fired at the same time
@@ -67,11 +68,7 @@ internal class IdeaVimCorrectorKeymapChangedListener : KeymapManagerListener {
     check(correctorRequester.tryEmit(Unit))
   }
 
-  override fun shortcutChanged(keymap: Keymap, actionId: String) {
+  override fun shortcutsChanged(keymap: Keymap, actionIds: @NonNls Collection<String>, fromSettings: Boolean) {
-    check(correctorRequester.tryEmit(Unit))
-  }
-
-  override fun shortcutChanged(keymap: Keymap, actionId: String, fromSettings: Boolean) {
     check(correctorRequester.tryEmit(Unit))
   }
 }

src/main/java/com/maddyhome/idea/vim/handler/KeymapChecker.kt

@@ -28,6 +28,7 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.launch
+import org.jetbrains.annotations.NonNls
 import javax.swing.KeyStroke
 
 // We use alarm with delay to avoid many notifications in case many events are fired at the same time
@@ -67,11 +68,7 @@ internal class IdeaVimKeymapChangedListener : KeymapManagerListener {
     check(keyCheckRequests.tryEmit(Unit))
   }
 
-  override fun shortcutChanged(keymap: Keymap, actionId: String) {
+  override fun shortcutsChanged(keymap: Keymap, actionIds: @NonNls Collection<String>, fromSettings: Boolean) {
-    check(keyCheckRequests.tryEmit(Unit))
-  }
-
-  override fun shortcutChanged(keymap: Keymap, actionId: String, fromSettings: Boolean) {
     check(keyCheckRequests.tryEmit(Unit))
   }
 }

src/main/java/com/maddyhome/idea/vim/helper/CaretVisualAttributesHelper.kt

@@ -60,7 +60,7 @@ internal fun Editor.updateCaretsVisualAttributes() {
  * Used when Vim emulation is disabled
  */
 internal fun Editor.removeCaretsVisualAttributes() {
-  caretModel.allCarets.forEach { it.visualAttributes = CaretVisualAttributes.DEFAULT }
+  caretModel.allCarets.forEach { it.visualAttributes = CaretVisualAttributes.getDefault() }
 }
 
 internal fun Editor.hasBlockOrUnderscoreCaret() = isBlockCursorOverride() ||
@@ -95,8 +95,8 @@ private fun Editor.updatePrimaryCaretVisualAttributes() {
 
   // Make sure the caret is visible as soon as it's set. It might be invisible while blinking
   // NOTE: At the moment, this causes project leak in tests
-  // IJPL-928 - this will be fixed in 2024.2
+  // IJPL-928 - this will be fixed in 2025.2
-  // [VERSION UPDATE] 2024.2 - remove if wrapping
+  // [VERSION UPDATE] 2025.2 - remove if wrapping
   if (!ApplicationManager.getApplication().isUnitTestMode) {
     (this as? EditorEx)?.setCaretVisible(true)
   }

src/main/java/com/maddyhome/idea/vim/helper/EditorDataContext.kt

@@ -1,67 +0,0 @@
-/*
- * Copyright 2003-2023 The IdeaVim authors
- *
- * Use of this source code is governed by an MIT-style
- * license that can be found in the LICENSE.txt file or at
- * https://opensource.org/licenses/MIT.
- */
-package com.maddyhome.idea.vim.helper
-
-import com.intellij.openapi.actionSystem.DataContext
-import com.intellij.openapi.actionSystem.PlatformDataKeys
-import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.editor.ex.util.EditorUtil
-import com.intellij.openapi.util.Key
-import com.intellij.openapi.util.UserDataHolder
-
-@Deprecated("Do not use context wrappers, use existing provided contexts. If no context available, use `injector.getExecutionContextManager().getEditorExecutionContext(editor)`")
-internal class EditorDataContext @Deprecated("Please use `init` method") constructor(
-  private val editor: Editor,
-  private val editorContext: DataContext,
-  private val contextDelegate: DataContext? = null,
-) : DataContext, UserDataHolder {
-  /**
-   * Returns the object corresponding to the specified data identifier. Some of the supported data identifiers are
-   * defined in the [PlatformDataKeys] class.
-   *
-   * @param dataId the data identifier for which the value is requested.
-   * @return the value, or null if no value is available in the current context for this identifier.
-   */
-  override fun getData(dataId: String): Any? = when {
-    PlatformDataKeys.EDITOR.name == dataId -> editor
-    PlatformDataKeys.PROJECT.name == dataId -> editor.project
-    PlatformDataKeys.VIRTUAL_FILE.name == dataId -> EditorHelper.getVirtualFile(editor)
-    else -> editorContext.getData(dataId) ?: contextDelegate?.getData(dataId)
-  }
-
-  override fun <T : Any?> getUserData(key: Key<T>): T? {
-    return if (contextDelegate is UserDataHolder) {
-      contextDelegate.getUserData(key)
-    } else {
-      null
-    }
-  }
-
-  override fun <T : Any?> putUserData(key: Key<T>, value: T?) {
-    if (contextDelegate is UserDataHolder) {
-      contextDelegate.putUserData(key, value)
-    }
-  }
-
-  companion object {
-    @Suppress("DEPRECATION")
-    @JvmStatic
-    fun init(editor: Editor, contextDelegate: DataContext? = null): EditorDataContext {
-      val editorContext = EditorUtil.getEditorDataContext(editor)
-      return if (contextDelegate is EditorDataContext) {
-        if (editor === contextDelegate.editor) {
-          contextDelegate
-        } else {
-          EditorDataContext(editor, editorContext, contextDelegate.contextDelegate)
-        }
-      } else {
-        EditorDataContext(editor, editorContext, contextDelegate)
-      }
-    }
-  }
-}

src/main/java/com/maddyhome/idea/vim/helper/EditorHelper.java

@@ -8,6 +8,7 @@
 
 package com.maddyhome.idea.vim.helper;
 
+import com.intellij.injected.editor.VirtualFileWindow;
 import com.intellij.openapi.editor.*;
 import com.intellij.openapi.editor.ex.util.EditorUtil;
 import com.intellij.openapi.editor.impl.EditorImpl;
@@ -15,6 +16,7 @@ import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.registry.Registry;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileUtil;
 import com.intellij.testFramework.LightVirtualFile;
 import com.maddyhome.idea.vim.api.EngineEditorHelperKt;
 import com.maddyhome.idea.vim.api.VimEditor;
@@ -342,7 +344,7 @@ public class EditorHelper {
 
     final int offset = y - ((screenHeight - lineHeight) / lineHeight / 2 * lineHeight);
     final @NotNull VimEditor editor1 = new IjVimEditor(editor);
-    final int lastVisualLine = EngineEditorHelperKt.getVisualLineCount(editor1) - 1;
+    final int lastVisualLine = EngineEditorHelperKt.getVisualLineCount(editor1) + editor.getSettings().getAdditionalLinesCount();
     final int offsetForLastLineAtBottom = getOffsetToScrollVisualLineToBottomOfScreen(editor, lastVisualLine);
 
     // For `zz`, we want to use virtual space and move any line, including the last one, to the middle of the screen.
@@ -652,7 +654,21 @@ public class EditorHelper {
    */
   public static boolean isFileEditor(@NotNull Editor editor) {
     final VirtualFile virtualFile = getVirtualFile(editor);
-    return virtualFile != null && !(virtualFile instanceof LightVirtualFile);
+    if (virtualFile == null) return false;
+    if (virtualFile instanceof LightVirtualFile) {
+      var hostVirtualFile = getHostFileFromInjectedFile(virtualFile);
+      if (hostVirtualFile == null) return false;
+      return !(hostVirtualFile instanceof LightVirtualFile);
+    }
+    return true;
+  }
+
+  private static @Nullable VirtualFile getHostFileFromInjectedFile(@NotNull VirtualFile virtualFile) {
+    final var vf = VirtualFileUtil.originalFileOrSelf(virtualFile);
+    if (vf instanceof VirtualFileWindow) {
+      return ((VirtualFileWindow)vf).getDelegate();
+    }
+    return null;
   }
 
   /**

src/main/java/com/maddyhome/idea/vim/helper/EditorHelper.kt

@@ -12,7 +12,9 @@ package com.maddyhome.idea.vim.helper
 
 import com.intellij.codeWithMe.ClientId
 import com.intellij.openapi.editor.Caret
+import com.intellij.openapi.editor.CaretState
 import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.EditorKind
 import com.intellij.openapi.editor.ex.util.EditorUtil
 import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
 import com.intellij.util.ui.table.JBTableRowEditor
@@ -21,6 +23,8 @@ import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.group.IjOptionConstants
 import com.maddyhome.idea.vim.key.IdeaVimDisablerExtensionPoint
 import com.maddyhome.idea.vim.newapi.globalIjOptions
+import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.mode.inBlockSelection
 import java.awt.Component
 import javax.swing.JComponent
 import javax.swing.JTable
@@ -39,9 +43,33 @@ internal val Editor.isIdeaVimDisabledHere: Boolean
     return (ideaVimDisabledInDialog(ideaVimSupportValue) && isInDialog()) ||
       !ClientId.isCurrentlyUnderLocalId || // CWM-927
       (ideaVimDisabledForSingleLine(ideaVimSupportValue) && isSingleLine()) ||
-      IdeaVimDisablerExtensionPoint.isDisabledForEditor(this)
+      IdeaVimDisablerExtensionPoint.isDisabledForEditor(this) ||
+      isNotFileEditorExceptAllowed()
   }
 
+/**
+ * Almost every non-file-based editor should not use Vim mode. These editors are debug watch, Python console, AI chats,
+ *   and other fields that are smart.
+ *
+ * We may support IdeaVim in these editors, but this will require a focused work and a lot of testing.
+ *
+ * Here are issues when non-file editors were supported:
+ * AI Chat – VIM-3786
+ * Debug evaluate console – VIM-3929
+ *
+ * However, we still support IdeaVim in a commit window because it works fine there, and removing vim from this place will
+ *   be quite a visible change for users.
+ * We detect the commit window by the name of the editor (Dummy.txt). If this causes issues, let's disable IdeaVim
+ *   in the commit window as well.
+ *
+ * Also, we support IdeaVim in diff viewers.
+ */
+private fun Editor.isNotFileEditorExceptAllowed(): Boolean {
+  if (EditorHelper.getVirtualFile(this)?.name?.contains("Dummy.txt") == true) return false
+  if (EditorHelper.isDiffEditor(this)) return false
+  return !EditorHelper.isFileEditor(this)
+}
+
 private fun ideaVimDisabledInDialog(ideaVimSupportValue: StringListOptionValue): Boolean {
   return !ideaVimSupportValue.contains(IjOptionConstants.ideavimsupport_dialog)
     && !ideaVimSupportValue.contains(IjOptionConstants.ideavimsupport_dialoglegacy)
@@ -68,6 +96,19 @@ internal fun Editor.isPrimaryEditor(): Boolean {
   return fileEditorManager.allEditors.any { fileEditor -> this == EditorUtil.getEditorEx(fileEditor) }
 }
 
+/**
+ * Checks if the editor should be treated like a terminal. I.e. switch to Insert mode automatically
+ *
+ * A "terminal" editor is an editor used for purposes other than mainstream editing, such as a terminal, console, log
+ * viewer, etc. In this instance, the editor is writable, the document is writable, but it's not backed by a real file
+ * and it's not the diff viewer. We also check that if it's an injected language fragment backed by a real file.
+ */
+internal fun Editor.isTerminalEditor(): Boolean {
+  return !isViewer
+    && document.isWritable
+    && this.editorKind == EditorKind.CONSOLE
+}
+
 // Optimized clone of com.intellij.ide.ui.laf.darcula.DarculaUIUtil.isTableCellEditor
 private fun isTableCellEditor(c: Component): Boolean {
   return (java.lang.Boolean.TRUE == (c as JComponent).getClientProperty("JComboBox.isTableCellEditor")) ||
@@ -97,4 +138,42 @@ internal val Caret.vimLine: Int
  * Get current caret line in vim notation (1-based)
  */
 internal val Editor.vimLine: Int
-  get() = this.caretModel.currentCaret.vimLine
+  get() = this.caretModel.currentCaret.vimLine
+
+internal inline fun Editor.runWithEveryCaretAndRestore(action: () -> Unit) {
+  val caretModel = this.caretModel
+  val carets = if (this.vim.inBlockSelection) null else caretModel.allCarets
+  if (carets == null || carets.size == 1) {
+    action()
+  }
+  else {
+    var initialDocumentSize = this.document.textLength
+    var documentSizeDifference = 0
+
+    val caretOffsets = carets.map { it.selectionStart to it.selectionEnd }
+    val restoredCarets = mutableListOf<CaretState>()
+
+    caretModel.removeSecondaryCarets()
+    
+    for ((selectionStart, selectionEnd) in caretOffsets) {
+      if (selectionStart == selectionEnd) {
+        caretModel.primaryCaret.moveToOffset(selectionStart + documentSizeDifference)
+      }
+      else {
+        caretModel.primaryCaret.setSelection(
+          selectionStart + documentSizeDifference,
+          selectionEnd + documentSizeDifference
+        )
+      }
+      
+      action()
+      restoredCarets.add(caretModel.caretsAndSelections.single())
+
+      val documentLength = this.document.textLength
+      documentSizeDifference += documentLength - initialDocumentSize
+      initialDocumentSize = documentLength
+    }
+
+    caretModel.caretsAndSelections = restoredCarets
+  } 
+}

src/main/java/com/maddyhome/idea/vim/helper/IjActionExecutor.kt

@@ -8,18 +8,15 @@
 
 package com.maddyhome.idea.vim.helper
 
-import com.intellij.openapi.actionSystem.ActionGroup
+import com.intellij.execution.actions.StopAction
 import com.intellij.openapi.actionSystem.ActionManager
 import com.intellij.openapi.actionSystem.ActionPlaces
 import com.intellij.openapi.actionSystem.AnAction
-import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.EmptyAction
 import com.intellij.openapi.actionSystem.IdeActions
 import com.intellij.openapi.actionSystem.PlatformDataKeys
 import com.intellij.openapi.actionSystem.ex.ActionUtil
-import com.intellij.openapi.actionSystem.ex.ActionUtil.performDumbAwareWithCallbacks
 import com.intellij.openapi.actionSystem.impl.ProxyShortcutSet
-import com.intellij.openapi.actionSystem.impl.SimpleDataContext
 import com.intellij.openapi.application.ex.ApplicationManagerEx
 import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.command.UndoConfirmationPolicy
@@ -27,9 +24,7 @@ import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.thisLogger
 import com.intellij.openapi.editor.actionSystem.DocCommandGroupId
 import com.intellij.openapi.progress.util.ProgressIndicatorUtils
-import com.intellij.openapi.ui.popup.JBPopupFactory
 import com.intellij.openapi.util.NlsContexts
-import com.intellij.openapi.util.registry.Registry
 import com.maddyhome.idea.vim.RegisterActions
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.NativeAction
@@ -39,11 +34,9 @@ import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.handler.EditorActionHandlerBase
 import com.maddyhome.idea.vim.newapi.IjNativeAction
 import com.maddyhome.idea.vim.newapi.ij
-import com.maddyhome.idea.vim.newapi.runFromVimKey
 import org.jetbrains.annotations.NonNls
 import java.awt.Component
 import javax.swing.JComponent
-import javax.swing.SwingUtilities
 
 @Service
 internal class IjActionExecutor : VimActionExecutor {
@@ -62,8 +55,11 @@ internal class IjActionExecutor : VimActionExecutor {
   override val ACTION_EXPAND_REGION_RECURSIVELY: String
     get() = IdeActions.ACTION_EXPAND_REGION_RECURSIVELY
   override val ACTION_EXPAND_COLLAPSE_TOGGLE: String
-    // [VERSION UPDATE] 2024.3+ Replace raw "ExpandCollapseToggleAction" with IdeActions.ACTION_EXPAND_COLLAPSE_TOGGLE_REGION from the platform.
+    get() = IdeActions.ACTION_EXPAND_COLLAPSE_TOGGLE_REGION
-    get() = "ExpandCollapseToggleAction"
+  override val ACTION_UNDO: String
+    get() = IdeActions.ACTION_UNDO
+  override val ACTION_REDO: String
+    get() = IdeActions.ACTION_REDO
 
   var isRunningActionFromVim: Boolean = false
 
@@ -75,77 +71,28 @@ internal class IjActionExecutor : VimActionExecutor {
     }
 
     val ijAction = (action as IjNativeAction).action
-    if (Registry.`is`("ideavim.old.action.execution", true)) {
+    try {
-      return manualActionExecution(context, ijAction)
+      isRunningActionFromVim = true
-    } else {
+      // The context component should be editor. This is especially important when running the `:action` commands
-      try {
+      //  because at the moment of execution, the focused component is Ex Field, not editor.
-        isRunningActionFromVim = true
+      val contextComponent = editor?.ij?.contentComponent
-        // The context component should be editor. This is especially important when running the `:action` commands
+      val place = ijAction.choosePlace()
-        //  because at the moment of execution, the focused component is Ex Field, not editor.
+      val res = ActionManager.getInstance().tryToExecute(ijAction, null, contextComponent, place, true)
-        val contextComponent = editor?.ij?.contentComponent
+      res.waitFor(5_000)
-        val res = ActionManager.getInstance().tryToExecute(ijAction, null, contextComponent, "IdeaVim", true)
+      return res.isDone
-        res.waitFor(5_000)
+    } finally {
-        return res.isDone
+      isRunningActionFromVim = false
-      } finally {
-        isRunningActionFromVim = false
-      }
     }
   }
 
-  private fun manualActionExecution(
+  // Note: We should find a proper place for the IdeaVim actions
-    context: ExecutionContext,
+  // Currently, we use "IdeaVim" except a few actions
-    ijAction: AnAction,
+  private fun AnAction.choosePlace(): String {
-  ): Boolean {
+    // StopAction works fine if `StopAction.isPlaceGlobal` returns true
-    /**
+    // Or if there is a specific data stored in the context. This data, however, is stored
-     * Data context that defines that some action was started from IdeaVim.
+    //   only if the run window is in focus.
-     * You can call use [runFromVimKey] key to define if intellij action was started from IdeaVim
+    if (this is StopAction) return ActionPlaces.ACTION_SEARCH
-     */
+    return "IdeaVim"
-    val dataContext = SimpleDataContext.getSimpleContext(runFromVimKey, true, context.ij)
-
-    val actionId = ActionManager.getInstance().getId(ijAction)
-    @Suppress("removal", "DEPRECATION") val event = AnActionEvent(
-      null,
-      dataContext,
-      ActionPlaces.KEYBOARD_SHORTCUT,
-      ijAction.templatePresentation.clone(),
-      ActionManager.getInstance(),
-      0,
-    )
-    // beforeActionPerformedUpdate should be called to update the action. It fixes some rider-specific problems
-    //   because rider uses an async update method. See VIM-1819.
-    // This method executes inside lastUpdateAndCheckDumb
-    // Another related issue: VIM-2604
-
-    // This is a hack to fix the tests and fix VIM-3332
-    // We should get rid of it in VIM-3376
-    if (actionId == "RunClass" || actionId == IdeActions.ACTION_COMMENT_LINE || actionId == IdeActions.ACTION_COMMENT_BLOCK) {
-      @Suppress("removal", "OverrideOnly", "DEPRECATION")
-      ijAction.beforeActionPerformedUpdate(event)
-      if (!event.presentation.isEnabled) return false
-    } else {
-      if (!ActionUtil.lastUpdateAndCheckDumb(ijAction, event, false)) return false
-    }
-    if (ijAction is ActionGroup && !event.presentation.isPerformGroup) {
-      // Some ActionGroups should not be performed but shown as a popup
-      val popup = JBPopupFactory.getInstance()
-        .createActionGroupPopup(event.presentation.text, ijAction, dataContext, false, null, -1)
-      val component = dataContext.getData(PlatformDataKeys.CONTEXT_COMPONENT)
-      if (component != null) {
-        val window = SwingUtilities.getWindowAncestor(component)
-        if (window != null) {
-          popup.showInCenterOf(window)
-        }
-        return true
-      }
-      popup.showInFocusCenter()
-      return true
-    } else {
-      performDumbAwareWithCallbacks(ijAction, event) {
-        @Suppress("OverrideOnly")
-        ijAction.actionPerformed(event)
-      }
-      return true
-    }
   }
 
   /**

src/main/java/com/maddyhome/idea/vim/helper/MacKeyRepeat.java

@@ -1,75 +0,0 @@
-/*
- * Copyright 2003-2023 The IdeaVim authors
- *
- * Use of this source code is governed by an MIT-style
- * license that can be found in the LICENSE.txt file or at
- * https://opensource.org/licenses/MIT.
- */
-
-package com.maddyhome.idea.vim.helper;
-
-import com.google.common.io.CharStreams;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-
-/**
- * @author vlan
- */
-public class MacKeyRepeat {
-  @VimNlsSafe public static final String FMT = "defaults %s -globalDomain ApplePressAndHoldEnabled";
-  @NotNull private static final MacKeyRepeat INSTANCE = new MacKeyRepeat();
-  @NonNls private static final String EXEC_COMMAND = "launchctl stop com.apple.SystemUIServer.agent";
-  @NonNls private static final String delete = "delete";
-  @NonNls private static final String write = "write";
-  @NonNls private static final String read = "read";
-
-  public static @NotNull MacKeyRepeat getInstance() {
-    return INSTANCE;
-  }
-
-  private static @NotNull String read(@NotNull InputStream stream) throws IOException {
-    return CharStreams.toString(new InputStreamReader(stream));
-  }
-
-  public @Nullable Boolean isEnabled() {
-    final String command = String.format(FMT, read);
-    try {
-      final Process process = Runtime.getRuntime().exec(command);
-      final String data = read(process.getInputStream()).trim();
-      try {
-        return Integer.parseInt(data) == 0;
-      }
-      catch (NumberFormatException e) {
-        return null;
-      }
-    }
-    catch (IOException e) {
-      return null;
-    }
-  }
-
-  public void setEnabled(@Nullable Boolean value) {
-    final String command;
-    if (value == null) {
-      command = String.format(FMT, delete);
-    }
-    else {
-      final String arg = value ? "0" : "1";
-      command = String.format(FMT, write) + " " + arg;
-    }
-    try {
-      final Runtime runtime = Runtime.getRuntime();
-      final Process defaults = runtime.exec(command);
-      defaults.waitFor();
-      final Process restartSystemUI = runtime.exec(EXEC_COMMAND);
-      restartSystemUI.waitFor();
-    }
-    catch (IOException | InterruptedException ignored) {
-    }
-  }
-}

src/main/java/com/maddyhome/idea/vim/helper/MacKeyRepeat.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2003-2023 The IdeaVim authors
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE.txt file or at
+ * https://opensource.org/licenses/MIT.
+ */
+package com.maddyhome.idea.vim.helper
+
+import com.google.common.io.CharStreams
+import java.io.IOException
+import java.io.InputStream
+import java.io.InputStreamReader
+
+object MacKeyRepeat {
+  var isEnabled: Boolean?
+    get() {
+      return try {
+        val process = Runtime.getRuntime().exec(READ_COMMAND)
+        val data = read(process.inputStream).trim().toIntOrNull() ?: return null
+        data == 0
+      } catch (_: IOException) {
+        null
+      }
+    }
+    set(value) {
+      val command: Array<String>
+      if (value == null) {
+        command = DELETE_COMMAND
+      } else {
+        val arg = if (value) "0" else "1"
+        command = WRITE_COMMAND + arg
+      }
+      try {
+        val runtime = Runtime.getRuntime()
+        val defaults = runtime.exec(command)
+        defaults.waitFor()
+        val restartSystemUI: Process = runtime.exec(EXEC_COMMAND)
+        restartSystemUI.waitFor()
+      } catch (_: IOException) {
+      } catch (_: InterruptedException) {
+      }
+    }
+
+  private val EXEC_COMMAND = arrayOf("launchctl", "stop", "com.apple.SystemUIServer.agent")
+  private val READ_COMMAND = arrayOf("defaults", "read", "-globalDomain", "ApplePressAndHoldEnabled")
+  private val WRITE_COMMAND = arrayOf("defaults", "write", "-globalDomain", "ApplePressAndHoldEnabled")
+  private val DELETE_COMMAND = arrayOf("defaults", "delete", "-globalDomain", "ApplePressAndHoldEnabled")
+
+  @Throws(IOException::class)
+  private fun read(stream: InputStream): String {
+    return CharStreams.toString(InputStreamReader(stream))
+  }
+}

src/main/java/com/maddyhome/idea/vim/helper/ModeExtensions.kt

@@ -24,28 +24,6 @@ import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.state.mode.inSelectMode
 
-/** [adjustCaretPosition] - if true, caret will be moved one char left if it's on the line end */
-internal fun Editor.exitSelectMode(adjustCaretPosition: Boolean) {
-  val vimEditor = this.vim
-  if (!vimEditor.inSelectMode) return
-
-  vimEditor.mode = vimEditor.mode.returnTo
-  SelectionVimListenerSuppressor.lock().use {
-    this.caretModel.allCarets.forEach {
-      // NOTE: I think it should be write action, but the exception shows only an absence of the read action
-      injector.application.runReadAction { it.removeSelection() }
-      it.vim.vimSelectionStartClear()
-      if (adjustCaretPosition && !vimEditor.isEndAllowed) {
-        val lineEnd = IjVimEditor(this).getLineEndForOffset(it.offset)
-        val lineStart = IjVimEditor(this).getLineStartForOffset(it.offset)
-        if (it.offset == lineEnd && it.offset != lineStart) {
-          it.moveToInlayAwareOffset(it.offset - 1)
-        }
-      }
-    }
-  }
-}
-
 /** [adjustCaretPosition] - if true, caret will be moved one char left if it's on the line end */
 internal fun VimEditor.exitSelectMode(adjustCaretPosition: Boolean) {
   if (!this.inSelectMode) return

src/main/java/com/maddyhome/idea/vim/helper/PsiHelper.java

@@ -42,7 +42,7 @@ public class PsiHelper {
     if (file == null) {
       return -1;
     }
-    StructureViewBuilder structureViewBuilder = LanguageStructureViewBuilder.INSTANCE.getStructureViewBuilder(file);
+    StructureViewBuilder structureViewBuilder = LanguageStructureViewBuilder.getInstance().getStructureViewBuilder(file);
     if (!(structureViewBuilder instanceof TreeBasedStructureViewBuilder builder)) return -1;
     StructureViewModel model = builder.createStructureViewModel(editor);
 

src/main/java/com/maddyhome/idea/vim/helper/ScrollViewHelper.kt

@@ -59,7 +59,7 @@ internal object ScrollViewHelper {
     // that this needs to be replaced as a more or less dumb line for line rewrite.
     val topLine = getVisualLineAtTopOfScreen(editor)
     val bottomLine = getVisualLineAtBottomOfScreen(editor)
-    val lastLine = vimEditor.getVisualLineCount() - 1
+    val lastLine = vimEditor.getVisualLineCount() + editor.settings.additionalLinesCount
 
     // We need the non-normalised value here, so we can handle cases such as so=999 to keep the current line centred
     val scrollOffset = injector.options(vimEditor).scrolloff

src/main/java/com/maddyhome/idea/vim/helper/SearchHighlightsHelper.kt

@@ -17,6 +17,7 @@ import com.intellij.openapi.editor.markup.HighlighterLayer
 import com.intellij.openapi.editor.markup.HighlighterTargetArea
 import com.intellij.openapi.editor.markup.RangeHighlighter
 import com.intellij.openapi.editor.markup.TextAttributes
+import com.intellij.util.application
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
@@ -30,6 +31,7 @@ import com.maddyhome.idea.vim.state.mode.inVisualMode
 import org.jetbrains.annotations.Contract
 import java.awt.Font
 import java.util.*
+import javax.swing.Timer
 
 internal fun updateSearchHighlights(
   pattern: String?,
@@ -84,6 +86,12 @@ internal fun addSubstitutionConfirmationHighlight(editor: Editor, start: Int, en
   )
 }
 
+val removeHighlightsEditors = mutableListOf<Editor>()
+val removeHighlightsTimer = Timer(400) {
+  removeHighlightsEditors.forEach(::removeSearchHighlights)
+  removeHighlightsEditors.clear()
+}
+
 /**
  * Refreshes current search highlights for all visible editors
  */
@@ -125,27 +133,43 @@ private fun updateSearchHighlights(
       // hlsearch (+ incsearch/noincsearch)
       // Make sure the range fits this editor. Note that Vim will use the same range for all windows. E.g., given
       // `:1,5s/foo`, Vim will highlight all occurrences of `foo` in the first five lines of all visible windows
-      val vimEditor = editor.vim
+      val isSearching = injector.commandLine.getActiveCommandLine() != null
-      val editorLastLine = vimEditor.lineCount() - 1
+      application.invokeLater {
-      val searchStartLine = searchRange?.startLine ?: 0
+        val vimEditor = editor.vim
-      val searchEndLine = (searchRange?.endLine ?: -1).coerceAtMost(editorLastLine)
+        val editorLastLine = vimEditor.lineCount() - 1
-      if (searchStartLine <= editorLastLine) {
+        val searchStartLine = searchRange?.startLine ?: 0
-        val results =
+        val searchEndLine = (searchRange?.endLine ?: -1).coerceAtMost(editorLastLine)
-          injector.searchHelper.findAll(
+        if (searchStartLine <= editorLastLine) {
-            vimEditor,
+          val visibleArea = editor.scrollingModel.visibleAreaOnScrollingFinished
-            pattern,
+          val visibleTopLeft = visibleArea.location
-            searchStartLine,
+          val visibleBottomRight = visibleArea.location.apply { translate(visibleArea.width, visibleArea.height) }
-            searchEndLine,
+          val visibleStartOffset = editor.logicalPositionToOffset(editor.xyToLogicalPosition(visibleTopLeft))
-            shouldIgnoreCase(pattern, shouldIgnoreSmartCase)
+          val visibleEndOffset = editor.logicalPositionToOffset(editor.xyToLogicalPosition(visibleBottomRight))
-          )
+          val visibleStartLine = editor.document.getLineNumber(visibleStartOffset)
-        if (results.isNotEmpty()) {
+          val visibleEndLine = editor.document.getLineNumber(visibleEndOffset)
-          if (editor === currentEditor?.ij) {
+          removeSearchHighlights(editor)
-            currentMatchOffset = findClosestMatch(results, initialOffset, count1, forwards)
+
+          val results =
+            injector.searchHelper.findAll(
+              vimEditor,
+              pattern,
+              searchStartLine.coerceAtLeast(visibleStartLine),
+              searchEndLine.coerceAtMost(visibleEndLine),
+              shouldIgnoreCase(pattern, shouldIgnoreSmartCase)
+            )
+          if (results.isNotEmpty()) {
+            if (editor === currentEditor?.ij) {
+              currentMatchOffset = findClosestMatch(results, initialOffset, count1, forwards)
+            }
+            highlightSearchResults(editor, pattern, results, currentMatchOffset)
+            if (!isSearching) {
+              removeHighlightsEditors.add(editor)
+              removeHighlightsTimer.restart()
+            }
           }
-          highlightSearchResults(editor, pattern, results, currentMatchOffset)
         }
+        editor.vimLastSearch = pattern
       }
-      editor.vimLastSearch = pattern
     } else if (shouldAddCurrentMatchSearchHighlight(pattern, showHighlights, initialOffset)) {
       // nohlsearch + incsearch. Even though search highlights are disabled, we still show a highlight (current editor
       // only), because 'incsearch' is active. But we don't show a search if Visual is active (behind Command-line of
@@ -179,6 +203,7 @@ private fun updateSearchHighlights(
     }
   }
 
+  removeHighlightsTimer.restart()
   return currentEditorCurrentMatchOffset
 }
 
@@ -204,7 +229,7 @@ private fun removeSearchHighlights(editor: Editor) {
  */
 @Contract("_, _, false -> false; _, null, true -> false")
 private fun shouldAddAllSearchHighlights(editor: Editor, newPattern: String?, hlSearch: Boolean): Boolean {
-  return hlSearch && newPattern != null && newPattern != editor.vimLastSearch && newPattern != ""
+  return hlSearch && newPattern != null && newPattern != ""
 }
 
 private fun findClosestMatch(

src/main/java/com/maddyhome/idea/vim/helper/UndoRedoHelper.kt

@@ -19,6 +19,8 @@ import com.intellij.openapi.fileEditor.TextEditor
 import com.intellij.openapi.fileEditor.TextEditorWithPreview
 import com.intellij.openapi.fileEditor.impl.text.TextEditorProvider
 import com.intellij.openapi.util.registry.Registry
+import com.intellij.util.PlatformUtils
+import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimCaret
 import com.maddyhome.idea.vim.api.VimEditor
@@ -28,6 +30,8 @@ import com.maddyhome.idea.vim.common.InsertSequence
 import com.maddyhome.idea.vim.newapi.IjVimCaret
 import com.maddyhome.idea.vim.newapi.globalIjOptions
 import com.maddyhome.idea.vim.newapi.ij
+import com.maddyhome.idea.vim.state.mode.SelectionType
+import com.maddyhome.idea.vim.state.mode.inVisualMode
 import com.maddyhome.idea.vim.undo.VimTimestampBasedUndoService
 
 /**
@@ -40,6 +44,12 @@ internal class UndoRedoHelper : VimTimestampBasedUndoService {
   }
 
   override fun undo(editor: VimEditor, context: ExecutionContext): Boolean {
+    if (PlatformUtils.isJetBrainsClient()) {
+      // Note: Remote Dev has special hacks for undo/redo, so we don't use the manager.
+      // The action is sent directly to the backend using the internal API.
+      return injector.actionExecutor.executeAction(editor, injector.actionExecutor.ACTION_UNDO, context)
+    }
+
     val ijContext = context.context as DataContext
     val project = PlatformDataKeys.PROJECT.getData(ijContext) ?: return false
     val textEditor = getTextEditor(editor.ij)
@@ -75,15 +85,7 @@ internal class UndoRedoHelper : VimTimestampBasedUndoService {
       // TODO refactor me after VIM-308 when restoring selection and caret movement will be ignored by undo
       editor.runWithChangeTracking {
         undoManager.undo(fileEditor)
-
+        restoreVisualMode(editor)
-        // We execute undo one more time if the previous one just restored selection
-        if (!hasChanges && hasSelection(editor) && undoManager.isUndoAvailable(fileEditor)) {
-          undoManager.undo(fileEditor)
-        }
-      }
-
-      CommandProcessor.getInstance().runUndoTransparentAction {
-        removeSelections(editor)
       }
     } else {
       runWithBooleanRegistryOption("ide.undo.transparent.caret.movement", true) {
@@ -111,6 +113,10 @@ internal class UndoRedoHelper : VimTimestampBasedUndoService {
   }
 
   override fun redo(editor: VimEditor, context: ExecutionContext): Boolean {
+    if (PlatformUtils.isJetBrainsClient()) {
+      return injector.actionExecutor.executeAction(editor, injector.actionExecutor.ACTION_REDO, context)
+    }
+
     val ijContext = context.context as DataContext
     val project = PlatformDataKeys.PROJECT.getData(ijContext) ?: return false
     val textEditor = getTextEditor(editor.ij)
@@ -230,4 +236,21 @@ internal class UndoRedoHelper : VimTimestampBasedUndoService {
     val hasChanges: Boolean
       get() = changeListener.hasChanged || initialPath != editor.getPath()
   }
+
+  private fun restoreVisualMode(editor: VimEditor) {
+    if (!editor.inVisualMode && editor.getSelectionModel().hasSelection()) {
+      val detectedMode = VimPlugin.getVisualMotion().detectSelectionType(editor)
+
+      // Visual block selection is restored into multiple carets, so multi-carets that form a block are always
+      // identified as visual block mode, leading to false positives.
+      // Since I use visual block mode much less often than multi-carets, this is a judgment call to never restore
+      // visual block mode.
+      val wantedMode = if (detectedMode == SelectionType.BLOCK_WISE)
+        SelectionType.CHARACTER_WISE
+      else
+        detectedMode
+
+      VimPlugin.getVisualMotion().enterVisualMode(editor, wantedMode)
+    }
+  }
 }

src/main/java/com/maddyhome/idea/vim/helper/UserDataManager.kt

@@ -18,7 +18,6 @@ import com.intellij.openapi.editor.VisualPosition
 import com.intellij.openapi.editor.markup.RangeHighlighter
 import com.intellij.openapi.util.Key
 import com.intellij.openapi.util.UserDataHolder
-import com.maddyhome.idea.vim.api.CaretRegisterStorageBase
 import com.maddyhome.idea.vim.api.LocalMarkStorage
 import com.maddyhome.idea.vim.api.SelectionInfo
 import com.maddyhome.idea.vim.common.InsertSequence
@@ -98,7 +97,6 @@ internal var Caret.vimInsertStart: RangeMarker by userDataOr {
 }
 
 // TODO: Data could be lost during visual block motion
-internal var Caret.registerStorage: CaretRegisterStorageBase? by userDataCaretToEditor()
 internal var Caret.markStorage: LocalMarkStorage? by userDataCaretToEditor()
 internal var Caret.lastSelectionInfo: SelectionInfo? by userDataCaretToEditor()
 

src/main/java/com/maddyhome/idea/vim/helper/VimStandalonePluginUpdateChecker.kt

@@ -1,32 +0,0 @@
-/*
- * Copyright 2003-2023 The IdeaVim authors
- *
- * Use of this source code is governed by an MIT-style
- * license that can be found in the LICENSE.txt file or at
- * https://opensource.org/licenses/MIT.
- */
-
-package com.maddyhome.idea.vim.helper
-
-import com.intellij.ide.plugins.StandalonePluginUpdateChecker
-import com.intellij.openapi.components.Service
-import com.intellij.openapi.components.service
-import com.maddyhome.idea.vim.VimPlugin
-import com.maddyhome.idea.vim.group.NotificationService
-import com.maddyhome.idea.vim.icons.VimIcons
-
-@Service(Service.Level.APP)
-internal class VimStandalonePluginUpdateChecker : StandalonePluginUpdateChecker(
-  VimPlugin.getPluginId(),
-  updateTimestampProperty = PROPERTY_NAME,
-  NotificationService.IDEAVIM_STICKY_GROUP,
-  VimIcons.IDEAVIM,
-) {
-
-  override fun skipUpdateCheck(): Boolean = VimPlugin.isNotEnabled() || "dev" in VimPlugin.getVersion()
-
-  companion object {
-    private const val PROPERTY_NAME = "ideavim.statistics.timestamp"
-    fun getInstance(): VimStandalonePluginUpdateChecker = service()
-  }
-}

src/main/java/com/maddyhome/idea/vim/listener/IJEditorFocusListener.kt

@@ -10,8 +10,6 @@ package com.maddyhome.idea.vim.listener
 
 import com.intellij.execution.impl.ConsoleViewImpl
 import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.editor.EditorKind
 import com.maddyhome.idea.vim.KeyHandler
 import com.maddyhome.idea.vim.LastUsedEditorInfo
 import com.maddyhome.idea.vim.VimPlugin
@@ -19,8 +17,8 @@ import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.common.EditorListener
-import com.maddyhome.idea.vim.helper.EditorHelper
 import com.maddyhome.idea.vim.helper.inInsertMode
+import com.maddyhome.idea.vim.helper.isTerminalEditor
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.state.mode.Mode
 
@@ -57,7 +55,7 @@ class IJEditorFocusListener : EditorListener {
     // to know that a read-only editor that is hosting a console view with a running process can be treated as writable.
 
     val ijEditor = editor.ij
-    val isCurrentEditorTerminal = isTerminal(ijEditor)
+    val isCurrentEditorTerminal = ijEditor.isTerminalEditor()
 
     KeyHandler.getInstance().lastUsedEditorInfo = LastUsedEditorInfo(currentEditorHashCode, false)
 
@@ -66,8 +64,10 @@ class IJEditorFocusListener : EditorListener {
       VimPlugin.getChange().insertBeforeCursor(editor, context)
       KeyHandler.getInstance().lastUsedEditorInfo = LastUsedEditorInfo(currentEditorHashCode, true)
     }
-    if (isCurrentEditorTerminal && !ijEditor.inInsertMode) {
+    if (isCurrentEditorTerminal) {
-      switchToInsertMode.run()
+      if (!ijEditor.inInsertMode) {
+        switchToInsertMode.run()
+      }
     } else if (ijEditor.isInsertMode && (oldEditorInfo.isInsertModeForced || !ijEditor.document.isWritable)) {
       val context: ExecutionContext = injector.executionContextManager.getEditorExecutionContext(editor)
       val mode = injector.vimState.mode
@@ -87,12 +87,4 @@ class IJEditorFocusListener : EditorListener {
     }
     KeyHandler.getInstance().reset(editor)
   }
-
-  // By "terminal" we refer to some editor that should switch to INSERT mode on focus
-  private fun isTerminal(ijEditor: Editor): Boolean {
-    return !ijEditor.isViewer &&
-      !EditorHelper.isFileEditor(ijEditor) &&
-      ijEditor.document.isWritable &&
-      ijEditor.editorKind != EditorKind.DIFF
-  }
 }

src/main/java/com/maddyhome/idea/vim/listener/IdeaSpecifics.kt

@@ -16,8 +16,11 @@ import com.intellij.codeInsight.lookup.impl.actions.ChooseItemAction
 import com.intellij.codeInsight.template.Template
 import com.intellij.codeInsight.template.TemplateEditingAdapter
 import com.intellij.codeInsight.template.TemplateManagerListener
+import com.intellij.codeInsight.template.impl.TemplateManagerImpl
 import com.intellij.codeInsight.template.impl.TemplateState
+import com.intellij.codeInsight.template.impl.actions.NextVariableAction
 import com.intellij.find.FindModelListener
+import com.intellij.ide.actions.ApplyIntentionAction
 import com.intellij.openapi.actionSystem.ActionManager
 import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnAction
@@ -29,6 +32,7 @@ import com.intellij.openapi.actionSystem.ex.AnActionListener
 import com.intellij.openapi.actionSystem.impl.ProxyShortcutSet
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.actions.EnterAction
+import com.intellij.openapi.editor.impl.ScrollingModelImpl
 import com.intellij.openapi.keymap.KeymapManager
 import com.intellij.openapi.project.DumbAwareToggleAction
 import com.intellij.openapi.util.TextRange
@@ -60,6 +64,7 @@ internal object IdeaSpecifics {
     private val surrounderAction =
       "com.intellij.codeInsight.generation.surroundWith.SurroundWithHandler\$InvokeSurrounderAction"
     private var editor: Editor? = null
+    private var caretOffset = -1
     private var completionPrevDocumentLength: Int? = null
     private var completionPrevDocumentOffset: Int? = null
 
@@ -69,6 +74,7 @@ internal object IdeaSpecifics {
       val hostEditor = event.dataContext.getData(CommonDataKeys.HOST_EDITOR)
       if (hostEditor != null) {
         editor = hostEditor
+        caretOffset = hostEditor.caretModel.offset
       }
 
       val isVimAction = (action as? AnActionWrapper)?.delegate is VimShortcutKeyAction
@@ -94,10 +100,14 @@ internal object IdeaSpecifics {
           } else {
             emptyList()
           }
+         val intentionName = if (action is ApplyIntentionAction) {
+            action.name
+          }
+          else null
 
           // We can still get empty ID and empty candidates. Notably, for the tool window toggle buttons on the new UI.
           // We could filter out action events with `place == ActionPlaces.TOOLWINDOW_TOOLBAR_BAR`
-          VimPlugin.getNotifications(event.dataContext.getData(CommonDataKeys.PROJECT)).notifyActionId(id, candidates)
+          VimPlugin.getNotifications(event.dataContext.getData(CommonDataKeys.PROJECT)).notifyActionId(id, candidates, intentionName)
         }
       }
 
@@ -122,17 +132,18 @@ internal object IdeaSpecifics {
       if (VimPlugin.isNotEnabled()) return
 
       val editor = editor
-      if (editor != null && action is ChooseItemAction && injector.registerGroup.isRecording) {
+      if (editor != null) {
-        val prevDocumentLength = completionPrevDocumentLength
+        if (action is ChooseItemAction && injector.registerGroup.isRecording) {
-        val prevDocumentOffset = completionPrevDocumentOffset
+          val prevDocumentLength = completionPrevDocumentLength
+          val prevDocumentOffset = completionPrevDocumentOffset
 
-        if (prevDocumentLength != null && prevDocumentOffset != null) {
+          if (prevDocumentLength != null && prevDocumentOffset != null) {
-          val register = VimPlugin.getRegister()
+            val register = VimPlugin.getRegister()
-          val addedTextLength = editor.document.textLength - prevDocumentLength
+            val addedTextLength = editor.document.textLength - prevDocumentLength
-          val caretShift = addedTextLength - (editor.caretModel.primaryCaret.offset - prevDocumentOffset)
+            val caretShift = addedTextLength - (editor.caretModel.primaryCaret.offset - prevDocumentOffset)
-          val leftArrow = KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0)
+            val leftArrow = KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0)
 
-          register.recordText(
+            register.recordText(
             editor.document.getText(
               TextRange(
                 prevDocumentOffset,
@@ -140,31 +151,49 @@ internal object IdeaSpecifics {
               )
             )
           )
-          repeat(caretShift.coerceAtLeast(0)) {
+            repeat(caretShift.coerceAtLeast(0)) {
-            register.recordKeyStroke(leftArrow)
+              register.recordKeyStroke(leftArrow)
+            }
+          }
+
+          this.completionPrevDocumentLength = null
+          this.completionPrevDocumentOffset = null
+        }
+        
+        //region Enter insert mode after surround with if
+        if (surrounderAction == action.javaClass.name && surrounderItems.any {
+            action.templatePresentation.text.endsWith(
+              it,
+            )
+          }
+        ) {
+          editor?.let {
+            it.vim.mode = Mode.NORMAL()
+            VimPlugin.getChange().insertBeforeCursor(it.vim, event.dataContext.vim)
+            KeyHandler.getInstance().reset(it.vim)
           }
         }
-
+        else if (action is NextVariableAction && TemplateManagerImpl.getTemplateState(editor) == null) {
-        this.completionPrevDocumentLength = null
+          editor.vim.exitInsertMode(event.dataContext.vim)
-        this.completionPrevDocumentOffset = null
+          KeyHandler.getInstance().reset(editor.vim)
-      }
-
-      //region Enter insert mode after surround with if
-      if (surrounderAction == action.javaClass.name && surrounderItems.any {
-          action.templatePresentation.text.endsWith(
-            it,
-          )
         }
-      ) {
+        //endregion
-        editor?.let {
+
-          it.vim.mode = Mode.NORMAL()
+        if (caretOffset != -1 && caretOffset != editor.caretModel.offset) {
-          VimPlugin.getChange().insertBeforeCursor(it.vim, event.dataContext.vim)
+          val scrollModel = editor.scrollingModel as ScrollingModelImpl
-          KeyHandler.getInstance().reset(it.vim)
+          if (scrollModel.isScrollingNow) {
+            val v = scrollModel.verticalScrollOffset
+            val h = scrollModel.horizontalScrollOffset
+            scrollModel.finishAnimation()
+            scrollModel.scroll(h, v)
+            scrollModel.finishAnimation()
+          }
+          injector.scroll.scrollCaretIntoView(editor.vim)
         }
       }
-      //endregion
 
       this.editor = null
+      this.caretOffset = -1
     }
   }
 

src/main/java/com/maddyhome/idea/vim/listener/RiderSpecifics.kt

@@ -9,6 +9,7 @@
 package com.maddyhome.idea.vim.listener
 
 import com.intellij.openapi.actionSystem.ActionManager
+import com.intellij.openapi.actionSystem.ActionPlaces
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.AnActionResult
@@ -16,6 +17,8 @@ import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.actionSystem.IdeActions
 import com.intellij.openapi.actionSystem.ex.AnActionListener
 import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.actionSystem.EditorAction
+import com.intellij.openapi.editor.actions.EnterAction
 import com.intellij.openapi.editor.event.CaretEvent
 import com.intellij.openapi.editor.event.CaretListener
 import com.maddyhome.idea.vim.VimPlugin
@@ -24,10 +27,16 @@ import com.maddyhome.idea.vim.group.visual.IdeaSelectionControl
 import com.maddyhome.idea.vim.group.visual.moveCaretOneCharLeftFromSelectionEnd
 import com.maddyhome.idea.vim.helper.getTopLevelEditor
 import com.maddyhome.idea.vim.helper.isIdeaVimDisabledHere
+import com.maddyhome.idea.vim.newapi.vim
 
 internal class RiderActionListener : AnActionListener {
 
   private var editor: Editor? = null
+  private fun shouldExecuteOnFrontend(action: EditorAction): Boolean {
+    val isInsertMode = editor?.vim?.insertMode
+    return isInsertMode == false && action is EnterAction
+  }
+
   override fun beforeActionPerformed(action: AnAction, event: AnActionEvent) {
     if (VimPlugin.isNotEnabled()) return
 
@@ -35,6 +44,12 @@ internal class RiderActionListener : AnActionListener {
     if (hostEditor != null) {
       editor = hostEditor
     }
+
+    // Fixes RIDER-123506
+    if (action is EditorAction) {
+      val key = ActionPlaces.EXECUTE_EDITOR_ACTION_ON_FRONTEND
+      editor?.putUserData(key, shouldExecuteOnFrontend(action))
+    }
   }
 
   override fun afterActionPerformed(action: AnAction, event: AnActionEvent, result: AnActionResult) {

src/main/java/com/maddyhome/idea/vim/listener/VimListenerManager.kt

@@ -81,7 +81,6 @@ import com.maddyhome.idea.vim.handler.keyCheckRequests
 import com.maddyhome.idea.vim.helper.CaretVisualAttributesListener
 import com.maddyhome.idea.vim.helper.GuicursorChangeListener
 import com.maddyhome.idea.vim.helper.StrictMode
-import com.maddyhome.idea.vim.helper.VimStandalonePluginUpdateChecker
 import com.maddyhome.idea.vim.helper.exitSelectMode
 import com.maddyhome.idea.vim.helper.exitVisualMode
 import com.maddyhome.idea.vim.helper.forceBarCursor
@@ -98,6 +97,7 @@ import com.maddyhome.idea.vim.newapi.IjVimSearchGroup
 import com.maddyhome.idea.vim.newapi.InsertTimeRecorder
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.state.mode.inSelectMode
 import com.maddyhome.idea.vim.state.mode.selectionType
 import com.maddyhome.idea.vim.ui.ShowCmdOptionChangeListener
@@ -411,10 +411,21 @@ internal object VimListenerManager {
     override fun selectionChanged(event: FileEditorManagerEvent) {
       // We can't rely on being passed a non-null editor, so check for Code With Me scenarios explicitly
       if (VimPlugin.isNotEnabled() || !ClientId.isCurrentlyUnderLocalId) return
-
+      
+      val newEditor = event.newEditor
+      if (newEditor is TextEditor) {
+        val editor = newEditor.editor
+        if (editor.isInsertMode) {
+          editor.vim.mode = Mode.NORMAL()
+          KeyHandler.getInstance().reset(editor.vim)
+        }
+        // Breaks relativenumber for some reason
+//        injector.scroll.scrollCaretIntoView(editor.vim)
+      }
+      
       MotionGroup.fileEditorManagerSelectionChangedCallback(event)
       FileGroup.fileEditorManagerSelectionChangedCallback(event)
-      VimPlugin.getSearch().fileEditorManagerSelectionChangedCallback(event)
+//      VimPlugin.getSearch().fileEditorManagerSelectionChangedCallback(event)
       IjVimRedrawService.fileEditorManagerSelectionChangedCallback(event)
       VimLastSelectedEditorTracker.setLastSelectedEditor(event.newEditor)
     }
@@ -457,7 +468,9 @@ internal object VimListenerManager {
           openingEditor == null -> LocalOptionInitialisationScenario.EDIT
           else -> LocalOptionInitialisationScenario.NEW
         }
-        EditorListeners.add(event.editor, openingEditor?.vim ?: injector.fallbackWindow, scenario)
+        SlowOperations.knownIssue("VIM-3648").use {
+          EditorListeners.add(event.editor, openingEditor?.vim ?: injector.fallbackWindow, scenario)
+        }
         firstEditorInitialised = true
       } else {
         // We've got a virtual file, so FileOpenedSyncListener will be called. Save data
@@ -485,8 +498,6 @@ internal object VimListenerManager {
           OpeningEditor(openingEditor, owningEditorWindow, isPreview, canBeReused)
         )
       }
-
-      VimStandalonePluginUpdateChecker.getInstance().pluginUsed()
     }
 
     override fun editorReleased(event: EditorFactoryEvent) {
@@ -808,7 +819,7 @@ internal object VimListenerManager {
             if (editor.inVisualMode) {
               editor.vim.exitVisualMode()
             } else if (editor.vim.inSelectMode) {
-              editor.exitSelectMode(false)
+              editor.vim.exitSelectMode(false)
               KeyHandler.getInstance().reset(editor.vim)
             }
           }

src/main/java/com/maddyhome/idea/vim/mark/IntellijMark.kt

@@ -18,7 +18,7 @@ internal class IntellijMark(bookmark: LineBookmark, override val col: Int, proje
 
   private val project: WeakReference<Project?> = WeakReference(project)
 
-  override val key = BookmarksManager.getInstance(project)?.getType(bookmark)?.mnemonic!!
+  override val key = BookmarksManager.getInstance(project)?.getType(bookmark)?.mnemonic ?: ' '
   override val line: Int
     get() = getMark()?.line ?: 0
   override val filepath: String

src/main/java/com/maddyhome/idea/vim/newapi/IjClipboardManager.kt

@@ -39,26 +39,16 @@ import java.io.IOException
 
 @Service
 internal class IjClipboardManager : VimClipboardManager {
-  @Deprecated("Please use com.maddyhome.idea.vim.api.VimClipboardManager#getPrimaryTextAndTransferableData")
+  override fun getPrimaryContent(): IjVimCopiedText? {
-  override fun getPrimaryTextAndTransferableData(): Pair<String, List<Any>?>? {
     val clipboard = Toolkit.getDefaultToolkit()?.systemSelection ?: return null
     val contents = clipboard.getContents(null) ?: return null
-    return getTextAndTransferableData(contents)
+    val (text, transferableData) = getTextAndTransferableData(contents) ?: return null
-  }
-
-  override fun getPrimaryContent(editor: VimEditor, context: ExecutionContext): IjVimCopiedText? {
-    val (text, transferableData) = getPrimaryTextAndTransferableData() ?: return null
     return IjVimCopiedText(text, transferableData ?: emptyList())
   }
 
-  @Deprecated("Please use com.maddyhome.idea.vim.api.VimClipboardManager#getClipboardTextAndTransferableData")
-  override fun getClipboardTextAndTransferableData(): Pair<String, List<Any>?>? {
-    val contents = getContents() ?: return null
-    return getTextAndTransferableData(contents)
-  }
-
   override fun getClipboardContent(editor: VimEditor, context: ExecutionContext): VimCopiedText? {
-    val (text, transferableData) = getClipboardTextAndTransferableData() ?: return null
+    val contents = getContents() ?: return null
+    val (text, transferableData) = getTextAndTransferableData(contents) ?: return null
     return IjVimCopiedText(text, transferableData ?: emptyList())
   }
 
@@ -125,14 +115,6 @@ internal class IjClipboardManager : VimClipboardManager {
 //    return setPrimaryText(entry.text, entry.rawText, entry.transferableData) != null
 //  }
 
-  @Deprecated("Please use com.maddyhome.idea.vim.api.VimClipboardManager#setPrimaryText")
-  override fun setPrimaryText(text: String, rawText: String, transferableData: List<Any>): Transferable? {
-    return handleTextSetting(text, rawText, transferableData) { content ->
-      val clipboard = Toolkit.getDefaultToolkit()?.systemSelection ?: return@handleTextSetting null
-      clipboard.setContents(content, EmptyClipboardOwner.INSTANCE)
-    }
-  }
-
   override fun collectCopiedText(
     editor: VimEditor,
     context: ExecutionContext,
@@ -260,6 +242,6 @@ internal class IjClipboardManager : VimClipboardManager {
   }
 }
 
-data class IjVimCopiedText(override val text: String, val transferableData: List<Any>) : VimCopiedText {
+data class IjVimCopiedText(override val text: String, override val transferableData: List<Any>) : VimCopiedText {
   override fun updateText(newText: String): VimCopiedText = IjVimCopiedText(newText, transferableData)
 }

src/main/java/com/maddyhome/idea/vim/newapi/IjVimApplication.kt

@@ -32,7 +32,7 @@ internal class IjVimApplication : VimApplicationBase() {
     return ApplicationManager.getApplication().isDispatchThread
   }
 
-  override fun invokeLater(action: () -> Unit, editor: VimEditor) {
+  override fun invokeLater(editor: VimEditor, action: () -> Unit) {
     ApplicationManager.getApplication()
       .invokeLater(action, ModalityState.stateForComponent((editor as IjVimEditor).editor.component))
   }

src/main/java/com/maddyhome/idea/vim/newapi/IjVimCaret.kt

@@ -12,8 +12,6 @@ import com.intellij.openapi.editor.Caret
 import com.intellij.openapi.editor.LogicalPosition
 import com.intellij.openapi.editor.VisualPosition
 import com.maddyhome.idea.vim.api.BufferPosition
-import com.maddyhome.idea.vim.api.CaretRegisterStorage
-import com.maddyhome.idea.vim.api.CaretRegisterStorageBase
 import com.maddyhome.idea.vim.api.ImmutableVimCaret
 import com.maddyhome.idea.vim.api.LocalMarkStorage
 import com.maddyhome.idea.vim.api.SelectionInfo
@@ -21,6 +19,7 @@ import com.maddyhome.idea.vim.api.VimCaret
 import com.maddyhome.idea.vim.api.VimCaretBase
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.VimVisualPosition
+import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.common.InsertSequence
 import com.maddyhome.idea.vim.common.LiveRange
 import com.maddyhome.idea.vim.group.visual.VisualChange
@@ -29,7 +28,6 @@ import com.maddyhome.idea.vim.helper.insertHistory
 import com.maddyhome.idea.vim.helper.lastSelectionInfo
 import com.maddyhome.idea.vim.helper.markStorage
 import com.maddyhome.idea.vim.helper.moveToInlayAwareOffset
-import com.maddyhome.idea.vim.helper.registerStorage
 import com.maddyhome.idea.vim.helper.resetVimLastColumn
 import com.maddyhome.idea.vim.helper.vimInsertStart
 import com.maddyhome.idea.vim.helper.vimLastColumn
@@ -37,22 +35,14 @@ import com.maddyhome.idea.vim.helper.vimLastVisualOperatorRange
 import com.maddyhome.idea.vim.helper.vimLine
 import com.maddyhome.idea.vim.helper.vimSelectionStart
 import com.maddyhome.idea.vim.helper.vimSelectionStartClear
+import com.maddyhome.idea.vim.register.VimRegisterGroup
 import com.maddyhome.idea.vim.state.mode.SelectionType
 
 internal class IjVimCaret(val caret: Caret) : VimCaretBase() {
 
-  override val registerStorage: CaretRegisterStorage
+  override val registerStorage: VimRegisterGroup
-    get() {
+    get() = injector.registerGroup
-      var storage = this.caret.registerStorage
+ 
-      if (storage == null) {
-        initInjector() // To initialize injector used in CaretRegisterStorageBase
-        storage = CaretRegisterStorageBase(this)
-        this.caret.registerStorage = storage
-      } else if (storage.caret != this) {
-        storage.caret = this
-      }
-      return storage
-    }
   override val markStorage: LocalMarkStorage
     get() {
       var storage = this.caret.markStorage

src/main/java/com/maddyhome/idea/vim/newapi/IjVimEditor.kt

@@ -35,8 +35,8 @@ import com.maddyhome.idea.vim.api.VimFoldRegion
 import com.maddyhome.idea.vim.api.VimIndentConfig
 import com.maddyhome.idea.vim.api.VimScrollingModel
 import com.maddyhome.idea.vim.api.VimSelectionModel
+import com.maddyhome.idea.vim.api.VimVirtualFile
 import com.maddyhome.idea.vim.api.VimVisualPosition
-import com.maddyhome.idea.vim.api.VirtualFile
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.common.IndentConfig
 import com.maddyhome.idea.vim.common.LiveRange
@@ -179,21 +179,38 @@ internal class IjVimEditor(editor: Editor) : MutableLinearEditor, VimEditorBase(
     return editor.caretModel.allCarets.map { IjVimCaret(it) }
   }
 
+  override var isFirstCaret = true
+  override var isReversingCarets = false
+  
   @Suppress("ideavimRunForEachCaret")
   override fun forEachCaret(action: (VimCaret) -> Unit) {
     if (editor.vim.inBlockSelection) {
       action(IjVimCaret(editor.caretModel.primaryCaret))
     } else {
-      editor.caretModel.runForEachCaret({
+      try {
-        if (it.isValid) {
+        editor.caretModel.runForEachCaret({
-          action(IjVimCaret(it))
+          if (it.isValid) {
-        }
+            action(IjVimCaret(it))
-      }, false)
+            isFirstCaret = false
+          }
+        }, false)
+      } finally {
+        isFirstCaret = true
+      }
     }
   }
 
   override fun forEachNativeCaret(action: (VimCaret) -> Unit, reverse: Boolean) {
-    editor.caretModel.runForEachCaret({ action(IjVimCaret(it)) }, reverse)
+    isReversingCarets = reverse
+    try {
+      editor.caretModel.runForEachCaret({
+        action(IjVimCaret(it))
+        isFirstCaret = false
+      }, reverse)
+    } finally {
+      isFirstCaret = true
+      isReversingCarets = false
+    }
   }
 
   override fun isInForEachCaretScope(): Boolean {
@@ -284,12 +301,13 @@ internal class IjVimEditor(editor: Editor) : MutableLinearEditor, VimEditorBase(
     return editor.logicalPositionToOffset(logicalPosition)
   }
 
-  override fun getVirtualFile(): VirtualFile? {
+  override fun getVirtualFile(): VimVirtualFile? {
     val vf = EditorHelper.getVirtualFile(editor)
     return vf?.let {
-      object : VirtualFile {
+      object : VimVirtualFile {
         override val path: String = vf.path
         override val protocol: String = vf.fileSystem.protocol
+        override val extension: String? = vf.extension
       }
     }
   }
@@ -496,6 +514,10 @@ internal class IjVimEditor(editor: Editor) : MutableLinearEditor, VimEditorBase(
     }
   }
 
+  override fun getSoftWrapStartAtOffset(offset: Int): Int? {
+    return editor.softWrapModel.getSoftWrap(offset)?.start
+  }
+
   override fun <T : ImmutableVimCaret> findLastVersionOfCaret(caret: T): T {
     return caret
   }

src/main/java/com/maddyhome/idea/vim/newapi/IjVimInjector.kt

@@ -213,16 +213,6 @@ internal class IjVimInjector : VimInjectorBase() {
   override val redrawService: VimRedrawService
     get() = service()
 
-  @Deprecated("Please use VimInjector.vimState", replaceWith = ReplaceWith("vimState"))
-  override fun commandStateFor(editor: VimEditor): VimStateMachine {
-    return vimState
-  }
-
-  @Deprecated("Please use VimInjector.vimState", replaceWith = ReplaceWith("vimState"))
-  override fun commandStateFor(editor: Any): VimStateMachine {
-    return vimState
-  }
-
   override val engineEditorHelper: EngineEditorHelper
     get() = service<IjEditorHelper>()
   override val editorGroup: VimEditorGroup

src/main/java/com/maddyhome/idea/vim/troubleshooting/AccidentalInstallDetector.kt

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2003-2025 The IdeaVim authors
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE.txt file or at
+ * https://opensource.org/licenses/MIT.
+ */
+
+package com.maddyhome.idea.vim.troubleshooting
+
+import com.intellij.openapi.fileEditor.FileEditor
+import com.intellij.openapi.project.DumbAware
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.ui.EditorNotificationPanel
+import com.intellij.ui.EditorNotificationProvider
+import com.intellij.ui.EditorNotifications
+import com.intellij.util.PlatformUtils
+import com.maddyhome.idea.vim.KeyHandler
+import com.maddyhome.idea.vim.VimPlugin
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.icons.VimIcons
+import com.maddyhome.idea.vim.vimscript.services.VimRcService
+import java.util.function.Function
+import javax.swing.JComponent
+
+private var warningExplicitlyDisabled = false
+
+private object CommandsCounter {
+  var commandsBeforeAutoDisable = 10
+  var initialized = false
+
+  @Synchronized
+  fun init() {
+    if (initialized) return
+    initialized = true
+    KeyHandler.getInstance().addCommandListener {
+      commandsBeforeAutoDisable -= 1
+      if (commandsBeforeAutoDisable <= 0) {
+        warningExplicitlyDisabled = true
+      }
+    }
+  }
+}
+
+/**
+ * Warning for the new users who may install IdeaVim plugin accidentally.
+ */
+internal class AccidentalInstallDetectorEditorNotificationProvider : EditorNotificationProvider, DumbAware {
+  override fun collectNotificationData(
+    project: Project,
+    file: VirtualFile,
+  ): Function<in FileEditor, out JComponent?>? {
+
+    CommandsCounter.init()
+
+    // Note: Currently, enable this only for GoLand as it was a request from this IDE (VIM-3784).
+    //   However, we can enable it for other IDEs if needed.
+    if (!PlatformUtils.isGoIde()) return null
+
+    if (warningExplicitlyDisabled) return null
+    if (VimPlugin.isNotEnabled()) return null
+    if (VimRcService.findIdeaVimRc() != null) return null
+    if (!injector.enabler.isNewIdeaVimUser()) return null
+
+    return Function { fileEditor: FileEditor ->
+      val panel = EditorNotificationPanel(fileEditor, EditorNotificationPanel.Status.Info)
+      panel.text = getText()
+      panel.icon(VimIcons.IDEAVIM)
+
+      KeyHandler.getInstance().addCommandListener {
+        if (CommandsCounter.commandsBeforeAutoDisable <= 0) {
+          KeyHandler.getInstance().removeAllCommandListeners()
+          EditorNotifications.getInstance(project).removeNotificationsForProvider(this)
+        }
+        panel.text = getText()
+        panel.invalidate()
+        panel.repaint()
+      }
+
+      @Suppress("DialogTitleCapitalization")
+      panel.createActionLabel("Disable IdeaVim") {
+        VimPlugin.setEnabled(false)
+        VimPlugin.getNotifications(project).showReenableNotification(project)
+        EditorNotifications.getInstance(project).removeNotificationsForProvider(this)
+        warningExplicitlyDisabled = true
+      }
+      panel.createActionLabel("Dismiss") {
+        EditorNotifications.getInstance(project).removeNotificationsForProvider(this)
+        warningExplicitlyDisabled = true
+      }
+      panel
+    }
+  }
+
+  private fun getText(): String {
+    return "<html>You’re using the IdeaVim plugin. If you’re not familiar with Vim, consider disabling it. This message will disappear after ${CommandsCounter.commandsBeforeAutoDisable} commands.</html>"
+  }
+}

src/main/java/com/maddyhome/idea/vim/ui/ex/ExEntryPanel.java

@@ -353,7 +353,7 @@ public class ExEntryPanel extends JPanel implements VimCommandLine {
         int count1 = Math.max(1, KeyHandler.getInstance().getKeyHandlerState().getEditorCommandBuilder()
           .calculateCount0Snapshot());
 
-        if (labelText.equals("/") || labelText.equals("?") || searchCommand) {
+        if ((labelText.equals("/") || labelText.equals("?") || searchCommand) && !injector.getMacro().isExecutingMacro()) {
           final boolean forwards = !labelText.equals("?");  // :s, :g, :v are treated as forwards
           int patternEnd = injector.getSearchGroup().findEndOfPattern(searchText, separator, 0);
           final String pattern = searchText.substring(0, patternEnd);
@@ -428,14 +428,6 @@ public class ExEntryPanel extends JPanel implements VimCommandLine {
     return active;
   }
 
-  /**
-   * @deprecated Use getVisibleText()
-   */
-  @Deprecated(forRemoval = true)
-  public @NotNull String getText() {
-    return entry.getText();
-  }
-
   @Override
   public @NotNull String getVisibleText() {
     return entry.getText();

src/main/java/com/maddyhome/idea/vim/vimscript/model/functions/handlers/PopupMenuVisibleFunctionHandler.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2003-2023 The IdeaVim authors
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE.txt file or at
+ * https://opensource.org/licenses/MIT.
+ */
+
+package com.maddyhome.idea.vim.vimscript.model.functions.handlers
+
+import com.intellij.codeInsight.completion.CompletionService
+import com.intellij.vim.annotations.VimscriptFunction
+import com.maddyhome.idea.vim.api.ExecutionContext
+import com.maddyhome.idea.vim.api.VimEditor
+import com.maddyhome.idea.vim.vimscript.model.VimLContext
+import com.maddyhome.idea.vim.vimscript.model.datatypes.VimDataType
+import com.maddyhome.idea.vim.vimscript.model.datatypes.VimInt
+import com.maddyhome.idea.vim.vimscript.model.expressions.Expression
+import com.maddyhome.idea.vim.vimscript.model.functions.FunctionHandler
+
+@VimscriptFunction(name = "pumvisible")
+internal class PopupMenuVisibleFunctionHandler : FunctionHandler() {
+  override val minimumNumberOfArguments = 0
+  override val maximumNumberOfArguments = 0
+
+  override fun doFunction(
+    argumentValues: List<Expression>,
+    editor: VimEditor,
+    context: ExecutionContext,
+    vimContext: VimLContext,
+  ): VimDataType {
+    return if (CompletionService.getCompletionService().currentCompletion == null)
+      VimInt.ZERO
+    else
+      VimInt.ONE
+  }
+}

src/main/resources/META-INF/plugin.xml

@@ -1,12 +1,4 @@
-<!--
+<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude">
-  ~ Copyright 2003-2023 The IdeaVim authors
-  ~
-  ~ Use of this source code is governed by an MIT-style
-  ~ license that can be found in the LICENSE.txt file or at
-  ~ https://opensource.org/licenses/MIT.
-  -->
-
-<idea-plugin url="https://plugins.jetbrains.com/plugin/164" xmlns:xi="http://www.w3.org/2001/XInclude">
   <name>IdeaVim</name>
   <id>IdeaVIM</id>
   <description><![CDATA[
@@ -21,7 +13,7 @@
         <li><a href="https://youtrack.jetbrains.com/issues/VIM">Issue tracker</a>: feature requests and bug reports</li>
       </ul>
     ]]></description>
-  <version>SNAPSHOT</version>
+  <version>chylex</version>
   <vendor>JetBrains</vendor>
 
   <!-- Mark the plugin as compatible with RubyMine and other products based on the IntelliJ platform (including CWM) -->
@@ -140,6 +132,9 @@
                  key="ideavim.only.in.editor.component"/>
     <registryKey defaultValue="false" description="Old action execution mechanism" key="ideavim.old.action.execution"
                  restartRequired="false"/>
+
+    <editorNotificationProvider
+        implementation="com.maddyhome.idea.vim.troubleshooting.AccidentalInstallDetectorEditorNotificationProvider"/>
   </extensions>
 
   <xi:include href="/META-INF/includes/ApplicationServices.xml" xpointer="xpointer(/idea-plugin/*)"/>
@@ -147,10 +142,12 @@
   <xi:include href="/META-INF/includes/VimListeners.xml" xpointer="xpointer(/idea-plugin/*)"/>
 
   <actions resource-bundle="messages.IdeaVimBundle">
-    <action id="VimPluginToggle" class="com.maddyhome.idea.vim.action.VimPluginToggleAction">
+    <group id="com.chylex.intellij.vim" text="Vim" popup="true">
       <add-to-group group-id="ToolsMenu" anchor="last"/>
-    </action>
+      <action id="VimPluginToggle" class="com.maddyhome.idea.vim.action.VimPluginToggleAction"/>
-
+      <action id="VimRunLastMacroInOpenFiles" class="com.maddyhome.idea.vim.action.VimRunLastMacroInOpenFiles"/>
+    </group>
+    
     <!-- Internal -->
     <!--suppress PluginXmlI18n -->
     <action id="VimInternalAddBlockInlays" class="com.maddyhome.idea.vim.action.internal.AddBlockInlaysAction" text="Add Test Block Inlays | IdeaVim Internal" internal="true"/>
@@ -168,5 +165,6 @@
     </group>
 
     <action id="VimFindActionIdAction" class="com.maddyhome.idea.vim.listener.FindActionIdAction"/>
+    <action id="VimJumpToSource" class="com.intellij.diff.actions.impl.OpenInEditorAction" />
   </actions>
 </idea-plugin>

src/main/resources/ksp-generated/intellij_vimscript_functions.json

@@ -1,3 +1,4 @@
 {
-    "has": "com.maddyhome.idea.vim.vimscript.model.functions.handlers.HasFunctionHandler"
+    "has": "com.maddyhome.idea.vim.vimscript.model.functions.handlers.HasFunctionHandler",
+    "pumvisible": "com.maddyhome.idea.vim.vimscript.model.functions.handlers.PopupMenuVisibleFunctionHandler"
 }

src/main/resources/messages/IdeaVimBundle.properties

@@ -85,11 +85,23 @@ E545=E545: Missing colon: {0}
 E546=E546: Illegal mode: {0}
 E548=E548: Digit expected: {0}
 E549=E549: Illegal percentage: {0}
+E691=E691: Can only compare List with List
+E692=E692: Invalid operation for List
+E694=E694: Invalid operation for Funcrefs
+E695=E695: Cannot index a Funcref
 E701=E701: Invalid type for len()
+E703=E703: Using a Funcref as a Number
+E728=E728: Using a Dictionary as a Number
+E729=E729: Using a Funcref as a String
 E730=E730: Using a List as a String
 E731=E731: Using a Dictionary as a String
+E735=E735: Can only compare Dictionary with Dictionary
+E736=E736: Invalid operation for Dictionary
+E745=E745: Using a List as a Number
 E774=E774: 'operatorfunc' is empty
+E804=E804: Cannot use '%' with Float
 E805=E805: Using a Float as a Number
+E806=E806: Using a Float as a String
 E808=E808: Number or Float required
 e841.reserved.name.cannot.be.used.for.user.defined.command=E841: Reserved name, cannot be used for user defined command
 E939=E939: Positive count required

src/test/java/org/jetbrains/plugins/ideavim/action/ChangeActionTest.kt

@@ -15,7 +15,6 @@ import org.jetbrains.plugins.ideavim.SkipNeovimReason
 import org.jetbrains.plugins.ideavim.TestWithoutNeovim
 import org.jetbrains.plugins.ideavim.VimBehaviorDiffers
 import org.jetbrains.plugins.ideavim.VimTestCase
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 
 /**
@@ -114,10 +113,8 @@ class ChangeActionTest : VimTestCase() {
     )
   }
 
-  // Turn it on after typing via handlers are implemented for tests
   // VIM-620 |i_CTRL-O|
   @Test
-  @Disabled
   fun testInsertSingleCommandAndNewLineInserting8() {
     doTest(
       listOf("i", "<C-O>", "gh", "d"),
@@ -142,24 +139,44 @@ class ChangeActionTest : VimTestCase() {
   // VIM-321 |d| |count|
   @Test
   fun testDeleteEmptyRange() {
-    doTest("d0", "${c}hello\n", "hello\n", Mode.NORMAL())
+    doTest(
+      "d0",
+      "${c}hello\n",
+      "hello\n",
+      Mode.NORMAL(),
+    )
   }
 
   // VIM-157 |~|
   @Test
   fun testToggleCharCase() {
-    doTest("~~", "${c}hello world\n", "HEllo world\n", Mode.NORMAL())
+    doTest(
+      "~~",
+      "${c}hello world\n",
+      "HEllo world\n",
+      Mode.NORMAL(),
+    )
   }
 
   // VIM-157 |~|
   @Test
   fun testToggleCharCaseLineEnd() {
-    doTest("~~", "hello wor${c}ld\n", "hello worLD\n", Mode.NORMAL())
+    doTest(
+      "~~",
+      "hello wor${c}ld\n",
+      "hello worLD\n",
+      Mode.NORMAL(),
+    )
   }
 
   @Test
   fun testToggleCaseMotion() {
-    doTest("g~w", "${c}FooBar Baz\n", "fOObAR Baz\n", Mode.NORMAL())
+    doTest(
+      "g~w",
+      "${c}FooBar Baz\n",
+      "fOObAR Baz\n",
+      Mode.NORMAL(),
+    )
   }
 
   @Test
@@ -174,7 +191,12 @@ class ChangeActionTest : VimTestCase() {
 
   @Test
   fun testChangeLowerCase() {
-    doTest("guw", "${c}FooBar Baz\n", "foobar Baz\n", Mode.NORMAL())
+    doTest(
+      "guw",
+      "${c}FooBar Baz\n",
+      "foobar Baz\n",
+      Mode.NORMAL(),
+    )
   }
 
   @Test
@@ -216,13 +238,13 @@ class ChangeActionTest : VimTestCase() {
    one
    two ${c}three
    four
-   
+
       """.trimIndent(),
       """
    one
    two hello world! three
    four
-   
+
       """.trimIndent(),
       Mode.INSERT,
     )
@@ -236,12 +258,12 @@ class ChangeActionTest : VimTestCase() {
       """
         one
         ${c}two
-        
+
       """.trimIndent(),
       """
         one
-        
+
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -256,12 +278,12 @@ class ChangeActionTest : VimTestCase() {
       """
    one ${c}two
    three
-   
+
       """.trimIndent(),
       """
    one 
    three
-   
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -274,15 +296,15 @@ class ChangeActionTest : VimTestCase() {
       "dw",
       """
    one ${c}two
-   
+
    three
-   
+
       """.trimIndent(),
       """
    one 
-   
+
    three
-   
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -293,12 +315,14 @@ class ChangeActionTest : VimTestCase() {
   fun testDeleteLastWordBeforeEOLAndWhitespace() {
     doTest(
       "dw",
-      """one ${c}two
+      """
- three
+        one ${c}two
-""",
+         three
-      """one 
+      """.trimIndent(),
- three
+      """
-""",
+        one 
+         three
+      """.trimIndent(),
       Mode.NORMAL(),
     )
     assertOffset(3)
@@ -312,7 +336,7 @@ class ChangeActionTest : VimTestCase() {
       """
    one ${c}two
    three four
-   
+
       """.trimIndent(),
       "one four\n",
       Mode.NORMAL(),
@@ -353,12 +377,12 @@ class ChangeActionTest : VimTestCase() {
       """
    foo(${c}bar
    baz
-   
+
       """.trimIndent(),
       """
    foo(
    baz
-   
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -372,12 +396,12 @@ class ChangeActionTest : VimTestCase() {
       """
         fo${c}o
         bar
-        
+
       """.trimIndent(),
       """
         fo
         bar
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -392,7 +416,7 @@ class ChangeActionTest : VimTestCase() {
       """
    one
    two
-   
+
       """.trimIndent(),
       "two\n",
       Mode.NORMAL(),
@@ -443,14 +467,14 @@ class ChangeActionTest : VimTestCase() {
         bar
         baz
         quux
-        
+
       """.trimIndent(),
       """
         ${c}o
         r
         z
         quux
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -465,14 +489,14 @@ class ChangeActionTest : VimTestCase() {
         bar
         baz
         quux
-        
+
       """.trimIndent(),
       """
         ${c}o
         r
         z
         quux
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -517,7 +541,7 @@ quux
       "3J",
       """
         foo.
-        
+
         bar
       """.dotToSpace().trimIndent(),
       "foo bar",
@@ -542,14 +566,16 @@ quux
   fun testDeleteJoinVisualLinesSpaces() {
     doTest(
       "v2jJ",
-      """    a$c 1
+      """
-    b 2
+        a$c 1
-    c 3
+        b 2
-quux
+        c 3
-""",
+        quux
-      """    a 1 b 2 c 3
+      """.trimIndent(),
-quux
+      """
-""",
+        a 1 b 2 c 3
+        quux
+      """.trimIndent(),
       Mode.NORMAL(),
     )
   }
@@ -600,15 +626,15 @@ quux
       listOf("l", "<C-V>", "jj", "x"),
       """
         foo
-        
+
         bar
-        
+
       """.trimIndent(),
       """
         fo
-        
+
         br
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -624,13 +650,13 @@ quux
         foo
         x
         bar
-        
+
       """.trimIndent(),
       """
         fo
         x
         br
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -643,7 +669,7 @@ quux
       """
   foo
   bar
-  
+
       """.trimIndent(),
     )
     typeText(injector.parser.parseKeys("<C-V>" + "j" + "x"))
@@ -651,7 +677,7 @@ quux
       """
   oo
   ar
-  
+
       """.trimIndent(),
     )
   }
@@ -659,20 +685,35 @@ quux
   // |r|
   @Test
   fun testReplaceOneChar() {
-    doTest("rx", "b${c}ar\n", "b${c}xr\n", Mode.NORMAL())
+    doTest(
+      "rx",
+      "b${c}ar\n",
+      "b${c}xr\n",
+      Mode.NORMAL(),
+    )
   }
 
   // |r|
   @VimBehaviorDiffers(originalVimAfter = "foXX${c}Xr\n")
   @Test
   fun testReplaceMultipleCharsWithCount() {
-    doTest("3rX", "fo${c}obar\n", "fo${c}XXXr\n", Mode.NORMAL())
+    doTest(
+      "3rX",
+      "fo${c}obar\n",
+      "fo${c}XXXr\n",
+      Mode.NORMAL(),
+    )
   }
 
   // |r|
   @Test
   fun testReplaceMultipleCharsWithCountPastEndOfLine() {
-    doTest("6rX", "fo${c}obar\n", "fo${c}obar\n", Mode.NORMAL())
+    doTest(
+      "6rX",
+      "fo${c}obar\n",
+      "fo${c}obar\n",
+      Mode.NORMAL(),
+    )
   }
 
   // |r|
@@ -684,12 +725,12 @@ quux
       """
         fo${c}obar
         foobaz
-        
+
       """.trimIndent(),
       """
         foZZZZ
         ZZZZZz
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -700,13 +741,15 @@ quux
   fun testReplaceOneCharWithNewline() {
     doTest(
       "r<Enter>",
-      """    fo${c}obar
+      """
-foobaz
+        fo${c}obar
-""",
+        foobaz
-      """    fo
+      """.trimIndent(),
-    bar
+      """
-foobaz
+        fo
-""",
+        bar
+        foobaz
+      """.trimIndent(),
       Mode.NORMAL(),
     )
   }
@@ -717,13 +760,15 @@ foobaz
   fun testReplaceCharWithNewlineAndCountAddsOnlySingleNewline() {
     doTest(
       "3r<Enter>",
-      """    fo${c}obar
+      """
-foobaz
+        fo${c}obar
-""",
+        foobaz
-      """    fo
+      """.trimIndent(),
-    r
+      """
-foobaz
+        fo
-""",
+        r
+        foobaz
+      """.trimIndent(),
       Mode.NORMAL(),
     )
   }
@@ -731,7 +776,12 @@ foobaz
   // |s|
   @Test
   fun testReplaceOneCharWithText() {
-    doTest("sxy<Esc>", "b${c}ar\n", "bx${c}yr\n", Mode.NORMAL())
+    doTest(
+      "sxy<Esc>",
+      "b${c}ar\n",
+      "bx${c}yr\n",
+      Mode.NORMAL(),
+    )
   }
 
   // |s|
@@ -753,12 +803,12 @@ foobaz
       """
         foo${c}bar
         biff
-        
+
       """.trimIndent(),
       """
         fooxy${c}z
         biff
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -767,7 +817,12 @@ foobaz
   // |R|
   @Test
   fun testReplaceMode() {
-    doTest("Rbaz<Esc>", "foo${c}bar\n", "fooba${c}z\n", Mode.NORMAL())
+    doTest(
+      "Rbaz<Esc>",
+      "foo${c}bar\n",
+      "fooba${c}z\n",
+      Mode.NORMAL(),
+    )
   }
 
   // |R| |i_<Insert>|
@@ -803,12 +858,12 @@ foobaz
       """
         ${c}foo baz
         baz quux
-        
+
       """.trimIndent(),
       """
         foo baz
         fo${c}o quux
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -822,16 +877,16 @@ foobaz
   $c- 1
   - 2
   - 3
-  
+
       """.trimIndent(),
     )
     typeText(injector.parser.parseKeys("d$" + "j" + "."))
     assertState(
       """
-  
+
-  
+
   - 3
-  
+
       """.trimIndent(),
     )
   }
@@ -847,7 +902,7 @@ foobaz
   $c- 1
   - 2
   - 3
-  
+
       """.trimIndent(),
     )
     typeText(injector.parser.parseKeys("A" + "<BS>" + "<Esc>" + "j" + "."))
@@ -856,7 +911,7 @@ foobaz
   - 
   - 
   - 3
-  
+
       """.trimIndent(),
     )
 
@@ -866,7 +921,7 @@ foobaz
   $c- 1
   - 2
   - 3
-  
+
       """.trimIndent(),
     )
     typeText(injector.parser.parseKeys("A" + "4" + "<BS>" + "<Esc>" + "j" + "."))
@@ -875,7 +930,7 @@ foobaz
   - 1
   - 2
   - 3
-  
+
       """.trimIndent(),
     )
 
@@ -885,7 +940,7 @@ foobaz
   $c- 1
   - 2
   - 3
-  
+
       """.trimIndent(),
     )
     typeText(injector.parser.parseKeys("A" + "<BS>" + "4" + "<Esc>" + "j" + "."))
@@ -894,7 +949,7 @@ foobaz
   - 4
   - 4
   - 3
-  
+
       """.trimIndent(),
     )
   }
@@ -1023,12 +1078,12 @@ foobaz
       """
         ${c}lorem ipsum dolor sit amet
         lorem ipsum dolor sit amet
-        
+
       """.trimIndent(),
       """
         psum dolor sit amet
         ${c}lorem ipsum dolor sit amet
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )
@@ -1043,12 +1098,12 @@ foobaz
         gaganis ${c}gaganis gaganis
         gaganis gaganis gaganis
         gaganis gaganis gaganis
-        
+
       """.trimIndent(),
       """
         gaganis s gaganis
         gaganis ${c}gaganis gaganis
-        
+
       """.trimIndent(),
       Mode.NORMAL(),
     )

src/test/java/org/jetbrains/plugins/ideavim/action/ChangeCaseTest.kt

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2003-2025 The IdeaVim authors
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE.txt file or at
+ * https://opensource.org/licenses/MIT.
+ */
+package org.jetbrains.plugins.ideavim.action
+
+import com.maddyhome.idea.vim.api.injector
+import org.jetbrains.plugins.ideavim.VimTestCase
+import org.junit.jupiter.api.Disabled
+import org.junit.jupiter.api.Test
+
+class ChangeCaseTest : VimTestCase() {
+  /**
+   * Note: The tests for duplicated commands (gugu and gUgU) might fail due to issues with the test environment,
+   * specifically related to file refresh operations. This is a known issue with the test infrastructure
+   * and not with the actual functionality being tested.
+   * 
+   * The tests for guu and gUU test the same functionality and should pass.
+   */
+  @Test
+  fun testChangeCaseLowerLineAction() {
+    typeTextInFile(
+      injector.parser.parseKeys("guu"),
+      """
+        H${c}ELLO WORLD
+        ${c}THIS IS A TEST
+        ${c}FOR CASE CONVERSION
+
+        """.trimIndent(),
+    )
+    assertState(
+      """
+        ${c}hello world
+        ${c}this is a test
+        ${c}for case conversion
+
+        """.trimIndent()
+    )
+  }
+
+  @Disabled("Not yet supported")
+  @Test
+  fun testChangeCaseLowerLineActionDuplicated() {
+    typeTextInFile(
+      injector.parser.parseKeys("gugu"),
+      """
+        H${c}ELLO WORLD
+        ${c}THIS IS A TEST
+        ${c}FOR CASE CONVERSION
+
+        """.trimIndent(),
+    )
+    assertState(
+      """
+        ${c}hello world
+        ${c}this is a test
+        ${c}for case conversion
+
+        """.trimIndent()
+    )
+  }
+
+  @Test
+  fun testChangeCaseUpperLineAction() {
+    typeTextInFile(
+      injector.parser.parseKeys("gUU"),
+      """
+        h${c}ello world
+        ${c}this is a test
+        ${c}for case conversion
+
+        """.trimIndent(),
+    )
+    assertState(
+      """
+        ${c}HELLO WORLD
+        ${c}THIS IS A TEST
+        ${c}FOR CASE CONVERSION
+
+        """.trimIndent()
+    )
+  }
+
+  @Disabled("Not yet supported")
+  @Test
+  fun testChangeCaseUpperLineActionDuplicated() {
+    typeTextInFile(
+      injector.parser.parseKeys("gUgU"),
+      """
+        h${c}ello world
+        ${c}this is a test
+        ${c}for case conversion
+
+        """.trimIndent(),
+    )
+    assertState(
+      """
+        ${c}HELLO WORLD
+        ${c}THIS IS A TEST
+        ${c}FOR CASE CONVERSION
+
+        """.trimIndent()
+    )
+  }
+}

src/test/java/org/jetbrains/plugins/ideavim/action/ChangeRot13Test.kt

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2003-2025 The IdeaVim authors
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE.txt file or at
+ * https://opensource.org/licenses/MIT.
+ */
+package org.jetbrains.plugins.ideavim.action
+
+import com.maddyhome.idea.vim.api.injector
+import org.jetbrains.plugins.ideavim.VimTestCase
+import org.junit.jupiter.api.Disabled
+import org.junit.jupiter.api.Test
+
+class ChangeRot13Test : VimTestCase() {
+  @Test
+  fun testChangeRot13MotionAction() {
+    typeTextInFile(
+      injector.parser.parseKeys("g?2w"),
+      "H${c}ello World ${c}This is a ${c}test for ROT13 ${c}encoding\n",
+    )
+    assertState("H${c}ryyb Jbeyq ${c}Guvf vf a ${c}grfg sbe ROT13 ${c}rapbqvat\n")
+  }
+
+  @Test
+  fun testChangeRot13VisualAction() {
+    typeTextInFile(
+      injector.parser.parseKeys("v2wg?"),
+      "H${c}ello World ${c}This is a ${c}test for ROT13 ${c}encoding\n",
+    )
+    assertState("H${c}ryyb Jbeyq Guvf vf n ${c}grfg sbe EOT13 ${c}rapbqvat\n")
+  }
+
+  @Test
+  fun testChangeRot13LineAction() {
+    typeTextInFile(
+      injector.parser.parseKeys("g??"),
+      """
+        H${c}ello World
+        ${c}This is a test
+        ${c}for ROT13 encoding
+
+        """.trimIndent(),
+    )
+    assertState(
+      """
+        ${c}Uryyb Jbeyq
+        ${c}Guvf vf n grfg
+        ${c}sbe EBG13 rapbqvat
+
+        """.trimIndent()
+    )
+  }
+
+  @Disabled("Not yet supported")
+  @Test
+  fun testChangeRot13LineActionDuplicated() {
+    typeTextInFile(
+      injector.parser.parseKeys("g?g?"),
+      """
+        H${c}ello World
+        ${c}This is a test
+        ${c}for ROT13 encoding
+
+        """.trimIndent(),
+    )
+    assertState(
+      """
+        ${c}Uryyb Jbeyq
+        ${c}Guvf vf n grfg
+        ${c}sbe EBG13 rapbqvat
+
+        """.trimIndent()
+    )
+  }
+  @Test
+  fun testChangeRot13NonEnglishLetters() {
+    typeTextInFile(
+      injector.parser.parseKeys("g?$"),
+      "${c}Привет мир! Hello world!\n",
+    )
+    assertState("${c}Привет мир! Uryyb jbeyq!\n")
+  }
+
+  @Test
+  fun testChangeRot13FullAlphabet() {
+    typeTextInFile(
+      injector.parser.parseKeys("g?$"),
+      "${c}abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
+    )
+    assertState("${c}nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM\n")
+  }
+
+  @Test
+  fun testChangeRot13Symbols() {
+    typeTextInFile(
+      injector.parser.parseKeys("g?$"),
+      "${c}!@#$%^&*()_+-=[]{}|;:'\",.<>/?\n",
+    )
+    assertState("${c}!@#$%^&*()_+-=[]{}|;:'\",.<>/?\n")
+  }
+}

src/test/java/org/jetbrains/plugins/ideavim/action/MacroActionTest.kt

@@ -284,4 +284,206 @@ class MacroActionTest : VimTestCase() {
 
     assertTrue(KeyHandler.getInstance().keyStack.isEmpty())
   }
+
+  // Undo tests for macros
+  @Test
+  fun `test undo after simple macro execution`() {
+    configureByText("${c}Hello world")
+    typeText(injector.parser.parseKeys("qa" + "dw" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState(c)
+    // Single undo should restore the state after a simple macro
+    typeText("u")
+    assertState("${c}world")
+  }
+
+  @Test
+  fun `test undo after macro with insert mode`() {
+    val initialText = "${c}test"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + "A" + " added" + "<Esc>" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("test added adde${c}d")
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "test" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState("test$c")
+  }
+
+  @Test
+  fun `test undo after executing macro multiple times`() {
+    val initialText = "${c}one two three four"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + "dw" + "q"))
+    typeText(injector.parser.parseKeys("3@a"))
+    assertState(c)
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "one two three four" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState(initialText)
+    // Verify that multiple undos were needed (one for each macro execution)
+    assertTrue(undoCount == 2, "Expected 2 undos for 2 macro executions, but needed $undoCount")
+  }
+
+  @Test
+  fun `test undo after nested macro execution`() {
+    val initialText = "${c}line1\nline2\nline3"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + "dd" + "q"))
+    typeText(injector.parser.parseKeys("qb" + "j@a" + "q"))
+    typeText(injector.parser.parseKeys("@b"))
+    assertState("${c}line2")
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "line1\nline2\nline3" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState(initialText)
+  }
+
+  @Test
+  fun `test undo macro with multiple operations`() {
+    val initialText = "${c}foo bar baz"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + "dw" + "A" + "!" + "<Esc>" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("bar baz${c}!")
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "foo bar baz" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState(initialText)
+    // Verify that multiple undos were needed for the multiple operations in the macro
+    assertTrue(undoCount > 1, "Expected multiple undos for macro with multiple operations")
+  }
+
+  @Test
+  fun `test undo macro with visual mode operations`() {
+    val initialText = "${c}select this text"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + "viw" + "d" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("${c}this text")
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "select this text" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState(initialText)
+  }
+
+  @Test
+  fun `test undo macro with change operation`() {
+    val initialText = "${c}change(this)"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + "ci(" + "that" + "<Esc>" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("change(tha${c}t)")
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "change(this)" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState(initialText)
+  }
+
+  @Test
+  fun `test undo after repeating last macro`() {
+    val initialText = "${c}word1 word2 word3"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + "dw" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("${c}word3")
+    typeText(injector.parser.parseKeys("@@"))
+    assertState(c)
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "word1 word2 word3" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState(initialText)
+    // Each macro execution should create its own undo entry
+    assertTrue(undoCount == 3, "Expected 3 undos for 3 macro executions, but was $undoCount")
+  }
+
+  @Test
+  fun `test undo macro with ex command`() {
+    val initialText = "${c}line1\nline2\nline3"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + ":d<CR>" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("${c}line3")
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "line1\nline2\nline3" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState(initialText)
+  }
+
+  @Test
+  fun `test undo macro with substitute command`() {
+    val initialText = "${c}hello world hello"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + ":s/hello/goodbye<CR>" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("${c}goodbye world goodbye")
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "hello world hello" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState(initialText)
+  }
+
+  @Test
+  fun `test multiple undo after macro`() {
+    val initialText = "${c}one two three"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + "dw" + "i" + "first " + "<Esc>" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("firstfirst${c} two three")
+    typeText(injector.parser.parseKeys("w"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("firstfirst first${c} three")
+    // Verify that undo can restore the original state
+    var undoCount = 0
+    while (fixture.editor.document.text != "one two three" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState(initialText)
+    // Should need multiple undos since we executed the macro twice
+    assertTrue(undoCount >= 2, "Expected at least 2 undos for 2 macro executions")
+  }
+
+  @Test
+  fun `test undo restores cursor position after macro`() {
+    val initialText = "${c}start middle end"
+    configureByText(initialText)
+    typeText(injector.parser.parseKeys("qa" + "w" + "dw" + "q"))
+    typeText(injector.parser.parseKeys("@a"))
+    assertState("start en${c}d")
+    // Verify that undo can restore both text and cursor position
+    var undoCount = 0
+    while (fixture.editor.document.text != "start middle end" && undoCount < 10) {
+      typeText("u")
+      undoCount++
+    }
+    assertState("start ${c}middle end")
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/MotionActionTest.kt

@@ -875,15 +875,6 @@ class MotionActionTest : VimTestCase() {
     assertOffset(9)
   }
 
-  // VIM-965 |[m|
-  @TestWithoutNeovim(reason = SkipNeovimReason.DIFFERENT, "File type specific")
-  @Test
-  fun testMethodMovingInNonJavaFile() {
-    configureByJsonText("{\"foo\": \"${c}bar\"}\n")
-    typeText(injector.parser.parseKeys("[m"))
-    assertState("{\"foo\": \"${c}bar\"}\n")
-  }
-
   // VIM-331 |w|
   @TestWithoutNeovim(reason = SkipNeovimReason.UNCLEAR)
   @Test

src/test/java/org/jetbrains/plugins/ideavim/action/MultipleCaretsTest.kt

@@ -18,7 +18,6 @@ import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.state.mode.SelectionType
 import org.jetbrains.plugins.ideavim.VimBehaviorDiffers
 import org.jetbrains.plugins.ideavim.VimTestCase
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 import kotlin.test.assertNotNull
 
@@ -1822,7 +1821,6 @@ $c five six se${c}ven eight
     )
   }
 
-  @Disabled("Action execution in tests is broken for 2024.2")
   @Test
   fun testInsertNewLineAboveAction() {
     typeTextInFile(
@@ -1849,7 +1847,6 @@ $c five six se${c}ven eight
     )
   }
 
-  @Disabled("Action execution in tests is broken for 2024.2")
   @VimBehaviorDiffers(originalVimAfter = "${c}\n${c}\nabcde\n${c}\n${c}\nabcde\n")
   @Test
   fun testInsertNewLineAboveActionWithMultipleCaretsInLine() {
@@ -1864,7 +1861,6 @@ $c five six se${c}ven eight
     assertState("${c}\nabcde\n${c}\nabcde\n")
   }
 
-  @Disabled("Action execution in tests is broken for 2024.2")
   @Test
   fun testInsertNewLineBelowAction() {
     typeTextInFile(
@@ -2185,16 +2181,18 @@ rtyfg${c}hzxc"""
     val vimEditor = fixture.editor.vim
     val context = injector.executionContextManager.getEditorExecutionContext(vimEditor)
     injector.registerGroup.storeText(vimEditor, context, '*', "fgh")
-    ApplicationManager.getApplication().runWriteAction {
+    ApplicationManager.getApplication().invokeAndWait {
-      VimPlugin.getRegister()
+      ApplicationManager.getApplication().runWriteAction {
-        .storeText(
+        VimPlugin.getRegister()
-          IjVimEditor(editor),
+          .storeText(
-          context,
+            IjVimEditor(editor),
-          editor.vim.primaryCaret(),
+            context,
-          TextRange(16, 19),
+            editor.vim.primaryCaret(),
-          SelectionType.CHARACTER_WISE,
+            TextRange(16, 19),
-          false
+            SelectionType.CHARACTER_WISE,
-        )
+            false
+          )
+      }
     }
     typeText(injector.parser.parseKeys("\"*P"))
     val after = "fg${c}hqfg${c}hwe asd zxc rty fg${c}hfgh vbn"

src/test/java/org/jetbrains/plugins/ideavim/action/change/ComplexUndoTest.kt

@@ -0,0 +1,557 @@
+/*
+ * Copyright 2003-2023 The IdeaVim authors
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE.txt file or at
+ * https://opensource.org/licenses/MIT.
+ */
+
+package org.jetbrains.plugins.ideavim.action.change
+
+import org.jetbrains.plugins.ideavim.VimTestCase
+import org.junit.jupiter.api.Test
+
+/**
+ * Tests for complex undo scenarios involving motion and change operations
+ * These tests verify that undo correctly restores both text and cursor position
+ */
+class ComplexUndoTest : VimTestCase() {
+  @Test
+  fun `test undo change inside parentheses with cursor movement`() {
+    // This is the example from the user's request
+    configureByText("a${c}bc(xxx)def")
+    typeText("ci(")
+    typeText("yyy")
+    typeText("<Esc>")
+    assertState("abc(yy${c}y)def")
+    typeText("u")
+    assertState("a${c}bc(xxx)def")
+  }
+
+  @Test
+  fun `test undo change inside parentheses with cursor movement with oldundo`() {
+    // This is the example from the user's request
+    configureByText("a${c}bc(xxx)def")
+    try {
+      enterCommand("set oldundo")
+      typeText("ci(")
+      typeText("yyy")
+      typeText("<Esc>")
+      assertState("abc(yy${c}y)def")
+      typeText("u")
+      assertState("abc(yyy${c})def")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo delete inside brackets with cursor movement`() {
+    configureByText("fo${c}o[bar]baz")
+    typeText("di[")
+    assertState("foo[${c}]baz")
+    typeText("u")
+    assertState("fo${c}o[bar]baz")
+  }
+
+  @Test
+  fun `test undo delete inside brackets with cursor movement with oldundo`() {
+    configureByText("fo${c}o[bar]baz")
+    try {
+      enterCommand("set oldundo")
+      typeText("di[")
+      assertState("foo[${c}]baz")
+      typeText("u")
+      assertState("fo${c}o[bar]baz")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo change inside quotes with cursor movement`() {
+    configureByText("Say ${c}hello \"world\" today")
+    typeText("ci\"")
+    typeText("universe")
+    typeText("<Esc>")
+    assertState("Say hello \"univers${c}e\" today")
+    typeText("u")
+    assertState("Say ${c}hello \"world\" today")
+  }
+
+  @Test
+  fun `test undo change inside quotes with cursor movement with oldundo`() {
+    configureByText("Say ${c}hello \"world\" today")
+    try {
+      enterCommand("set oldundo")
+      typeText("ci\"")
+      typeText("universe")
+      typeText("<Esc>")
+      assertState("Say hello \"univers${c}e\" today")
+      typeText("u")
+      assertState("Say hello \"universe${c}\" today")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo delete word with cursor at different position`() {
+    configureByText("The qu${c}ick brown fox")
+    typeText("daw")  // Delete a word (including surrounding spaces)
+    assertState("The ${c}brown fox")
+    typeText("u")
+    assertState("The qu${c}ick brown fox")
+  }
+
+  @Test
+  fun `test undo delete word with cursor at different position with oldundo`() {
+    configureByText("The qu${c}ick brown fox")
+    try {
+      enterCommand("set oldundo")
+      typeText("daw")  // Delete a word (including surrounding spaces)
+      assertState("The ${c}brown fox")
+      typeText("u")
+      assertState("The qu${c}ick brown fox")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo change paragraph with cursor movement`() {
+    configureByText(
+      """
+      First paragraph.
+      
+      Sec${c}ond paragraph
+      with multiple lines.
+      
+      Third paragraph.
+    """.trimIndent()
+    )
+    typeText("cip")
+    typeText("New content")
+    typeText("<Esc>")
+    assertState(
+      """
+      First paragraph.
+      
+      New conten${c}t
+      
+      Third paragraph.
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      First paragraph.
+      
+      Sec${c}ond paragraph
+      with multiple lines.
+      
+      Third paragraph.
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo change paragraph with cursor movement with oldundo`() {
+    configureByText(
+      """
+      First paragraph.
+      
+      Sec${c}ond paragraph
+      with multiple lines.
+      
+      Third paragraph.
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("cip")
+      typeText("New content")
+      typeText("<Esc>")
+      assertState(
+        """
+      First paragraph.
+      
+      New conten${c}t
+      
+      Third paragraph.
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      First paragraph.
+      
+      New content${c}
+      
+      Third paragraph.
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo delete to search result`() {
+    configureByText("abc${c}defghijklmnop")
+    typeText("d/jkl<CR>")  // Delete to search result
+    assertState("abc${c}jklmnop")
+    typeText("u")
+    assertState("abc${c}defghijklmnop")
+  }
+
+  @Test
+  fun `test undo delete to search result with oldundo`() {
+    configureByText("abc${c}defghijklmnop")
+    try {
+      enterCommand("set oldundo")
+      typeText("d/jkl<CR>")  // Delete to search result
+      assertState("abc${c}jklmnop")
+      typeText("u")
+      assertState("abc${c}defghijklmnop")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo change to mark with cursor movement`() {
+    configureByText(
+      """
+      Li${c}ne 1
+      Line 2
+      Line 3
+      Line 4
+    """.trimIndent()
+    )
+    typeText("ma")  // Set mark 'a'
+    typeText("2j")   // Move down 2 lines
+    assertState(
+      """
+      Line 1
+      Line 2
+      Li${c}ne 3
+      Line 4
+    """.trimIndent()
+    )
+    typeText("c'a")  // Change to mark 'a'
+    typeText("Changed")
+    typeText("<Esc>")
+    assertState(
+      """
+      Change${c}d
+      Line 4
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      Line 1
+      Line 2
+      Li${c}ne 3
+      Line 4
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo change to mark with cursor movement with oldundo`() {
+    configureByText(
+      """
+      Li${c}ne 1
+      Line 2
+      Line 3
+      Line 4
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("ma")  // Set mark 'a'
+      typeText("2j")   // Move down 2 lines
+      assertState(
+        """
+      Line 1
+      Line 2
+      Li${c}ne 3
+      Line 4
+    """.trimIndent()
+      )
+      typeText("c'a")  // Change to mark 'a'
+      typeText("Changed")
+      typeText("<Esc>")
+      assertState(
+        """
+      Change${c}d
+      Line 4
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      Changed${c}
+      Line 4
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo substitute with cursor movement`() {
+    configureByText("${c}Hello world hello")
+    typeText(":s/hello/goodbye/gi<CR>")  // Substitute with flags
+    assertState("${c}goodbye world goodbye")
+    typeText("u")
+    assertState("${c}Hello world hello")
+  }
+
+  @Test
+  fun `test undo substitute with cursor movement with oldundo`() {
+    configureByText("${c}Hello world hello")
+    try {
+      enterCommand("set oldundo")
+      typeText(":s/hello/goodbye/gi<CR>")  // Substitute with flags
+      assertState("${c}goodbye world goodbye")
+      typeText("u")
+      assertState("${c}Hello world hello")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo multiple operations in sequence`() {
+    configureByText("${c}abc def ghi")
+
+    // First operation: delete word
+    typeText("dw")
+    assertState("${c}def ghi")
+
+    // Second operation: change word
+    typeText("cw")
+    typeText("xyz")
+    typeText("<Esc>")
+    assertState("xy${c}z ghi")
+
+    // Third operation: append at end
+    typeText("A")
+    typeText(" jkl")
+    typeText("<Esc>")
+    assertState("xyz ghi jk${c}l")
+
+    // Undo all operations
+    typeText("u")
+    assertState("xyz ghi${c}")
+
+    typeText("u")
+    assertState("${c}def ghi")
+
+    typeText("u")
+    assertState("${c}abc def ghi")
+  }
+
+  @Test
+  fun `test undo multiple operations in sequence with oldundo`() {
+    configureByText("${c}abc def ghi")
+    try {
+      enterCommand("set oldundo")
+
+      // First operation: delete word
+      typeText("dw")
+      assertState("${c}def ghi")
+
+      // Second operation: change word
+      typeText("cw")
+      typeText("xyz")
+      typeText("<Esc>")
+      assertState("xy${c}z ghi")
+
+      // Third operation: append at end
+      typeText("A")
+      typeText(" jkl")
+      typeText("<Esc>")
+      assertState("xyz ghi jk${c}l")
+
+      // Undo all operations
+      typeText("u")
+      assertState("xyz ghi jkl${c}")
+
+      typeText("u")
+      assertState("xyz ghi${c}")
+
+      typeText("u")
+      assertState("xyz${c} ghi")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo with text objects and counts`() {
+    configureByText("function(${c}arg1, arg2, arg3)")
+    typeText("d2f,")  // Delete to 2nd comma
+    assertState("function(${c} arg3)")
+    typeText("u")
+    assertState("function(${c}arg1, arg2, arg3)")
+  }
+
+  @Test
+  fun `test undo with text objects and counts with oldundo`() {
+    configureByText("function(${c}arg1, arg2, arg3)")
+    try {
+      enterCommand("set oldundo")
+      typeText("d2f,")  // Delete to 2nd comma
+      assertState("function(${c} arg3)")
+      typeText("u")
+      assertState("function(${c}arg1, arg2, arg3)")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo inner word at end of word`() {
+    configureByText("The quic${c}k brown fox")
+    typeText("diw")
+    assertState("The ${c} brown fox")
+    typeText("u")
+    assertState("The quic${c}k brown fox")
+  }
+
+  @Test
+  fun `test undo inner word at end of word with oldundo`() {
+    configureByText("The quic${c}k brown fox")
+    try {
+      enterCommand("set oldundo")
+      typeText("diw")
+      assertState("The ${c} brown fox")
+      typeText("u")
+      assertState("The quic${c}k brown fox")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo change with register and motion`() {
+    configureByText("${c}Hello world")
+    typeText("\"aciw")  // Change inner word into register 'a'
+    typeText("Goodbye")
+    typeText("<Esc>")
+    assertState("Goodby${c}e world")
+    typeText("u")
+    assertState("${c}Hello world")
+  }
+
+  @Test
+  fun `test undo change with register and motion with oldundo`() {
+    configureByText("${c}Hello world")
+    try {
+      enterCommand("set oldundo")
+      typeText("\"aciw")  // Change inner word into register 'a'
+      typeText("Goodbye")
+      typeText("<Esc>")
+      assertState("Goodby${c}e world")
+      typeText("u")
+      assertState("Goodbye${c} world")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo join with indentation handling`() {
+    configureByText(
+      """
+      if (condition) {
+          ${c}doSomething();
+          doMore();
+      }
+    """.trimIndent()
+    )
+    typeText("J")
+    assertState(
+      """
+      if (condition) {
+          doSomething();${c} doMore();
+      }
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      if (condition) {
+          ${c}doSomething();
+          doMore();
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo join with indentation handling with oldundo`() {
+    configureByText(
+      """
+      if (condition) {
+          ${c}doSomething();
+          doMore();
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("J")
+      assertState(
+        """
+      if (condition) {
+          doSomething();${c} doMore();
+      }
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      if (condition) {
+          ${c}doSomething();
+          doMore();
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo replace mode changes`() {
+    configureByText("${c}Hello world")
+    typeText("R")
+    typeText("Goodbye")
+    typeText("<Esc>")
+    assertState("Goodby${c}eorld")
+    typeText("u")
+    assertState("${c}Hello world")
+  }
+
+  @Test
+  fun `test undo replace mode changes with oldundo`() {
+    configureByText("${c}Hello world")
+    try {
+      enterCommand("set oldundo")
+      typeText("R")
+      typeText("Goodbye")
+      typeText("<Esc>")
+      assertState("Goodby${c}eorld")
+      typeText("u")
+      assertState("Goodbye${c}orld")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+}

src/test/java/org/jetbrains/plugins/ideavim/action/change/OperatorActionTest.kt

@@ -9,7 +9,6 @@
 package org.jetbrains.plugins.ideavim.action.change
 
 import org.jetbrains.plugins.ideavim.VimTestCase
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 
 class OperatorActionTest : VimTestCase() {
@@ -154,7 +153,6 @@ class OperatorActionTest : VimTestCase() {
   }
 
   @Test
-  @Disabled(":set does not correctly parse the quotes in the lambda syntax")
   // The parser is treating the second double-quote char as a comment. The argument to the command is parsed as:
   // opfunc={ arg -> execute "`[v`]rx
   // The map command is properly handled - the `<CR>g@` is correctly understood, and the full lambda is passed to the

src/test/java/org/jetbrains/plugins/ideavim/action/change/change/ChangeCaseToggleCharacterActionTest.kt

@@ -85,4 +85,239 @@ class ChangeCaseToggleCharacterActionTest : VimTestCase() {
       this.enterCommand("set whichwrap=~")
     }
   }
+
+  @Test
+  fun `test undo after toggle case single character`() {
+    configureByText("Hello ${c}World")
+    typeText("~")
+    assertState("Hello w${c}orld")
+    typeText("u")
+    assertState("Hello ${c}World")
+  }
+
+  @Test
+  fun `test undo after toggle case single character with oldundo`() {
+    configureByText("Hello ${c}World")
+    try {
+      enterCommand("set oldundo")
+      typeText("~")
+      assertState("Hello w${c}orld")
+      typeText("u")
+      assertState("Hello ${c}World")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after toggle case multiple characters`() {
+    configureByText("${c}hello WORLD")
+    typeText("5~")
+    assertState("HELLO${c} WORLD")
+    typeText("u")
+    assertState("${c}hello WORLD")
+  }
+
+  @Test
+  fun `test undo after toggle case multiple characters with oldundo`() {
+    configureByText("${c}hello WORLD")
+    try {
+      enterCommand("set oldundo")
+      typeText("5~")
+      assertState("HELLO${c} WORLD")
+      typeText("u")
+      assertState("${c}hello WORLD")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test multiple undo after sequential toggle case`() {
+    configureByText("${c}aBc")
+    typeText("~")
+    assertState("A${c}Bc")
+    typeText("~")
+    assertState("Ab${c}c")
+    typeText("~")
+    assertState("Ab${c}C")
+    
+    // Undo third toggle
+    typeText("u")
+    assertState("Ab${c}c")
+    
+    // Undo second toggle
+    typeText("u")
+    assertState("A${c}Bc")
+    
+    // Undo first toggle
+    typeText("u")
+    assertState("${c}aBc")
+  }
+
+  @Test
+  fun `test multiple undo after sequential toggle case with oldundo`() {
+    configureByText("${c}aBc")
+    try {
+      enterCommand("set oldundo")
+      typeText("~")
+      assertState("A${c}Bc")
+      typeText("~")
+      assertState("Ab${c}c")
+      typeText("~")
+      assertState("Ab${c}C")
+
+      // Undo third toggle
+      typeText("u")
+      assertState("Ab${c}c")
+
+      // Undo second toggle
+      typeText("u")
+      assertState("A${c}Bc")
+
+      // Undo first toggle
+      typeText("u")
+      assertState("${c}aBc")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo toggle case motion`() {
+    configureByText("${c}hello world")
+    typeText("g~w")
+    assertState("${c}HELLO world")
+    typeText("u")
+    assertState("${c}hello world")
+  }
+
+  @Test
+  fun `test undo toggle case motion with oldundo`() {
+    configureByText("${c}hello world")
+    try {
+      enterCommand("set oldundo")
+      typeText("g~w")
+      assertState("${c}HELLO world")
+      typeText("u")
+      assertState("${c}hello world")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo uppercase motion`() {
+    configureByText("${c}hello world")
+    typeText("gUw")
+    assertState("${c}HELLO world")
+    typeText("u")
+    assertState("${c}hello world")
+  }
+
+  @Test
+  fun `test undo uppercase motion with oldundo`() {
+    configureByText("${c}hello world")
+    try {
+      enterCommand("set oldundo")
+      typeText("gUw")
+      assertState("${c}HELLO world")
+      typeText("u")
+      assertState("${c}hello world")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo lowercase motion`() {
+    configureByText("${c}HELLO WORLD")
+    typeText("guw")
+    assertState("${c}hello WORLD")
+    typeText("u")
+    assertState("${c}HELLO WORLD")
+  }
+
+  @Test
+  fun `test undo lowercase motion with oldundo`() {
+    configureByText("${c}HELLO WORLD")
+    try {
+      enterCommand("set oldundo")
+      typeText("guw")
+      assertState("${c}hello WORLD")
+      typeText("u")
+      assertState("${c}HELLO WORLD")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo toggle case line`() {
+    configureByText("${c}Hello World")
+    typeText("g~~")
+    assertState("${c}hELLO wORLD")
+    typeText("u")
+    assertState("${c}Hello World")
+  }
+
+  @Test
+  fun `test undo toggle case line with oldundo`() {
+    configureByText("${c}Hello World")
+    try {
+      enterCommand("set oldundo")
+      typeText("g~~")
+      assertState("${c}hELLO wORLD")
+      typeText("u")
+      assertState("${c}Hello World")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo uppercase line`() {
+    configureByText("${c}Hello World")
+    typeText("gUU")
+    assertState("${c}HELLO WORLD")
+    typeText("u")
+    assertState("${c}Hello World")
+  }
+
+  @Test
+  fun `test undo uppercase line with oldundo`() {
+    configureByText("${c}Hello World")
+    try {
+      enterCommand("set oldundo")
+      typeText("gUU")
+      assertState("${c}HELLO WORLD")
+      typeText("u")
+      assertState("${c}Hello World")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo lowercase line`() {
+    configureByText("${c}HELLO WORLD")
+    typeText("guu")
+    assertState("${c}hello world")
+    typeText("u")
+    assertState("${c}HELLO WORLD")
+  }
+
+  @Test
+  fun `test undo lowercase line with oldundo`() {
+    configureByText("${c}HELLO WORLD")
+    try {
+      enterCommand("set oldundo")
+      typeText("guu")
+      assertState("${c}hello world")
+      typeText("u")
+      assertState("${c}HELLO WORLD")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/change/ChangeMotionActionTest.kt

@@ -12,7 +12,6 @@ package org.jetbrains.plugins.ideavim.action.change.change
 
 import com.maddyhome.idea.vim.state.mode.Mode
 import org.jetbrains.plugins.ideavim.VimTestCase
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 
 class ChangeMotionActionTest : VimTestCase() {
@@ -150,9 +149,7 @@ class ChangeMotionActionTest : VimTestCase() {
   }
 
   // VIM-276 |c| |F|
-  @Suppress("unused")
   @Test
-  @Disabled
   fun testChangeLinesToBackwards() {
     doTest(
       "cFc",
@@ -208,4 +205,280 @@ class ChangeMotionActionTest : VimTestCase() {
       """.trimIndent()
     )
   }
+
+  @Test
+  fun `test undo after change word`() {
+    configureByText("Hello ${c}world and more")
+    typeText("cw")
+    typeText("Vim")
+    typeText("<Esc>")
+    assertState("Hello Vi${c}m and more")
+    typeText("u")
+    assertState("Hello ${c}world and more")
+  }
+
+  @Test
+  fun `test undo after change word with oldundo`() {
+    configureByText("Hello ${c}world and more")
+    try {
+      enterCommand("set oldundo")
+      typeText("cw")
+      typeText("Vim")
+      typeText("<Esc>")
+      assertState("Hello Vi${c}m and more")
+      typeText("u")
+      assertState("Hello Vim${c} and more")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after change line`() {
+    configureByText(
+      """
+      First line
+      ${c}Second line with text
+      Third line
+    """.trimIndent()
+    )
+    typeText("cc")
+    typeText("Changed line")
+    typeText("<Esc>")
+    assertState(
+      """
+      First line
+      Changed lin${c}e
+      Third line
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      First line
+      ${c}Second line with text
+      Third line
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after change line with oldundo`() {
+    configureByText(
+      """
+      First line
+      ${c}Second line with text
+      Third line
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("cc")
+      typeText("Changed line")
+      typeText("<Esc>")
+      assertState(
+        """
+      First line
+      Changed lin${c}e
+      Third line
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      First line
+      Changed line${c}
+      Third line
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after change to end of line`() {
+    configureByText("Start ${c}middle end")
+    typeText("C")
+    typeText("new ending")
+    typeText("<Esc>")
+    assertState("Start new endin${c}g")
+    typeText("u")
+    assertState("Start ${c}middle end")
+  }
+
+  @Test
+  fun `test undo after change to end of line with oldundo`() {
+    configureByText("Start ${c}middle end")
+    try {
+      enterCommand("set oldundo")
+      typeText("C")
+      typeText("new ending")
+      typeText("<Esc>")
+      assertState("Start new endin${c}g")
+      typeText("u")
+      assertState("Start new ending${c}")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after change with motion`() {
+    configureByText("The ${c}quick brown fox")
+    typeText("c3w")
+    typeText("slow")
+    typeText("<Esc>")
+    assertState("The slo${c}w")
+    typeText("u")
+    assertState("The ${c}quick brown fox")
+  }
+
+  @Test
+  fun `test undo after change with motion with oldundo`() {
+    configureByText("The ${c}quick brown fox")
+    try {
+      enterCommand("set oldundo")
+      typeText("c3w")
+      typeText("slow")
+      typeText("<Esc>")
+      assertState("The slo${c}w")
+      typeText("u")
+      assertState("The slow${c}")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo change with motion and caret movement`() {
+    configureByText("a${c}bc(xxx)def")
+    typeText("ci(")
+    typeText("yyy")
+    typeText("<Esc>")
+    assertState("abc(yy${c}y)def")
+    typeText("u")
+    assertState("a${c}bc(xxx)def")
+  }
+
+  @Test
+  fun `test undo change with motion and caret movement with oldundo`() {
+    configureByText("a${c}bc(xxx)def")
+    try {
+      enterCommand("set oldundo")
+      typeText("ci(")
+      typeText("yyy")
+      typeText("<Esc>")
+      assertState("abc(yy${c}y)def")
+      typeText("u")
+      assertState("abc(yyy${c})def")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test multiple undo after sequential changes`() {
+    configureByText("${c}one two three")
+    typeText("cw")
+    typeText("ONE")
+    typeText("<Esc>")
+    assertState("ON${c}E two three")
+
+    typeText("w")
+    typeText("cw")
+    typeText("TWO")
+    typeText("<Esc>")
+    assertState("ONE TW${c}O three")
+
+    // Undo second change
+    typeText("u")
+    assertState("ONE ${c}two three")
+
+    // Undo first change
+    typeText("u")
+    assertState("${c}one two three")
+  }
+
+  @Test
+  fun `test multiple undo after sequential changes with oldundo`() {
+    configureByText("${c}one two three")
+    try {
+      enterCommand("set oldundo")
+      typeText("cw")
+      typeText("ONE")
+      typeText("<Esc>")
+      assertState("ON${c}E two three")
+
+      typeText("w")
+      typeText("cw")
+      typeText("TWO")
+      typeText("<Esc>")
+      assertState("ONE TW${c}O three")
+
+      // Undo second change
+      typeText("u")
+      assertState("ONE TWO${c} three")
+
+      // Undo first change
+      typeText("u")
+      assertState("ONE ${c} three")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo change character`() {
+    configureByText("a${c}bcdef")
+    typeText("s")
+    typeText("X")
+    typeText("<Esc>")
+    assertState("a${c}Xcdef")
+    typeText("u")
+    assertState("a${c}bcdef")
+  }
+
+  @Test
+  fun `test undo change character with oldundo`() {
+    configureByText("a${c}bcdef")
+    try {
+      enterCommand("set oldundo")
+      typeText("s")
+      typeText("X")
+      typeText("<Esc>")
+      assertState("a${c}Xcdef")
+      typeText("u")
+      assertState("aX${c}cdef")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo change multiple characters`() {
+    configureByText("abc${c}defghijk")
+    typeText("3s")
+    typeText("XXX")
+    typeText("<Esc>")
+    assertState("abcXX${c}Xghijk")
+    typeText("u")
+    assertState("abc${c}defghijk")
+  }
+
+  @Test
+  fun `test undo change multiple characters with oldundo`() {
+    configureByText("abc${c}defghijk")
+    try {
+      enterCommand("set oldundo")
+      typeText("3s")
+      typeText("XXX")
+      typeText("<Esc>")
+      assertState("abcXX${c}Xghijk")
+      typeText("u")
+      assertState("abcXXX${c}ghijk")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/change/number/ChangeNumberDecActionTest.kt

@@ -47,4 +47,245 @@ class ChangeNumberDecActionTest : VimTestCase() {
       Mode.NORMAL(),
     )
   }
+
+  @Test
+  fun `test undo after decrement number`() {
+    configureByText("The answer is ${c}42")
+    typeText("<C-X>")
+    assertState("The answer is 4${c}1")
+    typeText("u")
+    assertState("The answer is ${c}42")
+  }
+
+  @Test
+  fun `test undo after decrement number with oldundo`() {
+    configureByText("The answer is ${c}42")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-X>")
+      assertState("The answer is 4${c}1")
+      typeText("u")
+      assertState("The answer is ${c}42")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after decrement number with caret move`() {
+    configureByText("The answer ${c}is 42")
+    typeText("<C-X>")
+    assertState("The answer is 4${c}1")
+    typeText("u")
+    assertState("The answer ${c}is 42")
+  }
+
+  @Test
+fun `test undo after decrement number with caret move with oldundo`() {
+    configureByText("The answer ${c}is 42")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-X>")
+      assertState("The answer is 4${c}1")
+      typeText("u")
+      assertState("The answer ${c}is 42")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after decrement with count`() {
+    configureByText("Count: ${c}20")
+    typeText("5<C-X>")
+    assertState("Count: 1${c}5")
+    typeText("u")
+    assertState("Count: ${c}20")
+  }
+
+  @Test
+  fun `test undo after decrement with count with oldundo`() {
+    configureByText("Count: ${c}20")
+    try {
+      enterCommand("set oldundo")
+      typeText("5<C-X>")
+      assertState("Count: 1${c}5")
+      typeText("u")
+      assertState("Count: ${c}20")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after decrement negative number`() {
+    configureByText("Temperature: ${c}-5 degrees")
+    typeText("<C-X>")
+    assertState("Temperature: -${c}6 degrees")
+    typeText("u")
+    assertState("Temperature: ${c}-5 degrees")
+  }
+
+  @Test
+  fun `test undo after decrement negative number with oldundo`() {
+    configureByText("Temperature: ${c}-5 degrees")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-X>")
+      assertState("Temperature: -${c}6 degrees")
+      typeText("u")
+      assertState("Temperature: ${c}-5 degrees")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test multiple undo after sequential decrements`() {
+    configureByText("Value: ${c}100")
+    typeText("<C-X>")
+    assertState("Value: 9${c}9")
+    typeText("<C-X>")
+    assertState("Value: 9${c}8")
+    typeText("<C-X>")
+    assertState("Value: 9${c}7")
+
+    // Undo third decrement
+    typeText("u")
+    assertState("Value: 9${c}8")
+
+    // Undo second decrement
+    typeText("u")
+    assertState("Value: 9${c}9")
+
+    // Undo first decrement
+    typeText("u")
+    assertState("Value: ${c}100")
+  }
+
+  @Test
+  fun `test multiple undo after sequential decrements with oldundo`() {
+    configureByText("Value: ${c}100")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-X>")
+      assertState("Value: 9${c}9")
+      typeText("<C-X>")
+      assertState("Value: 9${c}8")
+      typeText("<C-X>")
+      assertState("Value: 9${c}7")
+
+      // Undo third decrement
+      typeText("u")
+      assertState("Value: 9${c}8")
+
+      // Undo second decrement
+      typeText("u")
+      assertState("Value: 9${c}9")
+
+      // Undo first decrement
+      typeText("u")
+      assertState("Value: ${c}100")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo decrement with visual selection`() {
+    configureByText("""
+      ${c}10
+      20
+      30
+    """.trimIndent())
+    typeText("Vj<C-X>")  // Visual select first two lines and decrement
+    assertState("""
+      ${c}9
+      19
+      30
+    """.trimIndent())
+    typeText("u")
+    assertState("""
+      ${c}10
+      20
+      30
+    """.trimIndent())
+  }
+
+  @Test
+  fun `test undo decrement with visual selection with oldundo`() {
+    configureByText("""
+      ${c}10
+      20
+      30
+    """.trimIndent())
+    try {
+      enterCommand("set oldundo")
+      typeText("Vj<C-X>")  // Visual select first two lines and decrement
+      assertState("""
+        ${c}9
+        19
+        30
+      """.trimIndent())
+      typeText("u")
+      assertState("""
+        ${c}10
+        20
+        30
+      """.trimIndent())
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo increment and decrement combination`() {
+    configureByText("Number: ${c}50")
+    typeText("<C-A>")
+    assertState("Number: 5${c}1")
+    typeText("<C-X>")
+    assertState("Number: 5${c}0")
+    typeText("<C-X>")
+    assertState("Number: 4${c}9")
+
+    // Undo second decrement
+    typeText("u")
+    assertState("Number: 5${c}0")
+
+    // Undo first decrement
+    typeText("u")
+    assertState("Number: 5${c}1")
+
+    // Undo increment
+    typeText("u")
+    assertState("Number: ${c}50")
+  }
+
+  @Test
+  fun `test undo increment and decrement combination with oldundo`() {
+    configureByText("Number: ${c}50")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-A>")
+      assertState("Number: 5${c}1")
+      typeText("<C-X>")
+      assertState("Number: 5${c}0")
+      typeText("<C-X>")
+      assertState("Number: 4${c}9")
+
+      // Undo second decrement
+      typeText("u")
+      assertState("Number: 5${c}0")
+
+      // Undo first decrement
+      typeText("u")
+      assertState("Number: 5${c}1")
+
+      // Undo increment
+      typeText("u")
+      assertState("Number: ${c}50")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/change/number/ChangeNumberIncActionTest.kt

@@ -19,4 +19,231 @@ class ChangeNumberIncActionTest : VimTestCase() {
   fun `test inc fancy number`() {
     doTest("<C-A>", "1${c}0X0", "10X1", Mode.NORMAL())
   }
+
+  @Test
+  fun `test undo after increment number`() {
+    configureByText("The answer is ${c}42")
+    typeText("<C-A>")
+    assertState("The answer is 4${c}3")
+    typeText("u")
+    assertState("The answer is ${c}42")
+  }
+
+  @Test
+  fun `test undo after increment number with oldundo`() {
+    configureByText("The answer is ${c}42")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-A>")
+      assertState("The answer is 4${c}3")
+      typeText("u")
+      assertState("The answer is ${c}42")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after increment with count`() {
+    configureByText("Count: ${c}10")
+    typeText("5<C-A>")
+    assertState("Count: 1${c}5")
+    typeText("u")
+    assertState("Count: ${c}10")
+  }
+
+  @Test
+  fun `test undo after increment with count with oldundo`() {
+    configureByText("Count: ${c}10")
+    try {
+      enterCommand("set oldundo")
+      typeText("5<C-A>")
+      assertState("Count: 1${c}5")
+      typeText("u")
+      assertState("Count: ${c}10")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after increment negative number`() {
+    configureByText("Temperature: ${c}-5 degrees")
+    typeText("<C-A>")
+    assertState("Temperature: -${c}4 degrees")
+    typeText("u")
+    assertState("Temperature: ${c}-5 degrees")
+  }
+
+  @Test
+  fun `test undo after increment negative number with oldundo`() {
+    configureByText("Temperature: ${c}-5 degrees")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-A>")
+      assertState("Temperature: -${c}4 degrees")
+      typeText("u")
+      assertState("Temperature: ${c}-5 degrees")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test multiple undo after sequential increments`() {
+    configureByText("Value: ${c}100")
+    typeText("<C-A>")
+    assertState("Value: 10${c}1")
+    typeText("<C-A>")
+    assertState("Value: 10${c}2")
+    typeText("<C-A>")
+    assertState("Value: 10${c}3")
+
+    // Undo third increment
+    typeText("u")
+    assertState("Value: 10${c}2")
+
+    // Undo second increment
+    typeText("u")
+    assertState("Value: 10${c}1")
+
+    // Undo first increment
+    typeText("u")
+    assertState("Value: ${c}100")
+  }
+
+  @Test
+  fun `test multiple undo after sequential increments with oldundo`() {
+    configureByText("Value: ${c}100")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-A>")
+      assertState("Value: 10${c}1")
+      typeText("<C-A>")
+      assertState("Value: 10${c}2")
+      typeText("<C-A>")
+      assertState("Value: 10${c}3")
+
+      // Undo third increment
+      typeText("u")
+      assertState("Value: 10${c}2")
+
+      // Undo second increment
+      typeText("u")
+      assertState("Value: 10${c}1")
+
+      // Undo first increment
+      typeText("u")
+      assertState("Value: ${c}100")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo increment with visual selection`() {
+    configureByText(
+      """
+      ${c}10
+      20
+      30
+    """.trimIndent()
+    )
+    typeText("Vj<C-A>")  // Visual select first two lines and increment
+    assertState(
+      """
+      ${c}11
+      21
+      30
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      ${c}10
+      20
+      30
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo increment with visual selection with oldundo`() {
+    configureByText(
+      """
+      ${c}10
+      20
+      30
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("Vj<C-A>")  // Visual select first two lines and increment
+      assertState(
+        """
+      ${c}11
+      21
+      30
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      ${c}10
+      20
+      30
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo increment octal number`() {
+    // OCT is disabled by default
+    configureByText("Octal: ${c}0777")
+    typeText("<C-A>")
+    assertState("Octal: 077${c}8")
+    typeText("u")
+    assertState("Octal: ${c}0777")
+  }
+
+  @Test
+  fun `test undo increment octal number with oldundo`() {
+    // OCT is disabled by default
+    configureByText("Octal: ${c}0777")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-A>")
+      assertState("Octal: 077${c}8")
+      typeText("u")
+      assertState("Octal: ${c}0777")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo increment hex number`() {
+    configureByText("Hex: ${c}0xff")
+    typeText("<C-A>")
+    assertState("Hex: 0x10${c}0")
+    typeText("u")
+    assertState("Hex: ${c}0xff")
+  }
+
+  @Test
+  fun `test undo increment hex number with oldundo`() {
+    configureByText("Hex: ${c}0xff")
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-A>")
+      assertState("Hex: 0x10${c}0")
+      typeText("u")
+      assertState("Hex: ${c}0xff")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/delete/DeleteCharacterLeftActionTest.kt

@@ -130,4 +130,81 @@ class DeleteCharacterLeftActionTest : VimTestCase() {
     assertVisualPosition(0, 55)
     assertVisibleLineBounds(0, 15, 94)
   }
+
+  @Test
+  fun `test undo after deleting character left`() {
+    configureByText("foo f${c}oo")
+    typeText("X")
+    assertState("foo ${c}oo")
+    typeText("u")
+    assertState("foo f${c}oo")
+  }
+
+  @Test
+  fun `test undo after deleting character left with oldundo`() {
+    configureByText("foo f${c}oo")
+    try {
+      enterCommand("set oldundo")
+      typeText("X")
+      assertState("foo ${c}oo")
+      typeText("u")
+      assertState("foo f${c}oo")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after deleting multiple characters left`() {
+    configureByText("abcdef${c}ghijk")
+    typeText("3X")
+    assertState("abc${c}ghijk")
+    typeText("u")
+    assertState("abcdef${c}ghijk")
+  }
+
+  @Test
+  fun `test undo after deleting multiple characters left with oldundo`() {
+    configureByText("abcdef${c}ghijk")
+    try {
+      enterCommand("set oldundo")
+      typeText("3X")
+      assertState("abc${c}ghijk")
+      typeText("u")
+      assertState("abcdef${c}ghijk")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test multiple undo after sequential deletes`() {
+    configureByText("foo bar ${c}baz")
+    typeText("XXX")
+    assertState("foo b${c}baz")
+    typeText("u")
+    assertState("foo ba${c}baz")
+    typeText("u")
+    assertState("foo bar${c}baz")
+    typeText("u")
+    assertState("foo bar ${c}baz")
+  }
+
+  @Test
+  fun `test multiple undo after sequential deletes with oldundo`() {
+    configureByText("foo bar ${c}baz")
+    try {
+      enterCommand("set oldundo")
+      typeText("XXX")
+      assertState("foo b${c}baz")
+      typeText("u")
+      assertState("foo ba${c}baz")
+      typeText("u")
+      assertState("foo bar${c}baz")
+      typeText("u")
+      assertState("foo bar ${c}baz")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/delete/DeleteCharacterRightActionTest.kt

@@ -113,4 +113,31 @@ class DeleteCharacterRightActionTest : VimTestCase() {
     // type annotation
     assertVisualPosition(0, 4)
   }
+
+  @Test
+  fun `undo after deleting character`() {
+    configureByText("foo ${c}foo")
+    typeText("xx")
+    assertState("foo ${c}o")
+    typeText("u")
+    assertState("foo ${c}oo")
+    typeText("u")
+    assertState("foo ${c}foo")
+  }
+
+  @Test
+  fun `undo after deleting character with oldundo`() {
+    configureByText("foo ${c}foo")
+    try {
+      enterCommand("set oldundo")
+      typeText("xx")
+      assertState("foo ${c}o")
+      typeText("u")
+      assertState("foo ${c}oo")
+      typeText("u")
+      assertState("foo ${c}foo")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/delete/DeleteEndOfLineActionTest.kt

@@ -32,4 +32,230 @@ class DeleteEndOfLineActionTest : VimTestCase() {
       Mode.NORMAL(),
     )
   }
+
+  @Test
+  fun `test undo after delete to end of line`() {
+    configureByText("Hello ${c}world and more text")
+    typeText("D")
+    assertState("Hello$c ")
+    typeText("u")
+    assertState("Hello ${c}world and more text")
+  }
+
+  @Test
+  fun `test undo after delete to end of line with count`() {
+    configureByText(
+      """
+      First ${c}line with text
+      Second line
+      Third line
+      Fourth line
+    """.trimIndent()
+    )
+    typeText("2D")
+    assertState(
+      """
+      First$c 
+      Third line
+      Fourth line
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      First ${c}line with text
+      Second line
+      Third line
+      Fourth line
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after delete to end of line at different positions`() {
+    configureByText("abc${c}defghijk")
+    typeText("D")
+    assertState("ab${c}c")
+    typeText("u")
+    assertState("abc${c}defghijk")
+
+    // Move to different position and delete again
+    typeText("0")
+    assertState("${c}abcdefghijk")
+    typeText("D")
+    assertState("$c")
+    typeText("u")
+    assertState("${c}abcdefghijk")
+  }
+
+  @Test
+  fun `test multiple undo after sequential delete to end of line`() {
+    configureByText(
+      """
+      ${c}First line
+      Second line
+      Third line
+    """.trimIndent()
+    )
+    typeText("D")
+    assertState(
+      """
+      $c
+      Second line
+      Third line
+    """.trimIndent()
+    )
+    typeText("j")
+    typeText("D")
+    assertState(
+      """
+      
+      $c
+      Third line
+    """.trimIndent()
+    )
+
+    // Undo second delete
+    typeText("u")
+    assertState(
+      """
+      
+      ${c}Second line
+      Third line
+    """.trimIndent()
+    )
+
+    // Undo first delete
+    typeText("u")
+    assertState(
+      """
+      ${c}First line
+      Second line
+      Third line
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after delete to end of line with oldundo`() {
+    configureByText("Hello ${c}world and more text")
+    try {
+      enterCommand("set oldundo")
+      typeText("D")
+      assertState("Hello$c ")
+      typeText("u")
+      assertState("Hello ${c}world and more text")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after delete to end of line with count with oldundo`() {
+    configureByText(
+      """
+      First ${c}line with text
+      Second line
+      Third line
+      Fourth line
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("2D")
+      assertState(
+        """
+      First$c 
+      Third line
+      Fourth line
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      First ${c}line with text
+      Second line
+      Third line
+      Fourth line
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after delete to end of line at different positions with oldundo`() {
+    configureByText("abc${c}defghijk")
+    try {
+      enterCommand("set oldundo")
+      typeText("D")
+      assertState("ab${c}c")
+      typeText("u")
+      assertState("abc${c}defghijk")
+
+      // Move to different position and delete again
+      typeText("0")
+      assertState("${c}abcdefghijk")
+      typeText("D")
+      assertState("$c")
+      typeText("u")
+      assertState("${c}abcdefghijk")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test multiple undo after sequential delete to end of line with oldundo`() {
+    configureByText(
+      """
+      ${c}First line
+      Second line
+      Third line
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("D")
+      assertState(
+        """
+      $c
+      Second line
+      Third line
+    """.trimIndent()
+      )
+      typeText("j")
+      typeText("D")
+      assertState(
+        """
+      
+      $c
+      Third line
+    """.trimIndent()
+      )
+
+      // Undo second delete
+      typeText("u")
+      assertState(
+        """
+      
+      ${c}Second line
+      Third line
+    """.trimIndent()
+      )
+
+      // Undo first delete
+      typeText("u")
+      assertState(
+        """
+      ${c}
+      Second line
+      Third line
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/delete/DeleteJoinLinesSpacesActionTest.kt

@@ -16,6 +16,7 @@ import org.jetbrains.plugins.ideavim.VimTestCase
 import org.jetbrains.plugins.ideavim.impl.OptionTest
 import org.jetbrains.plugins.ideavim.impl.TraceOptions
 import org.jetbrains.plugins.ideavim.impl.VimOption
+import org.junit.jupiter.api.Test
 
 @TraceOptions
 class DeleteJoinLinesSpacesActionTest : VimTestCase() {
@@ -88,4 +89,280 @@ class DeleteJoinLinesSpacesActionTest : VimTestCase() {
       Mode.NORMAL(),
     )
   }
+
+  @Test
+  fun `test undo after join lines`() {
+    configureByText(
+      """
+      First line
+      ${c}Second line
+      Third line
+    """.trimIndent()
+    )
+    typeText("J")
+    assertState(
+      """
+      First line
+      Second line${c} Third line
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      First line
+      ${c}Second line
+      Third line
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after join multiple lines`() {
+    configureByText(
+      """
+      ${c}Line 1
+      Line 2
+      Line 3
+      Line 4
+    """.trimIndent()
+    )
+    typeText("3J")
+    assertState(
+      """
+      Line 1 Line 2$c Line 3
+      Line 4
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      ${c}Line 1
+      Line 2
+      Line 3
+      Line 4
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after multiple sequential joins`() {
+    configureByText(
+      """
+      ${c}One
+      Two
+      Three
+      Four
+    """.trimIndent()
+    )
+    typeText("J")
+    assertState(
+      """
+      One${c} Two
+      Three
+      Four
+    """.trimIndent()
+    )
+    typeText("J")
+    assertState(
+      """
+      One Two${c} Three
+      Four
+    """.trimIndent()
+    )
+
+    // Undo second join
+    typeText("u")
+    assertState(
+      """
+      One${c} Two
+      Three
+      Four
+    """.trimIndent()
+    )
+
+    // Undo first join
+    typeText("u")
+    assertState(
+      """
+      ${c}One
+      Two
+      Three
+      Four
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo join with special whitespace handling`() {
+    configureByText(
+      """
+      ${c}foo {
+          bar
+      }
+    """.trimIndent()
+    )
+    typeText("J")
+    assertState(
+      """
+      foo {${c} bar
+      }
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      ${c}foo {
+          bar
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after join lines with oldundo`() {
+    configureByText(
+      """
+      First line
+      ${c}Second line
+      Third line
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("J")
+      assertState(
+        """
+      First line
+      Second line${c} Third line
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      First line
+      ${c}Second line
+      Third line
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after join multiple lines with oldundo`() {
+    configureByText(
+      """
+      ${c}Line 1
+      Line 2
+      Line 3
+      Line 4
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("3J")
+      assertState(
+        """
+      Line 1 Line 2$c Line 3
+      Line 4
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      ${c}Line 1
+      Line 2
+      Line 3
+      Line 4
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after multiple sequential joins with oldundo`() {
+    configureByText(
+      """
+      ${c}One
+      Two
+      Three
+      Four
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("J")
+      assertState(
+        """
+      One${c} Two
+      Three
+      Four
+    """.trimIndent()
+      )
+      typeText("J")
+      assertState(
+        """
+      One Two${c} Three
+      Four
+    """.trimIndent()
+      )
+
+      // Undo second join
+      typeText("u")
+      assertState(
+        """
+      One${c} Two
+      Three
+      Four
+    """.trimIndent()
+      )
+
+      // Undo first join
+      typeText("u")
+      assertState(
+        """
+      ${c}One
+      Two
+      Three
+      Four
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo join with special whitespace handling with oldundo`() {
+    configureByText(
+      """
+      ${c}foo {
+          bar
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("J")
+      assertState(
+        """
+      foo {${c} bar
+      }
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      ${c}foo {
+          bar
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/delete/DeleteMotionActionTest.kt

@@ -257,4 +257,298 @@ class DeleteMotionActionTest : VimTestCase() {
     typeText("dd")
     assertStatusLineCleared()
   }
+
+  @Test
+  fun `test undo after delete motion with word`() {
+    configureByText("Hello ${c}world and more text")
+    typeText("dw")
+    assertState("Hello ${c}and more text")
+    typeText("u")
+    assertState("Hello ${c}world and more text")
+  }
+
+  @Test
+  fun `test undo after delete motion with word with oldundo`() {
+    configureByText("Hello ${c}world and more text")
+    try {
+      enterCommand("set oldundo")
+      typeText("dw")
+      assertState("Hello ${c}and more text")
+      typeText("u")
+      assertState("Hello ${c}world and more text")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after delete line`() {
+    configureByText(
+      """
+      First line
+      ${c}Second line
+      Third line
+    """.trimIndent()
+    )
+    typeText("dd")
+    assertState(
+      """
+      First line
+      ${c}Third line
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      First line
+      ${c}Second line
+      Third line
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after delete line with oldundo`() {
+    configureByText(
+      """
+      First line
+      ${c}Second line
+      Third line
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("dd")
+      assertState(
+        """
+      First line
+      ${c}Third line
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      First line
+      ${c}Second line
+      Third line
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after delete multiple lines`() {
+    configureByText(
+      """
+      First line
+      ${c}Second line
+      Third line
+      Fourth line
+      Fifth line
+    """.trimIndent()
+    )
+    typeText("3dd")
+    assertState(
+      """
+      First line
+      ${c}Fifth line
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      First line
+      ${c}Second line
+      Third line
+      Fourth line
+      Fifth line
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after delete multiple lines with oldundo`() {
+    configureByText(
+      """
+      First line
+      ${c}Second line
+      Third line
+      Fourth line
+      Fifth line
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("3dd")
+      assertState(
+        """
+      First line
+      ${c}Fifth line
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      First line
+      ${c}Second line
+      Third line
+      Fourth line
+      Fifth line
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after delete with different motions`() {
+    configureByText("The ${c}quick brown fox jumps")
+    typeText("d3w")
+    assertState("The ${c}jumps")
+    typeText("u")
+    assertState("The ${c}quick brown fox jumps")
+
+    // Test with $ motion
+    typeText("d$")
+    assertState("The$c ")
+    typeText("u")
+    assertState("The ${c}quick brown fox jumps")
+
+    // Test with 0 motion
+    typeText("d0")
+    assertState("${c}quick brown fox jumps")
+    typeText("u")
+    assertState("The ${c}quick brown fox jumps")
+  }
+
+  @Test
+  fun `test undo after delete with different motions with oldundo`() {
+    configureByText("The ${c}quick brown fox jumps")
+    try {
+      enterCommand("set oldundo")
+      typeText("d3w")
+      assertState("The ${c}jumps")
+      typeText("u")
+      assertState("The ${c}quick brown fox jumps")
+
+      // Test with $ motion
+      typeText("d$")
+      assertState("The$c ")
+      typeText("u")
+      assertState("The ${c}quick brown fox jumps")
+
+      // Test with 0 motion
+      typeText("d0")
+      assertState("${c}quick brown fox jumps")
+      typeText("u")
+      assertState("The ${c}quick brown fox jumps")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo delete with motion that includes caret movement`() {
+    configureByText("a${c}bc(xxx)def")
+    typeText("di(")
+    assertState("abc(${c})def")
+    typeText("u")
+    assertState("a${c}bc(xxx)def")
+  }
+
+  @Test
+  fun `test undo delete with motion that includes caret movement with oldundo`() {
+    configureByText("a${c}bc(xxx)def")
+    try {
+      enterCommand("set oldundo")
+      typeText("di(")
+      assertState("abc(${c})def")
+      typeText("u")
+      assertState("a${c}bc(xxx)def")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after delete to mark`() {
+    configureByText(
+      """
+      Line 1
+      Li${c}ne 2
+      Line 3
+      Line 4
+    """.trimIndent()
+    )
+    typeText("ma")  // Set mark a
+    typeText("jj")
+    assertState(
+      """
+      Line 1
+      Line 2
+      Line 3
+      Li${c}ne 4
+    """.trimIndent()
+    )
+    typeText("d'a")  // Delete to mark a
+    assertState(
+      """
+      ${c}Line 1
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      Line 1
+      Line 2
+      Line 3
+      Li${c}ne 4
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after delete to mark with oldundo`() {
+    configureByText(
+      """
+      Line 1
+      Li${c}ne 2
+      Line 3
+      Line 4
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("ma")  // Set mark a
+      typeText("jj")
+      assertState(
+        """
+      Line 1
+      Line 2
+      Line 3
+      Li${c}ne 4
+    """.trimIndent()
+      )
+      typeText("d'a")  // Delete to mark a
+      assertState(
+        """
+      ${c}Line 1
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      Line 1
+      Line 2
+      Line 3
+      Li${c}ne 4
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/insert/InsertDeleteInsertedTextActionTest.kt

@@ -52,4 +52,76 @@ class InsertDeleteInsertedTextActionTest : VimTestCase() {
       Mode.NORMAL(),
     )
   }
+
+  @Test
+  fun `test undo after delete inserted text in insert mode`() {
+    configureByText("Hello ${c}world")
+    typeText("i")
+    typeText("beautiful ")
+    assertState("Hello beautiful ${c}world")
+    assertMode(Mode.INSERT)
+    typeText("<C-U>")
+    assertState("Hello ${c}world")
+    assertMode(Mode.INSERT)
+    typeText("<Esc>")
+    typeText("u")
+    assertState("Hello ${c}world")
+  }
+
+  @Test
+  fun `test undo after delete inserted text in insert mode with oldundo`() {
+    configureByText("Hello ${c}world")
+    try {
+      enterCommand("set oldundo")
+      typeText("i")
+      typeText("beautiful ")
+      assertState("Hello beautiful ${c}world")
+      assertMode(Mode.INSERT)
+      typeText("<C-U>")
+      assertState("Hello ${c}world")
+      assertMode(Mode.INSERT)
+      typeText("<Esc>")
+      typeText("u")
+      assertState("Hello ${c}world")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo preserves text before insertion point`() {
+    configureByText("Start${c}End")
+    typeText("i")
+    typeText(" Middle ")
+    assertState("Start Middle ${c}End")
+    assertMode(Mode.INSERT)
+    typeText("<C-U>")
+    assertState("Start${c}End")
+    assertMode(Mode.INSERT)
+    typeText("<Esc>")
+    assertState("Star${c}tEnd")
+    typeText("u")
+    assertState("Start${c}End")
+  }
+
+  @Test
+  fun `test undo preserves text before insertion point with oldundo`() {
+    configureByText("Start${c}End")
+    try {
+      enterCommand("set oldundo")
+      typeText("i")
+      typeText(" Middle ")
+      assertState("Start Middle ${c}End")
+      assertMode(Mode.INSERT)
+      typeText("<C-U>")
+      assertState("Start${c}End")
+      assertMode(Mode.INSERT)
+      typeText("<Esc>")
+      assertState("Star${c}tEnd")
+      typeText("u")
+      assertState("Start${c}End")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/insert/InsertNewLineAboveActionTest.kt

@@ -15,7 +15,6 @@ import com.maddyhome.idea.vim.state.mode.Mode
 import org.jetbrains.plugins.ideavim.SkipNeovimReason
 import org.jetbrains.plugins.ideavim.TestWithoutNeovim
 import org.jetbrains.plugins.ideavim.VimTestCase
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
@@ -85,7 +84,6 @@ class InsertNewLineAboveActionTest : VimTestCase() {
     doTest("O", before, after, Mode.INSERT)
   }
 
-  @Disabled("Action execution in tests is broken for 2024.2")
   @Test
   fun `test insert new line above with multiple carets`() {
     val before = """    I fou${c}nd it in a legendary land

src/test/java/org/jetbrains/plugins/ideavim/action/change/insert/InsertNewLineBelowActionTest.kt

@@ -12,7 +12,6 @@ import com.maddyhome.idea.vim.state.mode.Mode
 import org.jetbrains.plugins.ideavim.SkipNeovimReason
 import org.jetbrains.plugins.ideavim.TestWithoutNeovim
 import org.jetbrains.plugins.ideavim.VimTestCase
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 
 class InsertNewLineBelowActionTest : VimTestCase() {
@@ -80,7 +79,6 @@ class InsertNewLineBelowActionTest : VimTestCase() {
     doTest("o", before, after, Mode.INSERT)
   }
 
-  @Disabled("Action execution in tests is broken for 2024.2")
   @Test
   fun `test insert new line below with multiple carets`() {
     val before = """    I fou${c}nd it in a legendary land

src/test/java/org/jetbrains/plugins/ideavim/action/change/shift/ShiftLeftTest.kt

@@ -136,4 +136,266 @@ class ShiftLeftTest : VimTestCase() {
       """.trimIndent(),
     )
   }
+
+  @Test
+  fun `test undo after shift left single line`() {
+    configureByText(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText("<<")
+    assertState(
+      """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after shift left with motion`() {
+    configureByText(
+      """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+    typeText("<2j")  // Shift left 3 lines
+    assertState(
+      """
+      func main() {
+      ${c}line1()
+      line2()
+      line3()
+      }
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after shift left visual mode`() {
+    configureByText(
+      """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+    typeText("Vj<")  // Visual select 2 lines and shift left
+    assertState(
+      """
+      func main() {
+      ${c}line1()
+      line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      func main() {
+      ${c}    line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo shift left in insert mode`() {
+    configureByText(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText("i<C-D>")
+    assertState(
+      """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText("<Esc>")
+    typeText("u")
+    assertState(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after shift left single line with oldundo`() {
+    configureByText(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("<<")
+      assertState(
+        """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after shift left with motion with oldundo`() {
+    configureByText(
+      """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("<2j")  // Shift left 3 lines
+      assertState(
+        """
+      func main() {
+      ${c}line1()
+      line2()
+      line3()
+      }
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after shift left visual mode with oldundo`() {
+    configureByText(
+      """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("Vj<")  // Visual select 2 lines and shift left
+      assertState(
+        """
+      func main() {
+      ${c}line1()
+      line2()
+          line3()
+      }
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      func main() {
+      ${c}    line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo shift left in insert mode with oldundo`() {
+    configureByText(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("i<C-D>")
+      assertState(
+        """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+      typeText("<Esc>")
+      typeText("u")
+      assertState(
+        """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/change/shift/ShiftRightTest.kt

@@ -208,4 +208,416 @@ class ShiftRightTest : VimTestCase() {
       """.trimIndent(),
     )
   }
+
+  @Test
+  fun `test undo after shift right single line`() {
+    configureByText(
+      """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText(">>")
+    assertState(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after shift right with motion`() {
+    configureByText(
+      """
+      func main() {
+      ${c}line1()
+      line2()
+      line3()
+      }
+    """.trimIndent()
+    )
+    typeText(">2j")  // Shift right 3 lines
+    assertState(
+      """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      func main() {
+      ${c}line1()
+      line2()
+      line3()
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after shift right visual mode`() {
+    configureByText(
+      """
+      func main() {
+      ${c}line1()
+      line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+    typeText("Vj>")  // Visual select 2 lines and shift right
+    assertState(
+      """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      func main() {
+      ${c}line1()
+      line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test multiple undo after sequential shifts right`() {
+    configureByText("${c}unindented line")
+    typeText(">>")
+    assertState("    ${c}unindented line")
+    typeText(">>")
+    assertState("        ${c}unindented line")
+    typeText(">>")
+    assertState("            ${c}unindented line")
+
+    // Undo third shift
+    typeText("u")
+    assertState("        ${c}unindented line")
+
+    // Undo second shift
+    typeText("u")
+    assertState("    ${c}unindented line")
+
+    // Undo first shift
+    typeText("u")
+    assertState("${c}unindented line")
+  }
+
+  @Test
+  fun `test undo shift right in insert mode`() {
+    configureByText(
+      """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText("i<C-T>")
+    assertState(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText("<Esc>")
+    typeText("u")
+    assertState(
+      """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo shift right and left combination`() {
+    configureByText(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText(">>")  // Shift right
+    assertState(
+      """
+      func main() {
+              ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    typeText("<<")  // Shift left
+    assertState(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+
+    // Undo shift left
+    typeText("u")
+    assertState(
+      """
+      func main() {
+              ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+
+    // Undo shift right
+    typeText("u")
+    assertState(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after shift right single line with oldundo`() {
+    configureByText(
+      """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText(">>")
+      assertState(
+        """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after shift right with motion with oldundo`() {
+    configureByText(
+      """
+      func main() {
+      ${c}line1()
+      line2()
+      line3()
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText(">2j")  // Shift right 3 lines
+      assertState(
+        """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      func main() {
+      ${c}line1()
+      line2()
+      line3()
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after shift right visual mode with oldundo`() {
+    configureByText(
+      """
+      func main() {
+      ${c}line1()
+      line2()
+          line3()
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("Vj>")  // Visual select 2 lines and shift right
+      assertState(
+        """
+      func main() {
+          ${c}line1()
+          line2()
+          line3()
+      }
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      func main() {
+      ${c}line1()
+      line2()
+          line3()
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test multiple undo after sequential shifts right with oldundo`() {
+    configureByText("${c}unindented line")
+    try {
+      enterCommand("set oldundo")
+      typeText(">>")
+      assertState("    ${c}unindented line")
+      typeText(">>")
+      assertState("        ${c}unindented line")
+      typeText(">>")
+      assertState("            ${c}unindented line")
+
+      // Undo third shift
+      typeText("u")
+      assertState("        ${c}unindented line")
+
+      // Undo second shift
+      typeText("u")
+      assertState("    ${c}unindented line")
+
+      // Undo first shift
+      typeText("u")
+      assertState("${c}unindented line")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo shift right in insert mode with oldundo`() {
+    configureByText(
+      """
+      func main() {
+      ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("i<C-T>")
+      assertState(
+        """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+      typeText("<Esc>")
+      typeText("u")
+      assertState(
+        """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo shift right and left combination with oldundo`() {
+    configureByText(
+      """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText(">>")  // Shift right
+      assertState(
+        """
+      func main() {
+              ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+      typeText("<<")  // Shift left
+      assertState(
+        """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+
+      // Undo shift left
+      typeText("u")
+      assertState(
+        """
+      func main() {
+              ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+
+      // Undo shift right
+      typeText("u")
+      assertState(
+        """
+      func main() {
+          ${c}println("Hello")
+      }
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/copy/IdeaPutNotificationsTest.kt

@@ -9,7 +9,6 @@
 package org.jetbrains.plugins.ideavim.action.copy
 
 import com.intellij.notification.ActionCenter
-import com.intellij.notification.EventLog
 import com.intellij.notification.Notification
 import com.intellij.openapi.application.ApplicationManager
 import com.maddyhome.idea.vim.VimPlugin
@@ -81,7 +80,7 @@ class IdeaPutNotificationsTest : VimTestCase() {
     kotlin.test.assertTrue(notifications.isEmpty() || notifications.last().isExpired || OptionConstants.clipboard_ideaput !in notifications.last().content)
   }
 
-  private fun notifications(): MutableList<Notification> {
+  private fun notifications(): List<Notification> {
     return ActionCenter.getNotifications(fixture.project)
   }
 
@@ -105,7 +104,7 @@ class IdeaPutNotificationsTest : VimTestCase() {
     }
     typeText(injector.parser.parseKeys("p"))
 
-    val notifications = EventLog.getLogModel(fixture.project).notifications
+    val notifications = ActionCenter.getNotifications(fixture.project)
     kotlin.test.assertTrue(notifications.isEmpty() || notifications.last().isExpired || OptionConstants.clipboard_ideaput !in notifications.last().content)
   }
 

src/test/java/org/jetbrains/plugins/ideavim/action/copy/PutTestAfterCursorActionTest.kt

@@ -216,4 +216,294 @@ class PutTestAfterCursorActionTest : VimTestCase() {
       )
     }
   }
+
+  @Test
+  fun `test undo after put after cursor`() {
+    configureByText("Hello ${c}world")
+    typeText("yy")
+    typeText("p")
+    assertState(
+      """
+      Hello world
+      ${c}Hello world
+      
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState("Hello ${c}world")
+  }
+
+  @Test
+  fun `test undo after put character after cursor`() {
+    configureByText("abc${c}def")
+    typeText("yl")  // Yank 'd'
+    typeText("h")   // Move left
+    assertState("ab${c}cdef")
+    typeText("p")
+    assertState("abc${c}ddef")
+    typeText("u")
+    assertState("ab${c}cdef")
+  }
+
+  @Test
+  fun `test undo after put word after cursor`() {
+    configureByText("The ${c}quick brown fox")
+    typeText("yiw")  // Yank "quick"
+    typeText("w")    // Move to "brown"
+    assertState("The quick ${c}brown fox")
+    typeText("p")
+    assertState("The quick bquic${c}krown fox")
+    typeText("u")
+    assertState("The quick ${c}brown fox")
+  }
+
+  @Test
+  fun `test multiple undo after sequential puts after cursor`() {
+    configureByText("${c}Hello")
+    typeText("yy")
+    typeText("p")
+    assertState(
+      """
+      Hello
+      ${c}Hello
+      
+    """.trimIndent()
+    )
+    typeText("p")
+    assertState(
+      """
+      Hello
+      Hello
+      ${c}Hello
+      
+    """.trimIndent()
+    )
+
+    // Undo second put
+    typeText("u")
+    assertState(
+      """
+      Hello
+      ${c}Hello
+      
+    """.trimIndent()
+    )
+
+    // Undo first put
+    typeText("u")
+    assertState(
+      """
+      ${c}Hello
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo put and move cursor`() {
+    configureByText("${c}abc def")
+    typeText("yiw")  // Yank "abc"
+    typeText("w")    // Move to "def"
+    assertState("abc ${c}def")
+    typeText("gp")   // Put and move cursor after pasted text
+    assertState("abc dabc${c}ef")
+    typeText("u")
+    assertState("abc ${c}def")
+  }
+
+  @Test
+  fun `test undo put visual block after cursor`() {
+    configureByText(
+      """
+      ${c}abc
+      def
+      ghi
+    """.trimIndent()
+    )
+    typeText("<C-V>jjl")  // Visual block select first 2 columns of all lines
+    typeText("y")
+    typeText("$")
+    assertState(
+      """
+      ab${c}c
+      def
+      ghi
+    """.trimIndent()
+    )
+    typeText("p")
+    assertState(
+      """
+      abc${c}ab
+      defde
+      ghigh
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      ab${c}c
+      def
+      ghi
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after put after cursor with oldundo`() {
+    configureByText("Hello ${c}world")
+    try {
+      enterCommand("set oldundo")
+      typeText("yy")
+      typeText("p")
+      assertState(
+        """
+      Hello world
+      ${c}Hello world
+      
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState("Hello ${c}world")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after put character after cursor with oldundo`() {
+    configureByText("abc${c}def")
+    try {
+      enterCommand("set oldundo")
+      typeText("yl")  // Yank 'd'
+      typeText("h")   // Move left
+      assertState("ab${c}cdef")
+      typeText("p")
+      assertState("abc${c}ddef")
+      typeText("u")
+      assertState("ab${c}cdef")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after put word after cursor with oldundo`() {
+    configureByText("The ${c}quick brown fox")
+    try {
+      enterCommand("set oldundo")
+      typeText("yiw")  // Yank "quick"
+      typeText("w")    // Move to "brown"
+      assertState("The quick ${c}brown fox")
+      typeText("p")
+      assertState("The quick bquic${c}krown fox")
+      typeText("u")
+      assertState("The quick ${c}brown fox")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test multiple undo after sequential puts after cursor with oldundo`() {
+    configureByText("${c}Hello")
+    try {
+      enterCommand("set oldundo")
+      typeText("yy")
+      typeText("p")
+      assertState(
+        """
+      Hello
+      ${c}Hello
+      
+    """.trimIndent()
+      )
+      typeText("p")
+      assertState(
+        """
+      Hello
+      Hello
+      ${c}Hello
+      
+    """.trimIndent()
+      )
+
+      // Undo second put
+      typeText("u")
+      assertState(
+        """
+      Hello
+      ${c}Hello
+      
+    """.trimIndent()
+      )
+
+      // Undo first put
+      typeText("u")
+      assertState(
+        """
+      ${c}Hello
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo put and move cursor with oldundo`() {
+    configureByText("${c}abc def")
+    try {
+      enterCommand("set oldundo")
+      typeText("yiw")  // Yank "abc"
+      typeText("w")    // Move to "def"
+      assertState("abc ${c}def")
+      typeText("gp")   // Put and move cursor after pasted text
+      assertState("abc dabc${c}ef")
+      typeText("u")
+      assertState("abc ${c}def")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo put visual block after cursor with oldundo`() {
+    configureByText(
+      """
+      ${c}abc
+      def
+      ghi
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-V>jjl")  // Visual block select first 2 columns of all lines
+      typeText("y")
+      typeText("$")
+      assertState(
+        """
+      ab${c}c
+      def
+      ghi
+    """.trimIndent()
+      )
+      typeText("p")
+      assertState(
+        """
+      abc${c}ab
+      defde
+      ghigh
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      ab${c}c
+      def
+      ghi
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }

src/test/java/org/jetbrains/plugins/ideavim/action/copy/PutTextBeforeCursorActionTest.kt

@@ -56,4 +56,257 @@ class PutTextBeforeCursorActionTest : VimTestCase() {
     """.trimIndent()
     assertState(after)
   }
+
+  @Test
+  fun `test undo after put before cursor`() {
+    configureByText("Hello ${c}world")
+    typeText("yy")
+    typeText("P")
+    assertState(
+      """
+      ${c}Hello world
+      Hello world
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState("Hello ${c}world")
+  }
+
+  @Test
+  fun `test undo after put character before cursor`() {
+    configureByText("abc${c}def")
+    typeText("yl")  // Yank 'd'
+    typeText("h")   // Move left
+    assertState("ab${c}cdef")
+    typeText("P")
+    assertState("ab${c}dcdef")
+    typeText("u")
+    assertState("ab${c}cdef")
+  }
+
+  @Test
+  fun `test undo after put word before cursor`() {
+    configureByText("The ${c}quick brown fox")
+    typeText("yiw")  // Yank "quick"
+    typeText("w")    // Move to "brown"
+    assertState("The quick ${c}brown fox")
+    typeText("P")
+    assertState("The quick quic${c}kbrown fox")
+    typeText("u")
+    assertState("The quick ${c}brown fox")
+  }
+
+  @Test
+  fun `test multiple undo after sequential puts`() {
+    configureByText("${c}Hello")
+    typeText("yy")
+    typeText("P")
+    assertState(
+      """
+      ${c}Hello
+      Hello
+    """.trimIndent()
+    )
+    typeText("P")
+    assertState(
+      """
+      ${c}Hello
+      Hello
+      Hello
+    """.trimIndent()
+    )
+
+    // Undo second put
+    typeText("u")
+    assertState(
+      """
+      ${c}Hello
+      Hello
+    """.trimIndent()
+    )
+
+    // Undo first put
+    typeText("u")
+    assertState(
+      """
+      ${c}Hello
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo put visual block`() {
+    configureByText(
+      """
+      ${c}abc
+      def
+      ghi
+    """.trimIndent()
+    )
+    typeText("<C-V>jjl")  // Visual block select first 2 columns of all lines
+    typeText("y")
+    typeText("$")
+    assertState(
+      """
+      ab${c}c
+      def
+      ghi
+    """.trimIndent()
+    )
+    typeText("P")
+    assertState(
+      """
+      ab${c}abc
+      dedef
+      ghghi
+    """.trimIndent()
+    )
+    typeText("u")
+    assertState(
+      """
+      ab${c}c
+      def
+      ghi
+    """.trimIndent()
+    )
+  }
+
+  @Test
+  fun `test undo after put before cursor with oldundo`() {
+    configureByText("Hello ${c}world")
+    try {
+      enterCommand("set oldundo")
+      typeText("yy")
+      typeText("P")
+      assertState(
+        """
+      ${c}Hello world
+      Hello world
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState("Hello ${c}world")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after put character before cursor with oldundo`() {
+    configureByText("abc${c}def")
+    try {
+      enterCommand("set oldundo")
+      typeText("yl")  // Yank 'd'
+      typeText("h")   // Move left
+      assertState("ab${c}cdef")
+      typeText("P")
+      assertState("ab${c}dcdef")
+      typeText("u")
+      assertState("ab${c}cdef")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo after put word before cursor with oldundo`() {
+    configureByText("The ${c}quick brown fox")
+    try {
+      enterCommand("set oldundo")
+      typeText("yiw")  // Yank "quick"
+      typeText("w")    // Move to "brown"
+      assertState("The quick ${c}brown fox")
+      typeText("P")
+      assertState("The quick quic${c}kbrown fox")
+      typeText("u")
+      assertState("The quick ${c}brown fox")
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test multiple undo after sequential puts with oldundo`() {
+    configureByText("${c}Hello")
+    try {
+      enterCommand("set oldundo")
+      typeText("yy")
+      typeText("P")
+      assertState(
+        """
+      ${c}Hello
+      Hello
+    """.trimIndent()
+      )
+      typeText("P")
+      assertState(
+        """
+      ${c}Hello
+      Hello
+      Hello
+    """.trimIndent()
+      )
+
+      // Undo second put
+      typeText("u")
+      assertState(
+        """
+      ${c}Hello
+      Hello
+    """.trimIndent()
+      )
+
+      // Undo first put
+      typeText("u")
+      assertState(
+        """
+      ${c}Hello
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
+
+  @Test
+  fun `test undo put visual block with oldundo`() {
+    configureByText(
+      """
+      ${c}abc
+      def
+      ghi
+    """.trimIndent()
+    )
+    try {
+      enterCommand("set oldundo")
+      typeText("<C-V>jjl")  // Visual block select first 2 columns of all lines
+      typeText("y")
+      typeText("$")
+      assertState(
+        """
+      ab${c}c
+      def
+      ghi
+    """.trimIndent()
+      )
+      typeText("P")
+      assertState(
+        """
+      ab${c}abc
+      dedef
+      ghghi
+    """.trimIndent()
+      )
+      typeText("u")
+      assertState(
+        """
+      ab${c}c
+      def
+      ghi
+    """.trimIndent()
+      )
+    } finally {
+      enterCommand("set nooldundo")
+    }
+  }
 }